WINGs/wsplitview.c

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