WINGs/wsplitview.c

   1
   2
   3
   4
   5 #include "WINGsP.h"
   6
   7 /*
   8 char *WMSplitViewDidResizeSubviewsNotification
   9     = "WMSplitViewDidResizeSubviewsNotification";
  10 char *WMSplitViewWillResizeSubviewsNotification
  11     = "WMSplitViewWillResizeSubviewsNotification";
  12 */
  13
  14 typedef struct _T_SplitViewSubview {
  15     WMView *view;
  16     int minSize;
  17     int maxSize;
  18     int size;
  19     int pos;
  20 } T_SplitViewSubview;
  21
  22
  23 typedef struct W_SplitView {
  24     W_Class widgetClass;
  25     W_View *view;
  26
  27     WMBag *subviewsBag;
  28
  29     WMSplitViewConstrainProc *constrainProc;
  30
  31     struct {
  32         unsigned int vertical:1;
  33         unsigned int adjustOnPaint:1;
  34         unsigned int subviewsWereManuallyMoved:1;
  35     } flags;
  36
  37     /* WMSplitViewResizeSubviewsProc *resizeSubviewsProc; */
  38
  39 } SplitView;
  40
  41
  42 #define DIVIDER_THICKNESS   8
  43 #define MIN_SUBVIEW_SIZE    4
  44 #define MAX_SUBVIEW_SIZE    -1
  45
  46
  47 #define _GetSubviewsCount() WMGetBagItemCount(sPtr->subviewsBag)
  48
  49 #define _AddPSubviewStruct(P) \
  50 (WMPutInBag(sPtr->subviewsBag,((void*)P)))
  51
  52 #define _GetPSubviewStructAt(i) \
  53 ((T_SplitViewSubview*)WMGetFromBag(sPtr->subviewsBag,(i)))
  54
  55 #define _GetSubviewAt(i) \
  56 (((T_SplitViewSubview*)WMGetFromBag(sPtr->subviewsBag,(i)))->view)
  57
  58 #define _GetMinSizeAt(i) \
  59 (((T_SplitViewSubview*)WMGetFromBag(sPtr->subviewsBag,(i)))->minSize)
  60
  61 #define _GetMaxSizeAt(i) \
  62 (((T_SplitViewSubview*)WMGetFromBag(sPtr->subviewsBag,(i)))->maxSize)
  63
  64 #define _GetSizeAt(i) \
  65 (((T_SplitViewSubview*)WMGetFromBag(sPtr->subviewsBag,(i)))->size)
  66
  67 #define _GetPosAt(i) \
  68 (((T_SplitViewSubview*)WMGetFromBag(sPtr->subviewsBag,(i)))->pos)
  69
  70 #define _GetSplitViewSize() \
  71 ((sPtr->flags.vertical) ? sPtr->view->size.width : sPtr->view->size.height)
  72
  73 static void destroySplitView(SplitView *sPtr);
  74 static void paintSplitView(SplitView *sPtr);
  75
  76 static void handleEvents(XEvent *event, void *data);
  77 static void handleActionEvents(XEvent *event, void *data);
  78
  79
  80 static void
  81 getConstraints(SplitView *sPtr, int index, int *minSize, int *maxSize)
  82 {
  83     *minSize = MIN_SUBVIEW_SIZE;
  84     *maxSize = MAX_SUBVIEW_SIZE;
  85
  86     if (sPtr->constrainProc)
  87         (*sPtr->constrainProc)(sPtr, index, minSize, maxSize);
  88
  89     if (*minSize < MIN_SUBVIEW_SIZE)
  90         *minSize = MIN_SUBVIEW_SIZE;
  91
  92     if (*maxSize < MIN_SUBVIEW_SIZE)
  93         *maxSize = MAX_SUBVIEW_SIZE;
  94     else if (*maxSize < *minSize)
  95         *maxSize = *minSize;
  96 }
  97
  98
  99 static void
 100 updateConstraints(SplitView *sPtr)
 101 {
 102     T_SplitViewSubview *p;
 103     int i, count;
 104
 105     count = _GetSubviewsCount();
 106     for (i = 0; i < count; i++) {
 107         p = _GetPSubviewStructAt(i);
 108         getConstraints(sPtr, i, &(p->minSize), &(p->maxSize));
 109     }
 110 }
 111
 112
 113 static void
 114 resizeView(SplitView *sPtr, WMView *view, int size)
 115 {
 116     int width, height;
 117
 118     if (sPtr->flags.vertical) {
 119         width = size;
 120         height = sPtr->view->size.height;
 121     } else {
 122         width = sPtr->view->size.width;
 123         height = size;
 124     }
 125
 126     if (view->self)
 127         WMResizeWidget(view->self, width, height);
 128     else
 129         W_ResizeView(view, width, height);
 130 }
 131
 132
 133 static void
 134 reparentView(SplitView *sPtr, WMView *view, int pos)
 135 {
 136     int x, y;
 137
 138     if (sPtr->flags.vertical) {
 139         x = pos;
 140         y = 0;
 141     } else {
 142         x = 0;
 143         y = pos;
 144     }
 145
 146     W_ReparentView(view, sPtr->view, x, y);
 147 }
 148
 149
 150 static void
 151 moveView(SplitView *sPtr, WMView *view, int pos)
 152 {
 153     int x, y;
 154
 155     if (sPtr->flags.vertical) {
 156         x = pos;
 157         y = 0;
 158     } else {
 159         x = 0;
 160         y = pos;
 161     }
 162
 163     if (view->self)
 164         WMMoveWidget(view->self, x, y);
 165     else
 166         W_MoveView(view, x, y);
 167 }
 168
 169
 170 static int
 171 checkSizes(SplitView *sPtr)
 172 {
 173     int i, count, offset;
 174     T_SplitViewSubview *p;
 175
 176     count = _GetSubviewsCount();
 177     offset = 0;
 178     for (i = 0; i < count; i++) {
 179         p = _GetPSubviewStructAt(i);
 180         if (p->size < p->minSize) {
 181             offset += p->minSize - p->size;
 182             p->size = p->minSize;
 183         } else if (p->maxSize != MAX_SUBVIEW_SIZE && p->size > p->maxSize) {
 184             offset += p->maxSize - p->size;
 185             p->size = p->maxSize;
 186         }
 187     }
 188
 189     return (offset);
 190 }
 191
 192
 193 static void
 194 checkPositions(SplitView *sPtr)
 195 {
 196     int i, count, pos;
 197     T_SplitViewSubview *p;
 198
 199     count = _GetSubviewsCount();
 200     pos = 0;
 201     for (i = 0; i < count; i++) {
 202         p = _GetPSubviewStructAt(i);
 203         p->pos = pos;
 204         pos += p->size + DIVIDER_THICKNESS;
 205     }
 206 }
 207
 208
 209 static void
 210 updateSubviewsGeom(SplitView *sPtr)
 211 {
 212     int i, count;
 213     T_SplitViewSubview *p;
 214
 215     count = _GetSubviewsCount();
 216     for (i = 0; i < count; i++) {
 217         p = _GetPSubviewStructAt(i);
 218         resizeView(sPtr, p->view, p->size);
 219         moveView(sPtr, p->view, p->pos);
 220     }
 221 }
 222
 223
 224 static int
 225 getTotalSize(SplitView *sPtr)
 226 {
 227     int i, count, totSize;
 228
 229     count = _GetSubviewsCount();
 230     if (!count)
 231         return (0);
 232
 233     totSize = 0;
 234     for (i = 0; i < count; i++)
 235         totSize += _GetSizeAt(i) + DIVIDER_THICKNESS;
 236
 237     return (totSize - DIVIDER_THICKNESS);
 238 }
 239
 240
 241 static Bool
 242 distributeOffsetEqually(SplitView *sPtr, int offset)
 243 {
 244     T_SplitViewSubview *p;
 245     int i, count, sizeChanged, forced;
 246
 247     if ((count = _GetSubviewsCount()) < 1)
 248         return (True);
 249
 250     forced = False;
 251     while (offset != 0) {
 252         sizeChanged = 0;
 253         for (i = 0; i < count && offset != 0; i++) {
 254             p = _GetPSubviewStructAt(i);
 255             if (offset < 0) {
 256                 if (p->size > p->minSize) {
 257                     offset++;
 258                     p->size--;
 259                     sizeChanged = 1;
 260                 }
 261             } else if (p->maxSize == MAX_SUBVIEW_SIZE || p->size < p->maxSize) {
 262                 offset--;
 263                 p->size++;
 264                 sizeChanged = 1;
 265             }
 266         }
 267         if (offset != 0 && !sizeChanged) {
 268             p = _GetPSubviewStructAt(count-1);
 269             if (offset > 0) {
 270                 p->size += offset;
 271                 p->maxSize = MAX_SUBVIEW_SIZE;
 272             }
 273             offset = 0;
 274             forced = True;
 275         }
 276     }
 277
 278     return (forced);
 279 }
 280
 281
 282 static Bool
 283 distributeOffsetFormEnd(SplitView *sPtr, int offset)
 284 {
 285     T_SplitViewSubview *p;
 286     int i, count, sizeTmp;
 287
 288     if ((count = _GetSubviewsCount()) < 1)
 289         return (True);
 290
 291     for (i = count-1; i >= 0 && offset != 0; i--) {
 292         p = _GetPSubviewStructAt(i);
 293         sizeTmp = p->size;
 294         if (offset > 0) {
 295             if (p->maxSize == MAX_SUBVIEW_SIZE || p->size + offset < p->maxSize)
 296                 p->size += offset;
 297             else
 298                 p->size = p->maxSize;
 299         } else {
 300             if (p->size + offset >= p->minSize)
 301                 p->size += offset;
 302             else
 303                 p->size = p->minSize;
 304         }
 305         offset -= p->size - sizeTmp;
 306     }
 307
 308     return (offset == 0);
 309 }
 310
 311
 312 static void
 313 adjustSplitViewSubviews(WMSplitView *sPtr)
 314 {
 315     T_SplitViewSubview *p;
 316     int i, count, adjSize, adjPad;
 317
 318     CHECK_CLASS(sPtr, WC_SplitView);
 319
 320 #if 0
 321     printf("---- (adjustSplitViewSubviews - 1) ----\n");
 322     dumpSubviews(sPtr);
 323 #endif
 324
 325     if ((count = _GetSubviewsCount()) < 1)
 326         return;
 327
 328     adjSize = (_GetSplitViewSize() - ((count-1) * DIVIDER_THICKNESS))  / count;
 329     adjPad =  (_GetSplitViewSize() - ((count-1) * DIVIDER_THICKNESS)) % count;
 330     for (i = 0; i < count; i++) {
 331         p = _GetPSubviewStructAt(i);
 332         p->size = adjSize;
 333     }
 334
 335     distributeOffsetEqually(sPtr, adjPad - checkSizes(sPtr));
 336
 337     checkPositions(sPtr);
 338     updateSubviewsGeom(sPtr);
 339
 340     sPtr->flags.subviewsWereManuallyMoved = 0;
 341
 342 #if 0
 343     printf("---- (adjustSplitViewSubviews - 2) ----\n");
 344     dumpSubviews(sPtr);
 345 #endif
 346 }
 347
 348 #if 0
 349 static void
 350 handleSubviewResized(void *self, WMNotification *notif)
 351 {
 352     SplitView *sPtr = (SplitView*)self;
 353
 354     CHECK_CLASS(sPtr, WC_SplitView);
 355
 356     if (WMGetNotificationName(notif) == WMViewSizeDidChangeNotification) {
 357         T_SplitViewSubview *p;
 358         int i, count, done;
 359         WMView *view = WMGetNotificationObject(notif);
 360
 361         count = _GetSubviewsCount();
 362         done = 0;
 363         for (i = 0; i < count; i++) {
 364             p = _GetPSubviewStructAt(i);
 365             if (p->view == view) {
 366                 done = 1;
 367                 break;
 368             }
 369         }
 370
 371         if (done) {
 372             /* TODO !!! */
 373             resizeView(sPtr, p->view, p->size);
 374             moveView(sPtr, p->view, p->pos);
 375         }
 376     }
 377 }
 378 #endif
 379
 380 static void
 381 handleViewResized(void *self, WMNotification *notification)
 382 {
 383     SplitView *sPtr = (SplitView*)self;
 384
 385 #if 0
 386     printf("---- (handleViewResized - 1) ----\n");
 387     dumpSubviews(sPtr);
 388 #endif
 389
 390     updateConstraints(sPtr);
 391     checkSizes(sPtr);
 392
 393     if (sPtr->constrainProc || sPtr->flags.subviewsWereManuallyMoved) {
 394         distributeOffsetFormEnd(sPtr, _GetSplitViewSize() - getTotalSize(sPtr));
 395         checkPositions(sPtr);
 396         updateSubviewsGeom(sPtr);
 397     } else
 398         adjustSplitViewSubviews(sPtr);
 399
 400     assert(checkSizes(sPtr) == 0);
 401
 402 #if 0
 403     printf("---- (handleViewResized - 2) ----\n");
 404     dumpSubviews(sPtr);
 405 #endif
 406 }
 407
 408
 409 static void
 410 paintSplitView(SplitView *sPtr)
 411 {
 412     T_SplitViewSubview *p;
 413     W_Screen *scr = sPtr->view->screen;
 414     int x, y, i, count;
 415     WMPixmap *dimple = scr->scrollerDimple;
 416
 417 #if 0
 418     printf("---- (paintSplitView - 1) ----\n");
 419     dumpSubviews(sPtr);
 420 #endif
 421
 422     if (!sPtr->view->flags.mapped || !sPtr->view->flags.realized)
 423         return;
 424
 425     XClearWindow(scr->display, sPtr->view->window);
 426
 427     count = _GetSubviewsCount();
 428     if (count == 0)
 429         return;
 430
 431     if (sPtr->flags.adjustOnPaint) {
 432         handleViewResized(sPtr, NULL);
 433         sPtr->flags.adjustOnPaint = 0;
 434     }
 435
 436     XSetClipMask(scr->display, scr->clipGC, dimple->mask);
 437
 438     if (sPtr->flags.vertical) {
 439         x = ((DIVIDER_THICKNESS - dimple->width) / 2);
 440         y = (sPtr->view->size.height - dimple->height)/2;
 441     } else {
 442         x = (sPtr->view->size.width - dimple->width)/2;
 443         y = ((DIVIDER_THICKNESS - dimple->height) / 2);
 444     }
 445
 446     for (i = 0; i < count-1; i++) {
 447         p = _GetPSubviewStructAt(i);
 448
 449         if (sPtr->flags.vertical)
 450             x += p->size;
 451         else
 452             y += p->size;
 453
 454         XSetClipOrigin(scr->display, scr->clipGC, x, y);
 455         XCopyArea(scr->display, dimple->pixmap, sPtr->view->window,
 456                   scr->clipGC, 0, 0, dimple->width, dimple->height, x, y);
 457
 458         if (sPtr->flags.vertical)
 459             x += DIVIDER_THICKNESS;
 460         else
 461             y += DIVIDER_THICKNESS;
 462     }
 463
 464 #if 0
 465     printf("---- (paintSplitView - 2) ----\n");
 466     dumpSubviews(sPtr);
 467 #endif
 468 }
 469
 470
 471 static void
 472 drawDragingRectangle(SplitView *sPtr, int pos)
 473 {
 474     int x, y, w, h;
 475
 476     if (sPtr->flags.vertical) {
 477         x = pos;
 478         y = 0;
 479         w = DIVIDER_THICKNESS;
 480         h = sPtr->view->size.height;
 481     } else {
 482         x = 0;
 483         y = pos;
 484         w = sPtr->view->size.width;
 485         h = DIVIDER_THICKNESS;
 486     }
 487
 488     XFillRectangle(sPtr->view->screen->display, sPtr->view->window,
 489                    sPtr->view->screen->ixorGC, x, y, w, h);
 490 }
 491
 492
 493 static void
 494 getMinMaxDividerCoord(SplitView *sPtr, int divider, int *minC, int *maxC)
 495 {
 496     int relMinC, relMaxC;
 497     int totSize = _GetSizeAt(divider) + _GetSizeAt(divider+1);
 498
 499     relMinC = _GetMinSizeAt(divider);
 500     if (_GetMaxSizeAt(divider+1) != MAX_SUBVIEW_SIZE
 501      && relMinC < totSize - _GetMaxSizeAt(divider+1))
 502         relMinC = totSize - _GetMaxSizeAt(divider+1);
 503
 504     relMaxC = totSize - _GetMinSizeAt(divider+1);
 505     if (_GetMaxSizeAt(divider) != MAX_SUBVIEW_SIZE
 506      && relMaxC > _GetMaxSizeAt(divider))
 507         relMaxC = _GetMaxSizeAt(divider);
 508
 509     *minC = _GetPosAt(divider) + relMinC;
 510     *maxC = _GetPosAt(divider) + relMaxC;
 511 }
 512
 513
 514 static void
 515 dragDivider(SplitView *sPtr, int clickX, int clickY)
 516 {
 517     int divider, pos, ofs, done, dragging;
 518     int i, count;
 519     XEvent ev;
 520     WMScreen *scr;
 521     int minCoord, maxCoord, coord;
 522
 523     if (sPtr->constrainProc) {
 524         updateConstraints(sPtr);
 525         checkSizes(sPtr);
 526         distributeOffsetFormEnd(sPtr, _GetSplitViewSize() - getTotalSize(sPtr));
 527         checkPositions(sPtr);
 528         updateSubviewsGeom(sPtr);
 529     }
 530
 531     scr = sPtr->view->screen;
 532     divider = ofs = pos = done = 0;
 533     coord = (sPtr->flags.vertical) ? clickX : clickY;
 534     count = _GetSubviewsCount();
 535     if (count < 2)
 536         return;
 537
 538     for (i = 0; i < count-1; i++) {
 539         pos += _GetSizeAt(i) + DIVIDER_THICKNESS;
 540         if (coord < pos) {
 541             ofs = coord - pos + DIVIDER_THICKNESS;
 542             done = 1;
 543             break;
 544         }
 545         divider++;
 546     }
 547
 548     if (!done)
 549         return;
 550
 551     getMinMaxDividerCoord(sPtr, divider, &minCoord, &maxCoord);
 552
 553     done = 0;
 554     dragging = 0;
 555     while (!done) {
 556         WMMaskEvent(scr->display, ButtonMotionMask|ButtonReleaseMask
 557                     |ExposureMask, &ev);
 558
 559         coord = (sPtr->flags.vertical) ? ev.xmotion.x : ev.xmotion.y;
 560
 561         switch (ev.type) {
 562          case ButtonRelease:
 563             done = 1;
 564             if (dragging)
 565                 drawDragingRectangle(sPtr, pos);
 566             break;
 567
 568          case MotionNotify:
 569             if (dragging)
 570                 drawDragingRectangle(sPtr, pos);
 571             if (coord - ofs < minCoord)
 572                 pos = minCoord;
 573             else if (coord - ofs > maxCoord)
 574                 pos = maxCoord;
 575             else
 576                 pos = coord - ofs;
 577             drawDragingRectangle(sPtr, pos);
 578             dragging = 1;
 579             break;
 580
 581          default:
 582             WMHandleEvent(&ev);
 583             break;
 584         }
 585     }
 586
 587     if (dragging) {
 588         T_SplitViewSubview *p1, *p2;
 589         int totSize;
 590
 591         p1 = _GetPSubviewStructAt(divider);
 592         p2 = _GetPSubviewStructAt(divider+1);
 593
 594         totSize = p1->size + DIVIDER_THICKNESS + p2->size;
 595
 596         p1->size = pos - p1->pos;
 597         p2->size = totSize - p1->size - DIVIDER_THICKNESS;
 598         p2->pos = p1->pos + p1->size  + DIVIDER_THICKNESS;
 599
 600         resizeView(sPtr, p1->view, p1->size);
 601         moveView(sPtr, p2->view, p2->pos);
 602         resizeView(sPtr, p2->view, p2->size);
 603         sPtr->flags.subviewsWereManuallyMoved = 1;
 604     }
 605 }
 606
 607
 608 static void
 609 handleEvents(XEvent *event, void *data)
 610 {
 611     SplitView *sPtr = (SplitView*)data;
 612
 613     CHECK_CLASS(data, WC_SplitView);
 614
 615
 616     switch (event->type) {
 617      case Expose:
 618         if (event->xexpose.count!=0)
 619             break;
 620         paintSplitView(sPtr);
 621         break;
 622
 623      case DestroyNotify:
 624         destroySplitView(sPtr);
 625         break;
 626     }
 627 }
 628
 629
 630 static void
 631 handleActionEvents(XEvent *event, void *data)
 632 {
 633
 634     CHECK_CLASS(data, WC_SplitView);
 635
 636     switch (event->type) {
 637      case ButtonPress:
 638         if (event->xbutton.button == Button1)
 639             dragDivider(data, event->xbutton.x, event->xbutton.y);
 640         break;
 641     }
 642 }
 643
 644
 645
 646 static void
 647 destroySplitView(SplitView *sPtr)
 648 {
 649     int i, count;
 650
 651     count = _GetSubviewsCount();
 652     for (i = 0; i < count; i++)
 653         wfree(WMGetFromBag(sPtr->subviewsBag, i));
 654     WMFreeBag(sPtr->subviewsBag);
 655
 656     WMRemoveNotificationObserver(sPtr);
 657
 658     wfree(sPtr);
 659 }
 660
 661 WMSplitView*
 662 WMCreateSplitView(WMWidget *parent)
 663 {
 664     SplitView *sPtr;
 665
 666     sPtr = wmalloc(sizeof(SplitView));
 667     memset(sPtr, 0, sizeof(SplitView));
 668
 669     sPtr->widgetClass = WC_SplitView;
 670
 671     sPtr->view = W_CreateView(W_VIEW(parent));
 672     if (!sPtr->view) {
 673         wfree(sPtr);
 674         return NULL;
 675     }
 676     sPtr->view->self = sPtr;
 677
 678     WMSetViewNotifySizeChanges(sPtr->view, True);
 679
 680     WMCreateEventHandler(sPtr->view, ExposureMask|StructureNotifyMask
 681                          |ClientMessageMask, handleEvents, sPtr);
 682
 683
 684     WMCreateEventHandler(sPtr->view, ButtonPressMask|ButtonReleaseMask
 685                          |EnterWindowMask|LeaveWindowMask,
 686                          handleActionEvents, sPtr);
 687
 688
 689     WMAddNotificationObserver(handleViewResized, sPtr,
 690                               WMViewSizeDidChangeNotification, sPtr->view);
 691
 692     sPtr->subviewsBag = WMCreateBag(8);
 693
 694     return sPtr;
 695 }
 696
 697
 698 void
 699 WMAdjustSplitViewSubviews(WMSplitView *sPtr)
 700 {
 701     CHECK_CLASS(sPtr, WC_SplitView);
 702
 703     checkSizes(sPtr);
 704
 705     adjustSplitViewSubviews(sPtr);
 706
 707     assert(checkSizes(sPtr) == 0);
 708 }
 709
 710
 711 void
 712 WMAddSplitViewSubview(WMSplitView *sPtr, WMView *subview)
 713 {
 714     int wasMapped, count;
 715     T_SplitViewSubview *p;
 716
 717     CHECK_CLASS(sPtr, WC_SplitView);
 718
 719     if (!(p = (T_SplitViewSubview*)wmalloc(sizeof(T_SplitViewSubview))))
 720         return;
 721
 722     wasMapped = subview->flags.mapped;
 723     if (wasMapped)
 724         W_UnmapView(subview);
 725
 726     count = _GetSubviewsCount();
 727     p->view = subview;
 728     getConstraints(sPtr, count, &(p->minSize), &(p->maxSize));
 729     if (sPtr->flags.vertical)
 730         p->size = subview->size.width;
 731     else
 732         p->size = subview->size.height;
 733
 734     WMPutInBag(sPtr->subviewsBag,(void*)p);
 735     reparentView(sPtr, subview, 0);
 736
 737 /*
 738     We should have something like that...
 739
 740     WMSetViewNotifySizeChanges(subview, True);
 741     WMAddNotificationObserver(handleSubviewResized, sPtr,
 742                               WMViewSizeDidChangeNotification,
 743                               subview);
 744     WMSetViewNotifyMoveChanges(subview, True);
 745     WMAddNotificationObserver(handleSubviewResized, sPtr,
 746                               WMViewMoveDidChangeNotification,
 747                               subview);
 748 */
 749     if (wasMapped) {
 750         W_MapView(subview);
 751
 752         sPtr->flags.adjustOnPaint = 1;
 753         paintSplitView(sPtr);
 754     } else {
 755         handleViewResized(sPtr, NULL);
 756     }
 757 }
 758
 759
 760 WMView*
 761 WMGetSplitViewSubviewAt(WMSplitView *sPtr, int index)
 762 {
 763     CHECK_CLASS(sPtr, WC_SplitView);
 764
 765     if (index > 0 && index < _GetSubviewsCount())
 766         return (_GetSubviewAt(index));
 767     else
 768         return (NULL);
 769 }
 770
 771
 772 void
 773 WMRemoveSplitViewSubview(WMSplitView *sPtr, WMView *view)
 774 {
 775     T_SplitViewSubview *p;
 776     int i, count;
 777
 778     CHECK_CLASS(sPtr, WC_SplitView);
 779
 780     count = _GetSubviewsCount();
 781     for (i = 0; i < count; i++) {
 782         p = _GetPSubviewStructAt(i);
 783         if (p->view == view) {
 784             wfree(p);
 785             WMDeleteFromBag(sPtr->subviewsBag, i);
 786             sPtr->flags.adjustOnPaint = 1;
 787             paintSplitView(sPtr);
 788             break;
 789         }
 790     }
 791 }
 792
 793
 794 void
 795 WMRemoveSplitViewSubviewAt(WMSplitView *sPtr, int index)
 796 {
 797     T_SplitViewSubview *p;
 798
 799     CHECK_CLASS(sPtr, WC_SplitView);
 800
 801     if (index > 0 && index < _GetSubviewsCount()) {
 802         p = _GetPSubviewStructAt(index);
 803         wfree(p);
 804         WMDeleteFromBag(sPtr->subviewsBag, index);
 805         sPtr->flags.adjustOnPaint = 1;
 806         paintSplitView(sPtr);
 807     }
 808 }
 809
 810
 811 void
 812 WMSetSplitViewConstrainProc(WMSplitView *sPtr, WMSplitViewConstrainProc *proc)
 813 {
 814     CHECK_CLASS(sPtr, WC_SplitView);
 815
 816     sPtr->constrainProc = proc;
 817 }
 818
 819
 820 int
 821 WMGetSplitViewSubviewsCount(WMSplitView *sPtr)
 822 {
 823     CHECK_CLASS(sPtr, WC_SplitView);
 824
 825     return (_GetSubviewsCount());
 826 }
 827
 828
 829 Bool
 830 WMGetSplitViewVertical(WMSplitView *sPtr)
 831 {
 832     CHECK_CLASS(sPtr, WC_SplitView);
 833
 834     return (sPtr->flags.vertical == 1);
 835 }
 836
 837 void
 838 WMSetSplitViewVertical(WMSplitView *sPtr, Bool flag)
 839 {
 840     int vertical;
 841
 842     CHECK_CLASS(sPtr, WC_SplitView);
 843
 844     vertical = (flag) ? 1 : 0;
 845     if (sPtr->flags.vertical == vertical)
 846         return;
 847
 848     sPtr->flags.vertical = vertical;
 849
 850 /*    if (sPtr->view->flags.mapped && sPtr->view->flags.realized)*/
 851         handleViewResized(sPtr, NULL);
 852 /*    else
 853         sPtr->flags.adjustOnPaint = 1;
 854  */
 855 }
 856
 857
 858 int
 859 WMGetSplitViewDividerThickness(WMSplitView *sPtr)
 860 {
 861     CHECK_CLASS(sPtr, WC_SplitView);
 862
 863     return (DIVIDER_THICKNESS);
 864 }
 865
 866 #if 0
 867 void
 868 WMSetSplitViewResizeSubviewsProc(WMSplitView *sPtr,
 869                                  WMSplitViewResizeSubviewsProc *proc)
 870 {
 871     CHECK_CLASS(sPtr, WC_SplitView);
 872
 873     sPtr->resizeSubviewsProc = proc;
 874 }
 875 #endif