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
  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         free(sPtr);
  64         return NULL;
  65     }
  66     sPtr->viewport = W_CreateView(sPtr->view);
  67     if (!sPtr->view) {
  68         W_DestroyView(sPtr->view);
  69         free(sPtr);
  70         return NULL;
  71     }
  72     sPtr->view->self = sPtr;
  73
  74     sPtr->view->delegate = &_ScrollViewViewDelegate;
  75
  76     sPtr->viewport->flags.mapWhenRealized = 1;
  77
  78     WMCreateEventHandler(sPtr->view, StructureNotifyMask|ExposureMask,
  79                          handleEvents, sPtr);
  80     WMCreateEventHandler(sPtr->viewport, SubstructureNotifyMask,
  81                          handleViewportEvents, sPtr);
  82
  83     sPtr->lineScroll = 4;
  84
  85     sPtr->pageScroll = 0;
  86
  87     return sPtr;
  88 }
  89
  90
  91
  92 static void
  93 reorganizeInterior(WMScrollView *sPtr)
  94 {
  95     int hx, hy, hw;
  96     int vx, vy, vh;
  97     int cx, cy, cw, ch;
  98
  99
 100     cw = hw = sPtr->view->size.width;
 101     vh = ch = sPtr->view->size.height;
 102
 103     if (sPtr->flags.relief == WRSimple) {
 104         cw -= 2;
 105         ch -= 2;
 106         cx = 1;
 107         cy = 1;
 108     } else if (sPtr->flags.relief != WRFlat) {
 109         cw -= 3;
 110         ch -= 3;
 111         cx = 2;
 112         cy = 2;
 113     } else {
 114         cx = 0;
 115         cy = 0;
 116     }
 117
 118     if (sPtr->flags.hasHScroller) {
 119         int h = W_VIEW(sPtr->hScroller)->size.height;
 120
 121         ch -= h;
 122
 123         if (sPtr->flags.relief == WRSimple) {
 124             hx = 0;
 125             hy = sPtr->view->size.height - h;
 126         } else if (sPtr->flags.relief != WRFlat) {
 127             hx = 1;
 128             hy = sPtr->view->size.height - h - 1;
 129             hw -= 2;
 130         } else {
 131             hx = 0;
 132             hy = sPtr->view->size.height - h;
 133         }
 134     } else {
 135         /* make compiler shutup */
 136         hx = 0;
 137         hy = 0;
 138     }
 139
 140     if (sPtr->flags.hasVScroller) {
 141         int w = W_VIEW(sPtr->vScroller)->size.width;
 142         cw -= w;
 143         cx += w;
 144         hx += w - 1;
 145         hw -= w - 1;
 146
 147         if (sPtr->flags.relief == WRSimple) {
 148             vx = 0;
 149             vy = 0;
 150         } else if (sPtr->flags.relief != WRFlat) {
 151             vx = 1;
 152             vy = 1;
 153             vh -= 2;
 154         } else {
 155             vx = 0;
 156             vy = 0;
 157         }
 158     } else {
 159         /* make compiler shutup */
 160         vx = 0;
 161         vy = 0;
 162     }
 163
 164     W_ResizeView(sPtr->viewport, cw, ch);
 165     W_MoveView(sPtr->viewport, cx, cy);
 166
 167     if (sPtr->flags.hasHScroller) {
 168         WMResizeWidget(sPtr->hScroller, hw, 20);
 169         WMMoveWidget(sPtr->hScroller, hx, hy);
 170     }
 171     if (sPtr->flags.hasVScroller) {
 172         WMResizeWidget(sPtr->vScroller, 20, vh);
 173         WMMoveWidget(sPtr->vScroller, vx, vy);
 174     }
 175 }
 176
 177
 178 static void
 179 resizeScrollView(W_ViewDelegate *self, WMView *view)
 180 {
 181     reorganizeInterior(view->self);
 182 }
 183
 184
 185
 186 void
 187 WMResizeScrollViewContent(WMScrollView *sPtr, unsigned int width,
 188                           unsigned int height)
 189 {
 190     int w, h, x;
 191
 192     w = width;
 193     h = height;
 194
 195     x = 0;
 196     if (sPtr->flags.relief == WRSimple) {
 197         w += 2;
 198         h += 2;
 199     } else if (sPtr->flags.relief != WRFlat) {
 200         w += 4;
 201         h += 4;
 202         x = 1;
 203     }
 204
 205     if (sPtr->flags.hasVScroller) {
 206         w -= W_VIEW(sPtr->hScroller)->size.width;
 207         WMResizeWidget(sPtr->vScroller, 20, h);
 208     }
 209     if (sPtr->flags.hasHScroller) {
 210         h -= W_VIEW(sPtr->hScroller)->size.height;
 211         WMResizeWidget(sPtr->hScroller, w, 20);
 212         WMMoveWidget(sPtr->hScroller, x, h);
 213     }
 214
 215     W_ResizeView(sPtr->view, w, h);
 216
 217     W_ResizeView(sPtr->viewport, width, height);
 218 }
 219
 220
 221 void
 222 WMSetScrollViewLineScroll(WMScrollView *sPtr, int amount)
 223 {
 224     assert(amount > 0);
 225
 226     sPtr->lineScroll = amount;
 227 }
 228
 229
 230 void
 231 WMSetScrollViewPageScroll(WMScrollView *sPtr, int amount)
 232 {
 233     assert(amount >= 0);
 234
 235     sPtr->pageScroll = amount;
 236 }
 237
 238
 239 static void
 240 doScrolling(WMWidget *self, void *data)
 241 {
 242     ScrollView *sPtr = (ScrollView*)data;
 243     float value;
 244     int pos;
 245     int vpsize;
 246     float size;
 247
 248     if (sPtr->hScroller == (WMScroller *)self) {
 249         pos = -sPtr->contentView->pos.x;
 250         size = sPtr->contentView->size.width-sPtr->viewport->size.width;
 251         vpsize = sPtr->viewport->size.width - sPtr->pageScroll;
 252     } else {
 253         pos = -sPtr->contentView->pos.y;
 254         size = sPtr->contentView->size.height-sPtr->viewport->size.height;
 255         vpsize = sPtr->viewport->size.height - sPtr->pageScroll;
 256     }
 257     if (vpsize <= 0)
 258         vpsize = 1;
 259
 260     switch (WMGetScrollerHitPart(self)) {
 261      case WSDecrementLine:
 262         if (pos > 0) {
 263             pos-=sPtr->lineScroll;
 264             if (pos < 0)
 265                 pos = 0;
 266             value = (float)pos / size;
 267             WMSetScrollerParameters(self, value,
 268                                     WMGetScrollerKnobProportion(self));
 269         }
 270         break;
 271      case WSIncrementLine:
 272         if (pos < size) {
 273             pos+=sPtr->lineScroll;
 274             if (pos > size)
 275                 pos = size;
 276             value = (float)pos / size;
 277             WMSetScrollerParameters(self, value,
 278                                     WMGetScrollerKnobProportion(self));
 279         }
 280         break;
 281      case WSKnob:
 282         value = WMGetScrollerValue(self);
 283         pos = value*size;
 284         break;
 285
 286      case WSDecrementPage:
 287         if (pos > 0) {
 288             pos -= vpsize;
 289             if (pos < 0)
 290                 pos = 0;
 291             value = (float)pos / size;
 292             WMSetScrollerParameters(self, value,
 293                                     WMGetScrollerKnobProportion(self));
 294         }
 295         break;
 296
 297      case WSIncrementPage:
 298         if (pos < size) {
 299             pos += vpsize;
 300             if (pos > size)
 301                 pos = size;
 302             value = (float)pos / size;
 303             WMSetScrollerParameters(self, value,
 304                                     WMGetScrollerKnobProportion(self));
 305         }
 306         break;
 307
 308      case WSNoPart:
 309      case WSKnobSlot:
 310         break;
 311     }
 312
 313     if (sPtr->hScroller == (WMScroller *)self) {
 314         W_MoveView(sPtr->contentView, -pos, sPtr->contentView->pos.y);
 315     } else {
 316         W_MoveView(sPtr->contentView, sPtr->contentView->pos.x, -pos);
 317     }
 318 }
 319
 320
 321 WMScroller*
 322 WMGetScrollViewHorizontalScroller(WMScrollView *sPtr)
 323 {
 324     return sPtr->hScroller;
 325 }
 326
 327
 328
 329 WMScroller*
 330 WMGetScrollViewVerticalScroller(WMScrollView *sPtr)
 331 {
 332     return sPtr->vScroller;
 333 }
 334
 335
 336 void
 337 WMSetScrollViewHasHorizontalScroller(WMScrollView *sPtr, Bool flag)
 338 {
 339     if (flag) {
 340         if (sPtr->flags.hasHScroller)
 341             return;
 342         sPtr->flags.hasHScroller = 1;
 343
 344         sPtr->hScroller = WMCreateScroller(sPtr);
 345         WMSetScrollerAction(sPtr->hScroller, doScrolling, sPtr);
 346         /* make it a horiz. scroller */
 347         WMResizeWidget(sPtr->hScroller, 2, 1);
 348
 349         reorganizeInterior(sPtr);
 350
 351         WMMapWidget(sPtr->hScroller);
 352     } else {
 353         if (!sPtr->flags.hasHScroller)
 354             return;
 355
 356         WMUnmapWidget(sPtr->hScroller);
 357         WMDestroyWidget(sPtr->hScroller);
 358         sPtr->hScroller = NULL;
 359         sPtr->flags.hasHScroller = 0;
 360
 361         reorganizeInterior(sPtr);
 362     }
 363 }
 364
 365
 366 void
 367 WMSetScrollViewHasVerticalScroller(WMScrollView *sPtr, Bool flag)
 368 {
 369     if (flag) {
 370         if (sPtr->flags.hasVScroller)
 371             return;
 372         sPtr->flags.hasVScroller = 1;
 373
 374         sPtr->vScroller = WMCreateScroller(sPtr);
 375         WMSetScrollerAction(sPtr->vScroller, doScrolling, sPtr);
 376         WMSetScrollerArrowsPosition(sPtr->vScroller, WSAMaxEnd);
 377         /* make it a vert. scroller */
 378         WMResizeWidget(sPtr->vScroller, 1, 2);
 379
 380         reorganizeInterior(sPtr);
 381
 382         WMMapWidget(sPtr->vScroller);
 383     } else {
 384         if (!sPtr->flags.hasVScroller)
 385             return;
 386         sPtr->flags.hasVScroller = 0;
 387
 388         WMUnmapWidget(sPtr->vScroller);
 389         WMDestroyWidget(sPtr->vScroller);
 390         sPtr->vScroller = NULL;
 391
 392         reorganizeInterior(sPtr);
 393     }
 394 }
 395
 396
 397 void
 398 WMSetScrollViewContentView(WMScrollView *sPtr, WMView *view)
 399 {
 400     assert(sPtr->contentView == NULL);
 401
 402     sPtr->contentView = view;
 403
 404     W_ReparentView(sPtr->contentView, sPtr->viewport, 0, 0);
 405
 406     if (sPtr->flags.hasHScroller) {
 407         float prop;
 408
 409         prop = (float)sPtr->viewport->size.width/sPtr->contentView->size.width;
 410         WMSetScrollerParameters(sPtr->hScroller, 0, prop);
 411     }
 412     if (sPtr->flags.hasVScroller) {
 413         float prop;
 414
 415         prop = (float)sPtr->viewport->size.height/sPtr->contentView->size.height;
 416
 417         WMSetScrollerParameters(sPtr->vScroller, 0, prop);
 418     }
 419 }
 420
 421
 422 void
 423 WMSetScrollViewRelief(WMScrollView *sPtr, WMReliefType type)
 424 {
 425     sPtr->flags.relief = type;
 426
 427     if (sPtr->view->flags.mapped)
 428         paintScrollView(sPtr);
 429
 430
 431 }
 432
 433
 434 static void
 435 paintScrollView(ScrollView *sPtr)
 436 {
 437     W_DrawRelief(sPtr->view->screen, sPtr->view->window, 0, 0,
 438                  sPtr->view->size.width, sPtr->view->size.height,
 439                  sPtr->flags.relief);
 440 }
 441
 442
 443 static void
 444 updateScrollerProportion(ScrollView *sPtr)
 445 {
 446     float prop, value;
 447
 448     if (sPtr->flags.hasHScroller) {
 449         prop = (float)sPtr->viewport->size.width/sPtr->contentView->size.width;
 450         value = WMGetScrollerValue(sPtr->hScroller);
 451
 452         WMSetScrollerParameters(sPtr->hScroller, value, prop);
 453     }
 454     if (sPtr->flags.hasVScroller) {
 455         prop = (float)sPtr->viewport->size.height/sPtr->contentView->size.height;
 456
 457         value = WMGetScrollerValue(sPtr->vScroller);
 458
 459         WMSetScrollerParameters(sPtr->vScroller, value, prop);
 460     }
 461 }
 462
 463
 464 static void
 465 handleViewportEvents(XEvent *event, void *data)
 466 {
 467     ScrollView *sPtr = (ScrollView*)data;
 468
 469     if (sPtr->contentView
 470         && event->xconfigure.window == sPtr->contentView->window)
 471         updateScrollerProportion(sPtr);
 472 }
 473
 474
 475 static void
 476 handleEvents(XEvent *event, void *data)
 477 {
 478     ScrollView *sPtr = (ScrollView*)data;
 479
 480     CHECK_CLASS(data, WC_ScrollView);
 481
 482     switch (event->type) {
 483      case Expose:
 484         if (event->xexpose.count!=0)
 485             break;
 486         paintScrollView(sPtr);
 487         break;
 488
 489      case DestroyNotify:
 490         destroyScrollView(sPtr);
 491         break;
 492
 493     }
 494 }
 495
 496
 497 static void
 498 destroyScrollView(ScrollView *sPtr)
 499 {
 500
 501
 502     free(sPtr);
 503 }
 504