Change to the linux kernel coding style
[wmaker-crm.git] / 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 memset(sPtr, 0, sizeof(WMSplitView));
611
612 sPtr->widgetClass = WC_SplitView;
613
614 sPtr->view = W_CreateView(W_VIEW(parent));
615 if (!sPtr->view) {
616 wfree(sPtr);
617 return NULL;
618 }
619 sPtr->view->self = sPtr;
620
621 WMSetViewNotifySizeChanges(sPtr->view, True);
622
623 WMCreateEventHandler(sPtr->view, ExposureMask | StructureNotifyMask
624 | ClientMessageMask, handleEvents, sPtr);
625
626 WMCreateEventHandler(sPtr->view, ButtonPressMask | ButtonReleaseMask
627 | EnterWindowMask | LeaveWindowMask, handleActionEvents, sPtr);
628
629 WMAddNotificationObserver(handleViewResized, sPtr, WMViewSizeDidChangeNotification, sPtr->view);
630
631 sPtr->subviews = WMCreateArrayWithDestructor(8, wfree);
632
633 return sPtr;
634 }
635
636 void WMAdjustSplitViewSubviews(WMSplitView * sPtr)
637 {
638 CHECK_CLASS(sPtr, WC_SplitView);
639
640 checkSizes(sPtr);
641
642 adjustSplitViewSubviews(sPtr);
643
644 assert(checkSizes(sPtr) == 0);
645 }
646
647 void WMAddSplitViewSubview(WMSplitView * sPtr, WMView * subview)
648 {
649 int wasMapped, count;
650 W_SplitViewSubview *p;
651
652 CHECK_CLASS(sPtr, WC_SplitView);
653
654 if (!(p = (W_SplitViewSubview *) wmalloc(sizeof(W_SplitViewSubview))))
655 return;
656
657 wasMapped = subview->flags.mapped;
658 if (wasMapped)
659 W_UnmapView(subview);
660
661 count = _GetSubviewsCount();
662 p->view = subview;
663 getConstraints(sPtr, count, &(p->minSize), &(p->maxSize));
664 if (sPtr->flags.vertical)
665 p->size = subview->size.width;
666 else
667 p->size = subview->size.height;
668
669 WMAddToArray(sPtr->subviews, p);
670 reparentView(sPtr, subview, 0);
671
672 /*
673 We should have something like that...
674
675 WMSetViewNotifySizeChanges(subview, True);
676 WMAddNotificationObserver(handleSubviewResized, sPtr,
677 WMViewSizeDidChangeNotification,
678 subview);
679 WMSetViewNotifyMoveChanges(subview, True);
680 WMAddNotificationObserver(handleSubviewResized, sPtr,
681 WMViewMoveDidChangeNotification,
682 subview);
683 */
684 if (wasMapped) {
685 W_MapView(subview);
686
687 sPtr->flags.adjustOnPaint = 1;
688 paintSplitView(sPtr);
689 } else {
690 handleViewResized(sPtr, NULL);
691 }
692 }
693
694 WMView *WMGetSplitViewSubviewAt(WMSplitView * sPtr, int index)
695 {
696 CHECK_CLASS(sPtr, WC_SplitView);
697
698 if (index >= 0 && index < _GetSubviewsCount())
699 return (_GetSubviewAt(index));
700 else
701 return (NULL);
702 }
703
704 void WMRemoveSplitViewSubview(WMSplitView * sPtr, WMView * view)
705 {
706 W_SplitViewSubview *p;
707 int i, count;
708
709 CHECK_CLASS(sPtr, WC_SplitView);
710
711 /* TODO: rewrite this. This code with macros is getting more complex than it worths */
712 count = _GetSubviewsCount();
713 for (i = 0; i < count; i++) {
714 p = _GetPSubviewStructAt(i);
715 if (p->view == view) {
716 WMDeleteFromArray(sPtr->subviews, i);
717 sPtr->flags.adjustOnPaint = 1;
718 paintSplitView(sPtr);
719 break;
720 }
721 }
722 }
723
724 void WMRemoveSplitViewSubviewAt(WMSplitView * sPtr, int index)
725 {
726 W_SplitViewSubview *p;
727
728 CHECK_CLASS(sPtr, WC_SplitView);
729
730 /* TODO: same about rewrite */
731 if (index >= 0 && index < _GetSubviewsCount()) {
732 p = _GetPSubviewStructAt(index);
733 WMDeleteFromArray(sPtr->subviews, index);
734 sPtr->flags.adjustOnPaint = 1;
735 paintSplitView(sPtr);
736 }
737 }
738
739 void WMSetSplitViewConstrainProc(WMSplitView * sPtr, WMSplitViewConstrainProc * proc)
740 {
741 CHECK_CLASS(sPtr, WC_SplitView);
742
743 sPtr->constrainProc = proc;
744 }
745
746 int WMGetSplitViewSubviewsCount(WMSplitView * sPtr)
747 {
748 CHECK_CLASS(sPtr, WC_SplitView);
749
750 return (_GetSubviewsCount());
751 }
752
753 Bool WMGetSplitViewVertical(WMSplitView * sPtr)
754 {
755 CHECK_CLASS(sPtr, WC_SplitView);
756
757 return (sPtr->flags.vertical == 1);
758 }
759
760 void WMSetSplitViewVertical(WMSplitView * sPtr, Bool flag)
761 {
762 int vertical;
763
764 CHECK_CLASS(sPtr, WC_SplitView);
765
766 vertical = ((flag == 0) ? 0 : 1);
767 if (sPtr->flags.vertical == vertical)
768 return;
769
770 sPtr->flags.vertical = vertical;
771
772 /* if (sPtr->view->flags.mapped && sPtr->view->flags.realized) */
773 handleViewResized(sPtr, NULL);
774 /* else
775 sPtr->flags.adjustOnPaint = 1;
776 */
777 }
778
779 int WMGetSplitViewDividerThickness(WMSplitView * sPtr)
780 {
781 CHECK_CLASS(sPtr, WC_SplitView);
782
783 return (DIVIDER_THICKNESS);
784 }
785
786 #if 0
787 void WMSetSplitViewResizeSubviewsProc(WMSplitView * sPtr, WMSplitViewResizeSubviewsProc * proc)
788 {
789 CHECK_CLASS(sPtr, WC_SplitView);
790
791 sPtr->resizeSubviewsProc = proc;
792 }
793 #endif