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 _AddPSubviewStruct(P) \
  45     (WMAddToArray(sPtr->subviews,((void*)P)))
  46
  47 #define _GetPSubviewStructAt(i) \
  48     ((W_SplitViewSubview*)WMGetFromArray(sPtr->subviews,(i)))
  49
  50 #define _GetSubviewAt(i) \
  51     (((W_SplitViewSubview*)WMGetFromArray(sPtr->subviews,(i)))->view)
  52
  53 #define _GetMinSizeAt(i) \
  54     (((W_SplitViewSubview*)WMGetFromArray(sPtr->subviews,(i)))->minSize)
  55
  56 #define _GetMaxSizeAt(i) \
  57     (((W_SplitViewSubview*)WMGetFromArray(sPtr->subviews,(i)))->maxSize)
  58
  59 #define _GetSizeAt(i) \
  60     (((W_SplitViewSubview*)WMGetFromArray(sPtr->subviews,(i)))->size)
  61
  62 #define _GetPosAt(i) \
  63     (((W_SplitViewSubview*)WMGetFromArray(sPtr->subviews,(i)))->pos)
  64
  65 #define _GetSplitViewSize() \
  66     ((sPtr->flags.vertical) ? sPtr->view->size.width : sPtr->view->size.height)
  67
  68 static void destroySplitView(WMSplitView * sPtr);
  69 static void paintSplitView(WMSplitView * sPtr);
  70
  71 static void handleEvents(XEvent * event, void *data);
  72 static void handleActionEvents(XEvent * event, void *data);
  73
  74 static void getConstraints(WMSplitView * sPtr, int index, int *minSize, int *maxSize)
  75 {
  76         *minSize = MIN_SUBVIEW_SIZE;
  77         *maxSize = MAX_SUBVIEW_SIZE;
  78
  79         if (sPtr->constrainProc)
  80                 (*sPtr->constrainProc) (sPtr, index, minSize, maxSize);
  81
  82         if (*minSize < MIN_SUBVIEW_SIZE)
  83                 *minSize = MIN_SUBVIEW_SIZE;
  84
  85         if (*maxSize < MIN_SUBVIEW_SIZE)
  86                 *maxSize = MAX_SUBVIEW_SIZE;
  87         else if (*maxSize < *minSize)
  88                 *maxSize = *minSize;
  89 }
  90
  91 static void updateConstraints(WMSplitView * sPtr)
  92 {
  93         W_SplitViewSubview *p;
  94         int i, count;
  95
  96         count = _GetSubviewsCount();
  97         for (i = 0; i < count; i++) {
  98                 p = _GetPSubviewStructAt(i);
  99                 getConstraints(sPtr, i, &(p->minSize), &(p->maxSize));
 100         }
 101 }
 102
 103 static void resizeView(WMSplitView * sPtr, WMView * view, int size)
 104 {
 105         int width, height;
 106
 107         if (sPtr->flags.vertical) {
 108                 width = size;
 109                 height = sPtr->view->size.height;
 110         } else {
 111                 width = sPtr->view->size.width;
 112                 height = size;
 113         }
 114
 115         if (view->self)
 116                 WMResizeWidget(view->self, width, height);
 117         else
 118                 W_ResizeView(view, width, height);
 119 }
 120
 121 static void reparentView(WMSplitView * sPtr, WMView * view, int pos)
 122 {
 123         int x, y;
 124
 125         if (sPtr->flags.vertical) {
 126                 x = pos;
 127                 y = 0;
 128         } else {
 129                 x = 0;
 130                 y = pos;
 131         }
 132
 133         W_ReparentView(view, sPtr->view, x, y);
 134 }
 135
 136 static void moveView(WMSplitView * sPtr, WMView * view, int pos)
 137 {
 138         int x, y;
 139
 140         if (sPtr->flags.vertical) {
 141                 x = pos;
 142                 y = 0;
 143         } else {
 144                 x = 0;
 145                 y = pos;
 146         }
 147
 148         if (view->self)
 149                 WMMoveWidget(view->self, x, y);
 150         else
 151                 W_MoveView(view, x, y);
 152 }
 153
 154 static int checkSizes(WMSplitView * sPtr)
 155 {
 156         int i, count, offset;
 157         W_SplitViewSubview *p;
 158
 159         count = _GetSubviewsCount();
 160         offset = 0;
 161         for (i = 0; i < count; i++) {
 162                 p = _GetPSubviewStructAt(i);
 163                 if (p->size < p->minSize) {
 164                         offset += p->minSize - p->size;
 165                         p->size = p->minSize;
 166                 } else if (p->maxSize != MAX_SUBVIEW_SIZE && p->size > p->maxSize) {
 167                         offset += p->maxSize - p->size;
 168                         p->size = p->maxSize;
 169                 }
 170         }
 171
 172         return (offset);
 173 }
 174
 175 static void checkPositions(WMSplitView * sPtr)
 176 {
 177         int i, count, pos;
 178         W_SplitViewSubview *p;
 179
 180         count = _GetSubviewsCount();
 181         pos = 0;
 182         for (i = 0; i < count; i++) {
 183                 p = _GetPSubviewStructAt(i);
 184                 p->pos = pos;
 185                 pos += p->size + DIVIDER_THICKNESS;
 186         }
 187 }
 188
 189 static void updateSubviewsGeom(WMSplitView * sPtr)
 190 {
 191         int i, count;
 192         W_SplitViewSubview *p;
 193
 194         count = _GetSubviewsCount();
 195         for (i = 0; i < count; i++) {
 196                 p = _GetPSubviewStructAt(i);
 197                 resizeView(sPtr, p->view, p->size);
 198                 moveView(sPtr, p->view, p->pos);
 199         }
 200 }
 201
 202 static int getTotalSize(WMSplitView * sPtr)
 203 {
 204         int i, count, totSize;
 205
 206         count = _GetSubviewsCount();
 207         if (!count)
 208                 return (0);
 209
 210         totSize = 0;
 211         for (i = 0; i < count; i++)
 212                 totSize += _GetSizeAt(i) + DIVIDER_THICKNESS;
 213
 214         return (totSize - DIVIDER_THICKNESS);
 215 }
 216
 217 static Bool distributeOffsetEqually(WMSplitView * sPtr, int offset)
 218 {
 219         W_SplitViewSubview *p;
 220         int i, count, sizeChanged, forced;
 221
 222         if ((count = _GetSubviewsCount()) < 1)
 223                 return (True);
 224
 225         forced = False;
 226         while (offset != 0) {
 227                 sizeChanged = 0;
 228                 for (i = 0; i < count && offset != 0; i++) {
 229                         p = _GetPSubviewStructAt(i);
 230                         if (offset < 0) {
 231                                 if (p->size > p->minSize) {
 232                                         offset++;
 233                                         p->size--;
 234                                         sizeChanged = 1;
 235                                 }
 236                         } else if (p->maxSize == MAX_SUBVIEW_SIZE || p->size < p->maxSize) {
 237                                 offset--;
 238                                 p->size++;
 239                                 sizeChanged = 1;
 240                         }
 241                 }
 242                 if (offset != 0 && !sizeChanged) {
 243                         p = _GetPSubviewStructAt(count - 1);
 244                         if (offset > 0) {
 245                                 p->size += offset;
 246                                 p->maxSize = MAX_SUBVIEW_SIZE;
 247                         }
 248                         offset = 0;
 249                         forced = True;
 250                 }
 251         }
 252
 253         return (forced);
 254 }
 255
 256 static Bool distributeOffsetFormEnd(WMSplitView * sPtr, int offset)
 257 {
 258         W_SplitViewSubview *p;
 259         int i, count, sizeTmp;
 260
 261         if ((count = _GetSubviewsCount()) < 1)
 262                 return (True);
 263
 264         for (i = count - 1; i >= 0 && offset != 0; i--) {
 265                 p = _GetPSubviewStructAt(i);
 266                 sizeTmp = p->size;
 267                 if (offset > 0) {
 268                         if (p->maxSize == MAX_SUBVIEW_SIZE || p->size + offset < p->maxSize)
 269                                 p->size += offset;
 270                         else
 271                                 p->size = p->maxSize;
 272                 } else {
 273                         if (p->size + offset >= p->minSize)
 274                                 p->size += offset;
 275                         else
 276                                 p->size = p->minSize;
 277                 }
 278                 offset -= p->size - sizeTmp;
 279         }
 280
 281         return (offset == 0);
 282 }
 283
 284 static void adjustSplitViewSubviews(WMSplitView * sPtr)
 285 {
 286         W_SplitViewSubview *p;
 287         int i, count, adjSize, adjPad;
 288
 289         CHECK_CLASS(sPtr, WC_SplitView);
 290
 291 #if 0
 292         printf("---- (adjustSplitViewSubviews - 1) ----\n");
 293         dumpSubviews(sPtr);
 294 #endif
 295
 296         if ((count = _GetSubviewsCount()) < 1)
 297                 return;
 298
 299         adjSize = (_GetSplitViewSize() - ((count - 1) * DIVIDER_THICKNESS)) / count;
 300         adjPad = (_GetSplitViewSize() - ((count - 1) * DIVIDER_THICKNESS)) % count;
 301         for (i = 0; i < count; i++) {
 302                 p = _GetPSubviewStructAt(i);
 303                 p->size = adjSize;
 304         }
 305
 306         distributeOffsetEqually(sPtr, adjPad - checkSizes(sPtr));
 307
 308         checkPositions(sPtr);
 309         updateSubviewsGeom(sPtr);
 310
 311         sPtr->flags.subviewsWereManuallyMoved = 0;
 312
 313 #if 0
 314         printf("---- (adjustSplitViewSubviews - 2) ----\n");
 315         dumpSubviews(sPtr);
 316 #endif
 317 }
 318
 319 #if 0
 320 static void handleSubviewResized(void *self, WMNotification * notif)
 321 {
 322         WMSplitView *sPtr = (WMSplitView *) self;
 323
 324         CHECK_CLASS(sPtr, WC_SplitView);
 325
 326         if (WMGetNotificationName(notif) == WMViewSizeDidChangeNotification) {
 327                 W_SplitViewSubview *p;
 328                 int i, count, done;
 329                 WMView *view = WMGetNotificationObject(notif);
 330
 331                 count = _GetSubviewsCount();
 332                 done = 0;
 333                 for (i = 0; i < count; i++) {
 334                         p = _GetPSubviewStructAt(i);
 335                         if (p->view == view) {
 336                                 done = 1;
 337                                 break;
 338                         }
 339                 }
 340
 341                 if (done) {
 342                         /* TODO !!! */
 343                         resizeView(sPtr, p->view, p->size);
 344                         moveView(sPtr, p->view, p->pos);
 345                 }
 346         }
 347 }
 348 #endif
 349
 350 static void handleViewResized(void *self, WMNotification * notification)
 351 {
 352         WMSplitView *sPtr = (WMSplitView *) self;
 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         return (DIVIDER_THICKNESS);
 780 }
 781
 782 #if 0
 783 void WMSetSplitViewResizeSubviewsProc(WMSplitView * sPtr, WMSplitViewResizeSubviewsProc * proc)
 784 {
 785         CHECK_CLASS(sPtr, WC_SplitView);
 786
 787         sPtr->resizeSubviewsProc = proc;
 788 }
 789 #endif