changed indentation to use spaces only

WINGs/wsplitview.c

@@ -5,11 +5,11 @@
 #include "WINGsP.h"
 
 /*
-char *WMSplitViewDidResizeSubviewsNotification
-    = "WMSplitViewDidResizeSubviewsNotification";
-char *WMSplitViewWillResizeSubviewsNotification
-    = "WMSplitViewWillResizeSubviewsNotification";
-*/
+ char *WMSplitViewDidResizeSubviewsNotification
+ = "WMSplitViewDidResizeSubviewsNotification";
+ char *WMSplitViewWillResizeSubviewsNotification
+ = "WMSplitViewWillResizeSubviewsNotification";
+ */
 
 typedef struct W_SplitViewSubview {
     WMView *view;
@@ -23,15 +23,15 @@ typedef struct W_SplitViewSubview {
 typedef struct W_SplitView {
     W_Class widgetClass;
     W_View *view;
-    
+
     WMArray *subviews;
-    
+
     WMSplitViewConstrainProc *constrainProc;
-    
+
     struct {
-	unsigned int vertical:1;	
-	unsigned int adjustOnPaint:1;
-	unsigned int subviewsWereManuallyMoved:1;
+        unsigned int vertical:1;
+        unsigned int adjustOnPaint:1;
+        unsigned int subviewsWereManuallyMoved:1;
     } flags;
 
     /* WMSplitViewResizeSubviewsProc *resizeSubviewsProc; */
@@ -48,28 +48,28 @@ typedef struct W_SplitView {
 #define _GetSubviewsCount() WMGetArrayItemCount(sPtr->subviews)
 
 #define _AddPSubviewStruct(P) \
-(WMAddToArray(sPtr->subviews,((void*)P)))
+    (WMAddToArray(sPtr->subviews,((void*)P)))
 
 #define _GetPSubviewStructAt(i) \
-((W_SplitViewSubview*)WMGetFromArray(sPtr->subviews,(i)))
+    ((W_SplitViewSubview*)WMGetFromArray(sPtr->subviews,(i)))
 
 #define _GetSubviewAt(i) \
-(((W_SplitViewSubview*)WMGetFromArray(sPtr->subviews,(i)))->view)
+    (((W_SplitViewSubview*)WMGetFromArray(sPtr->subviews,(i)))->view)
 
 #define _GetMinSizeAt(i) \
-(((W_SplitViewSubview*)WMGetFromArray(sPtr->subviews,(i)))->minSize)
+    (((W_SplitViewSubview*)WMGetFromArray(sPtr->subviews,(i)))->minSize)
 
 #define _GetMaxSizeAt(i) \
-(((W_SplitViewSubview*)WMGetFromArray(sPtr->subviews,(i)))->maxSize)
+    (((W_SplitViewSubview*)WMGetFromArray(sPtr->subviews,(i)))->maxSize)
 
 #define _GetSizeAt(i) \
-(((W_SplitViewSubview*)WMGetFromArray(sPtr->subviews,(i)))->size)
+    (((W_SplitViewSubview*)WMGetFromArray(sPtr->subviews,(i)))->size)
 
 #define _GetPosAt(i) \
-(((W_SplitViewSubview*)WMGetFromArray(sPtr->subviews,(i)))->pos)
+    (((W_SplitViewSubview*)WMGetFromArray(sPtr->subviews,(i)))->pos)
 
 #define _GetSplitViewSize() \
-((sPtr->flags.vertical) ? sPtr->view->size.width : sPtr->view->size.height)
+    ((sPtr->flags.vertical) ? sPtr->view->size.width : sPtr->view->size.height)
 
 static void destroySplitView(WMSplitView *sPtr);
 static void paintSplitView(WMSplitView *sPtr);
@@ -85,15 +85,15 @@ getConstraints(WMSplitView *sPtr, int index, int *minSize, int *maxSize)
     *maxSize = MAX_SUBVIEW_SIZE;
 
     if (sPtr->constrainProc)
-	(*sPtr->constrainProc)(sPtr, index, minSize, maxSize);
+        (*sPtr->constrainProc)(sPtr, index, minSize, maxSize);
 
     if (*minSize < MIN_SUBVIEW_SIZE)
-	*minSize = MIN_SUBVIEW_SIZE;
+        *minSize = MIN_SUBVIEW_SIZE;
 
     if (*maxSize < MIN_SUBVIEW_SIZE)
-    	*maxSize = MAX_SUBVIEW_SIZE;
+        *maxSize = MAX_SUBVIEW_SIZE;
     else if (*maxSize < *minSize)
-    	*maxSize = *minSize;
+        *maxSize = *minSize;
 }
 
 
@@ -105,8 +105,8 @@ updateConstraints(WMSplitView *sPtr)
 
     count = _GetSubviewsCount();
     for (i = 0; i < count; i++) {
-    	p = _GetPSubviewStructAt(i);
-    	getConstraints(sPtr, i, &(p->minSize), &(p->maxSize));
+        p = _GetPSubviewStructAt(i);
+        getConstraints(sPtr, i, &(p->minSize), &(p->maxSize));
     }
 }
 
@@ -117,17 +117,17 @@ resizeView(WMSplitView *sPtr, WMView *view, int size)
     int width, height;
 
     if (sPtr->flags.vertical) {
-	width = size;
-    	height = sPtr->view->size.height;
+        width = size;
+        height = sPtr->view->size.height;
     } else {
-	width = sPtr->view->size.width;
-    	height = size;
+        width = sPtr->view->size.width;
+        height = size;
     }
 
     if (view->self)
-	WMResizeWidget(view->self, width, height);
+        WMResizeWidget(view->self, width, height);
     else
-	W_ResizeView(view, width, height);
+        W_ResizeView(view, width, height);
 }
 
 
@@ -137,11 +137,11 @@ reparentView(WMSplitView *sPtr, WMView *view, int pos)
     int x, y;
 
     if (sPtr->flags.vertical) {
-    	x = pos;
-	y = 0;
+        x = pos;
+        y = 0;
     } else {
-    	x = 0;
-	y = pos;
+        x = 0;
+        y = pos;
     }
 
     W_ReparentView(view, sPtr->view, x, y);
@@ -154,17 +154,17 @@ moveView(WMSplitView *sPtr, WMView *view, int pos)
     int x, y;
 
     if (sPtr->flags.vertical) {
-    	x = pos;
-	y = 0;
+        x = pos;
+        y = 0;
     } else {
-    	x = 0;
-	y = pos;
+        x = 0;
+        y = pos;
     }
 
     if (view->self)
-	WMMoveWidget(view->self, x, y);
+        WMMoveWidget(view->self, x, y);
     else
-	W_MoveView(view, x, y);
+        W_MoveView(view, x, y);
 }
 
 
@@ -177,16 +177,16 @@ checkSizes(WMSplitView *sPtr)
     count = _GetSubviewsCount();
     offset = 0;
     for (i = 0; i < count; i++) {
-    	p = _GetPSubviewStructAt(i);
-	if (p->size < p->minSize) {
-	    offset += p->minSize - p->size;
-	    p->size = p->minSize;
-	} else if (p->maxSize != MAX_SUBVIEW_SIZE && p->size > p->maxSize) {
-	    offset += p->maxSize - p->size;
-	    p->size = p->maxSize;
-	}
+        p = _GetPSubviewStructAt(i);
+        if (p->size < p->minSize) {
+            offset += p->minSize - p->size;
+            p->size = p->minSize;
+        } else if (p->maxSize != MAX_SUBVIEW_SIZE && p->size > p->maxSize) {
+            offset += p->maxSize - p->size;
+            p->size = p->maxSize;
+        }
     }
-    
+
     return (offset);
 }
 
@@ -200,9 +200,9 @@ checkPositions(WMSplitView *sPtr)
     count = _GetSubviewsCount();
     pos = 0;
     for (i = 0; i < count; i++) {
-    	p = _GetPSubviewStructAt(i);
-	p->pos = pos;
-	pos += p->size + DIVIDER_THICKNESS;
+        p = _GetPSubviewStructAt(i);
+        p->pos = pos;
+        pos += p->size + DIVIDER_THICKNESS;
     }
 }
 
@@ -215,9 +215,9 @@ updateSubviewsGeom(WMSplitView *sPtr)
 
     count = _GetSubviewsCount();
     for (i = 0; i < count; i++) {
-    	p = _GetPSubviewStructAt(i);
-	resizeView(sPtr, p->view, p->size);
-	moveView(sPtr, p->view, p->pos);
+        p = _GetPSubviewStructAt(i);
+        resizeView(sPtr, p->view, p->size);
+        moveView(sPtr, p->view, p->pos);
     }
 }
 
@@ -229,12 +229,12 @@ getTotalSize(WMSplitView *sPtr)
 
     count = _GetSubviewsCount();
     if (!count)
-    	return (0);
+        return (0);
 
     totSize = 0;
     for (i = 0; i < count; i++)
-    	totSize += _GetSizeAt(i) + DIVIDER_THICKNESS;
-    
+        totSize += _GetSizeAt(i) + DIVIDER_THICKNESS;
+
     return (totSize - DIVIDER_THICKNESS);
 }
 
@@ -246,36 +246,36 @@ distributeOffsetEqually(WMSplitView *sPtr, int offset)
     int i, count, sizeChanged, forced;
 
     if ((count = _GetSubviewsCount()) < 1)
-    	return (True);
+        return (True);
 
     forced = False;
     while (offset != 0) {
-	sizeChanged = 0;
-    	for (i = 0; i < count && offset != 0; i++) {
-    	    p = _GetPSubviewStructAt(i);
-	    if (offset < 0) {
-	    	if (p->size > p->minSize) {
-		    offset++;
-	    	    p->size--;
-		    sizeChanged = 1;
-		}
-	    } else if (p->maxSize == MAX_SUBVIEW_SIZE || p->size < p->maxSize) {
-		offset--;
-	    	p->size++;
-		sizeChanged = 1;
-	    }
-    	}
-	if (offset != 0 && !sizeChanged) {
-	    p = _GetPSubviewStructAt(count-1);
-	    if (offset > 0) {
-	    	p->size += offset;
-	    	p->maxSize = MAX_SUBVIEW_SIZE;
-	    }
-	    offset = 0;
-	    forced = True;
-	}
+        sizeChanged = 0;
+        for (i = 0; i < count && offset != 0; i++) {
+            p = _GetPSubviewStructAt(i);
+            if (offset < 0) {
+                if (p->size > p->minSize) {
+                    offset++;
+                    p->size--;
+                    sizeChanged = 1;
+                }
+            } else if (p->maxSize == MAX_SUBVIEW_SIZE || p->size < p->maxSize) {
+                offset--;
+                p->size++;
+                sizeChanged = 1;
+            }
+        }
+        if (offset != 0 && !sizeChanged) {
+            p = _GetPSubviewStructAt(count-1);
+            if (offset > 0) {
+                p->size += offset;
+                p->maxSize = MAX_SUBVIEW_SIZE;
+            }
+            offset = 0;
+            forced = True;
+        }
     }
-    
+
     return (forced);
 }
 
@@ -287,23 +287,23 @@ distributeOffsetFormEnd(WMSplitView *sPtr, int offset)
     int i, count, sizeTmp;
 
     if ((count = _GetSubviewsCount()) < 1)
-    	return (True);
+        return (True);
 
     for (i = count-1; i >= 0 && offset != 0; i--) {
-	p = _GetPSubviewStructAt(i);
-	sizeTmp = p->size;
-	if (offset > 0) {
-	    if (p->maxSize == MAX_SUBVIEW_SIZE || p->size + offset < p->maxSize)
-	    	p->size += offset;
-	    else
-		p->size = p->maxSize;
-	} else {
-	    if (p->size + offset >= p->minSize)
-	    	p->size += offset;
-	    else
-		p->size = p->minSize;
-	}
-	offset -= p->size - sizeTmp;
+        p = _GetPSubviewStructAt(i);
+        sizeTmp = p->size;
+        if (offset > 0) {
+            if (p->maxSize == MAX_SUBVIEW_SIZE || p->size + offset < p->maxSize)
+                p->size += offset;
+            else
+                p->size = p->maxSize;
+        } else {
+            if (p->size + offset >= p->minSize)
+                p->size += offset;
+            else
+                p->size = p->minSize;
+        }
+        offset -= p->size - sizeTmp;
     }
 
     return (offset == 0);
@@ -324,23 +324,23 @@ adjustSplitViewSubviews(WMSplitView *sPtr)
 #endif
 
     if ((count = _GetSubviewsCount()) < 1)
-	return;
+        return;
 
     adjSize = (_GetSplitViewSize() - ((count-1) * DIVIDER_THICKNESS))  / count;
     adjPad =  (_GetSplitViewSize() - ((count-1) * DIVIDER_THICKNESS)) % count;
     for (i = 0; i < count; i++) {
-    	p = _GetPSubviewStructAt(i);
-	p->size = adjSize;
+        p = _GetPSubviewStructAt(i);
+        p->size = adjSize;
     }
-    
+
     distributeOffsetEqually(sPtr, adjPad - checkSizes(sPtr));
-    
+
     checkPositions(sPtr);
     updateSubviewsGeom(sPtr);
-    
+
     sPtr->flags.subviewsWereManuallyMoved = 0;
 
-#if 0    
+#if 0
     printf("---- (adjustSplitViewSubviews - 2) ----\n");
     dumpSubviews(sPtr);
 #endif
@@ -355,25 +355,25 @@ handleSubviewResized(void *self, WMNotification *notif)
     CHECK_CLASS(sPtr, WC_SplitView);
 
     if (WMGetNotificationName(notif) == WMViewSizeDidChangeNotification) {
-    	W_SplitViewSubview *p;
-    	int i, count, done;
-    	WMView *view = WMGetNotificationObject(notif);
+        W_SplitViewSubview *p;
+        int i, count, done;
+        WMView *view = WMGetNotificationObject(notif);
 
-    	count = _GetSubviewsCount();
-    	done = 0;
-	for (i = 0; i < count; i++) {
-    	    p = _GetPSubviewStructAt(i);
-	    if (p->view == view) {
-	    	done = 1;
-		break;
-	    }
-	}
-	
-	if (done) {
-	    /* TODO !!! */
-	    resizeView(sPtr, p->view, p->size);
-	    moveView(sPtr, p->view, p->pos);
-	}
+        count = _GetSubviewsCount();
+        done = 0;
+        for (i = 0; i < count; i++) {
+            p = _GetPSubviewStructAt(i);
+            if (p->view == view) {
+                done = 1;
+                break;
+            }
+        }
+
+        if (done) {
+            /* TODO !!! */
+            resizeView(sPtr, p->view, p->size);
+            moveView(sPtr, p->view, p->pos);
+        }
     }
 }
 #endif
@@ -390,13 +390,13 @@ handleViewResized(void *self, WMNotification *notification)
 
     updateConstraints(sPtr);
     checkSizes(sPtr);
-    
+
     if (sPtr->constrainProc || sPtr->flags.subviewsWereManuallyMoved) {
-    	distributeOffsetFormEnd(sPtr, _GetSplitViewSize() - getTotalSize(sPtr));
-    	checkPositions(sPtr);
-    	updateSubviewsGeom(sPtr);
+        distributeOffsetFormEnd(sPtr, _GetSplitViewSize() - getTotalSize(sPtr));
+        checkPositions(sPtr);
+        updateSubviewsGeom(sPtr);
     } else
-    	adjustSplitViewSubviews(sPtr);
+        adjustSplitViewSubviews(sPtr);
 
     assert(checkSizes(sPtr) == 0);
 
@@ -419,47 +419,47 @@ paintSplitView(WMSplitView *sPtr)
     printf("---- (paintSplitView - 1) ----\n");
     dumpSubviews(sPtr);
 #endif
-    
+
     if (!sPtr->view->flags.mapped || !sPtr->view->flags.realized)
-    	return;
+        return;
 
     XClearWindow(scr->display, sPtr->view->window);
 
     count = _GetSubviewsCount();
     if (count == 0)
-    	return;
+        return;
 
     if (sPtr->flags.adjustOnPaint) {
-	handleViewResized(sPtr, NULL);
-	sPtr->flags.adjustOnPaint = 0;
+        handleViewResized(sPtr, NULL);
+        sPtr->flags.adjustOnPaint = 0;
     }
 
     XSetClipMask(scr->display, scr->clipGC, dimple->mask);
 
     if (sPtr->flags.vertical) {
-	x = ((DIVIDER_THICKNESS - dimple->width) / 2);
-	y = (sPtr->view->size.height - dimple->height)/2;
+        x = ((DIVIDER_THICKNESS - dimple->width) / 2);
+        y = (sPtr->view->size.height - dimple->height)/2;
     } else {
-	x = (sPtr->view->size.width - dimple->width)/2;
-	y = ((DIVIDER_THICKNESS - dimple->height) / 2);
+        x = (sPtr->view->size.width - dimple->width)/2;
+        y = ((DIVIDER_THICKNESS - dimple->height) / 2);
     }
 
     for (i = 0; i < count-1; i++) {
-    	p = _GetPSubviewStructAt(i);
+        p = _GetPSubviewStructAt(i);
 
-	if (sPtr->flags.vertical)
-    	    x += p->size;
-	else
-    	    y += p->size;
+        if (sPtr->flags.vertical)
+            x += p->size;
+        else
+            y += p->size;
 
-	XSetClipOrigin(scr->display, scr->clipGC, x, y);
-	XCopyArea(scr->display, dimple->pixmap, sPtr->view->window,
-		  scr->clipGC, 0, 0, dimple->width, dimple->height, x, y);
-	
-	if (sPtr->flags.vertical)
-    	    x += DIVIDER_THICKNESS;
-	else
-	    y += DIVIDER_THICKNESS;
+        XSetClipOrigin(scr->display, scr->clipGC, x, y);
+        XCopyArea(scr->display, dimple->pixmap, sPtr->view->window,
+                  scr->clipGC, 0, 0, dimple->width, dimple->height, x, y);
+
+        if (sPtr->flags.vertical)
+            x += DIVIDER_THICKNESS;
+        else
+            y += DIVIDER_THICKNESS;
     }
 
 #if 0
@@ -473,21 +473,21 @@ static void
 drawDragingRectangle(WMSplitView *sPtr, int pos)
 {
     int x, y, w, h;
-    
+
     if (sPtr->flags.vertical) {
-    	x = pos;
-	y = 0;
-	w = DIVIDER_THICKNESS;
-	h = sPtr->view->size.height;
+        x = pos;
+        y = 0;
+        w = DIVIDER_THICKNESS;
+        h = sPtr->view->size.height;
     } else {
-    	x = 0;
-	y = pos;
-	w = sPtr->view->size.width;
-	h = DIVIDER_THICKNESS;
+        x = 0;
+        y = pos;
+        w = sPtr->view->size.width;
+        h = DIVIDER_THICKNESS;
     }
-    
+
     XFillRectangle(sPtr->view->screen->display, sPtr->view->window,
-		   sPtr->view->screen->ixorGC, x, y, w, h);
+                   sPtr->view->screen->ixorGC, x, y, w, h);
 }
 
 
@@ -499,14 +499,14 @@ getMinMaxDividerCoord(WMSplitView *sPtr, int divider, int *minC, int *maxC)
 
     relMinC = _GetMinSizeAt(divider);
     if (_GetMaxSizeAt(divider+1) != MAX_SUBVIEW_SIZE
-     && relMinC < totSize - _GetMaxSizeAt(divider+1))
-    	relMinC = totSize - _GetMaxSizeAt(divider+1);
+        && relMinC < totSize - _GetMaxSizeAt(divider+1))
+        relMinC = totSize - _GetMaxSizeAt(divider+1);
 
     relMaxC = totSize - _GetMinSizeAt(divider+1);
     if (_GetMaxSizeAt(divider) != MAX_SUBVIEW_SIZE
-     && relMaxC > _GetMaxSizeAt(divider))
-    	relMaxC = _GetMaxSizeAt(divider);
-    
+        && relMaxC > _GetMaxSizeAt(divider))
+        relMaxC = _GetMaxSizeAt(divider);
+
     *minC = _GetPosAt(divider) + relMinC;
     *maxC = _GetPosAt(divider) + relMaxC;
 }
@@ -522,11 +522,11 @@ dragDivider(WMSplitView *sPtr, int clickX, int clickY)
     int minCoord, maxCoord, coord;
 
     if (sPtr->constrainProc) {
-	updateConstraints(sPtr);
-	checkSizes(sPtr);
-	distributeOffsetFormEnd(sPtr, _GetSplitViewSize() - getTotalSize(sPtr));
-	checkPositions(sPtr);
-	updateSubviewsGeom(sPtr);
+        updateConstraints(sPtr);
+        checkSizes(sPtr);
+        distributeOffsetFormEnd(sPtr, _GetSplitViewSize() - getTotalSize(sPtr));
+        checkPositions(sPtr);
+        updateSubviewsGeom(sPtr);
     }
 
     scr = sPtr->view->screen;
@@ -534,74 +534,74 @@ dragDivider(WMSplitView *sPtr, int clickX, int clickY)
     coord = (sPtr->flags.vertical) ? clickX : clickY;
     count = _GetSubviewsCount();
     if (count < 2)
-    	return;
+        return;
 
     for (i = 0; i < count-1; i++) {
-	pos += _GetSizeAt(i) + DIVIDER_THICKNESS;
-	if (coord < pos) {
-	    ofs = coord - pos + DIVIDER_THICKNESS;
-	    done = 1;
-	    break;
-	}
-	divider++;
+        pos += _GetSizeAt(i) + DIVIDER_THICKNESS;
+        if (coord < pos) {
+            ofs = coord - pos + DIVIDER_THICKNESS;
+            done = 1;
+            break;
+        }
+        divider++;
     }
 
     if (!done)
-    	return;
+        return;
 
     getMinMaxDividerCoord(sPtr, divider, &minCoord, &maxCoord);
 
     done = 0;
     dragging = 0;
     while (!done) {
-	WMMaskEvent(scr->display, ButtonMotionMask|ButtonReleaseMask
-		    |ExposureMask, &ev);
+        WMMaskEvent(scr->display, ButtonMotionMask|ButtonReleaseMask
+                    |ExposureMask, &ev);
 
-    	coord = (sPtr->flags.vertical) ? ev.xmotion.x : ev.xmotion.y;
+        coord = (sPtr->flags.vertical) ? ev.xmotion.x : ev.xmotion.y;
 
-	switch (ev.type) {
-	 case ButtonRelease:
-	    done = 1;
-	    if (dragging)
-		drawDragingRectangle(sPtr, pos);
-	    break;
-	    
-	 case MotionNotify:
-	    if (dragging)
-		drawDragingRectangle(sPtr, pos);
-	    if (coord - ofs < minCoord)
-		pos = minCoord;
-	    else if (coord - ofs > maxCoord)
-		pos = maxCoord;
-	    else
-		pos = coord - ofs;
-	    drawDragingRectangle(sPtr, pos);
-	    dragging = 1;
-	    break;
-	    
-	 default:
-	    WMHandleEvent(&ev);
-	    break;
-	}
+        switch (ev.type) {
+        case ButtonRelease:
+            done = 1;
+            if (dragging)
+                drawDragingRectangle(sPtr, pos);
+            break;
+
+        case MotionNotify:
+            if (dragging)
+                drawDragingRectangle(sPtr, pos);
+            if (coord - ofs < minCoord)
+                pos = minCoord;
+            else if (coord - ofs > maxCoord)
+                pos = maxCoord;
+            else
+                pos = coord - ofs;
+            drawDragingRectangle(sPtr, pos);
+            dragging = 1;
+            break;
+
+        default:
+            WMHandleEvent(&ev);
+            break;
+        }
     }
-    
+
     if (dragging) {
-    	W_SplitViewSubview *p1, *p2;
-	int totSize;
-	
-	p1 = _GetPSubviewStructAt(divider);
-	p2 = _GetPSubviewStructAt(divider+1);
-	
-	totSize = p1->size + DIVIDER_THICKNESS + p2->size;
-	
-	p1->size = pos - p1->pos;
-	p2->size = totSize - p1->size - DIVIDER_THICKNESS;
-	p2->pos = p1->pos + p1->size  + DIVIDER_THICKNESS;
-	
-	resizeView(sPtr, p1->view, p1->size);
-	moveView(sPtr, p2->view, p2->pos);
-	resizeView(sPtr, p2->view, p2->size);
-	sPtr->flags.subviewsWereManuallyMoved = 1;
+        W_SplitViewSubview *p1, *p2;
+        int totSize;
+
+        p1 = _GetPSubviewStructAt(divider);
+        p2 = _GetPSubviewStructAt(divider+1);
+
+        totSize = p1->size + DIVIDER_THICKNESS + p2->size;
+
+        p1->size = pos - p1->pos;
+        p2->size = totSize - p1->size - DIVIDER_THICKNESS;
+        p2->pos = p1->pos + p1->size  + DIVIDER_THICKNESS;
+
+        resizeView(sPtr, p1->view, p1->size);
+        moveView(sPtr, p2->view, p2->pos);
+        resizeView(sPtr, p2->view, p2->size);
+        sPtr->flags.subviewsWereManuallyMoved = 1;
     }
 }
 
@@ -614,16 +614,16 @@ handleEvents(XEvent *event, void *data)
     CHECK_CLASS(data, WC_SplitView);
 
 
-    switch (event->type) {	
-     case Expose:
-	if (event->xexpose.count!=0)
-	    break;
-	paintSplitView(sPtr);
-	break;
-	
-     case DestroyNotify:
-	destroySplitView(sPtr);
-	break;
+    switch (event->type) {
+    case Expose:
+        if (event->xexpose.count!=0)
+            break;
+        paintSplitView(sPtr);
+        break;
+
+    case DestroyNotify:
+        destroySplitView(sPtr);
+        break;
     }
 }
 
@@ -631,14 +631,14 @@ handleEvents(XEvent *event, void *data)
 static void
 handleActionEvents(XEvent *event, void *data)
 {
-    
+
     CHECK_CLASS(data, WC_SplitView);
 
     switch (event->type) {
-     case ButtonPress:
-	if (event->xbutton.button == Button1)
-	    dragDivider(data, event->xbutton.x, event->xbutton.y);
-	break;
+    case ButtonPress:
+        if (event->xbutton.button == Button1)
+            dragDivider(data, event->xbutton.x, event->xbutton.y);
+        break;
     }
 }
 
@@ -663,27 +663,27 @@ WMCreateSplitView(WMWidget *parent)
     memset(sPtr, 0, sizeof(WMSplitView));
 
     sPtr->widgetClass = WC_SplitView;
-    
+
     sPtr->view = W_CreateView(W_VIEW(parent));
     if (!sPtr->view) {
-	wfree(sPtr);
-	return NULL;
+        wfree(sPtr);
+        return NULL;
     }
     sPtr->view->self = sPtr;
 
     WMSetViewNotifySizeChanges(sPtr->view, True);
 
     WMCreateEventHandler(sPtr->view, ExposureMask|StructureNotifyMask
-			 |ClientMessageMask, handleEvents, sPtr);
+                         |ClientMessageMask, handleEvents, sPtr);
 
 
     WMCreateEventHandler(sPtr->view, ButtonPressMask|ButtonReleaseMask
-			 |EnterWindowMask|LeaveWindowMask, 
-			 handleActionEvents, sPtr);
+                         |EnterWindowMask|LeaveWindowMask,
+                         handleActionEvents, sPtr);
 
 
-    WMAddNotificationObserver(handleViewResized, sPtr, 
-			      WMViewSizeDidChangeNotification, sPtr->view);
+    WMAddNotificationObserver(handleViewResized, sPtr,
+                              WMViewSizeDidChangeNotification, sPtr->view);
 
     sPtr->subviews = WMCreateArrayWithDestructor(8, wfree);
 
@@ -695,7 +695,7 @@ void
 WMAdjustSplitViewSubviews(WMSplitView *sPtr)
 {
     CHECK_CLASS(sPtr, WC_SplitView);
-    
+
     checkSizes(sPtr);
 
     adjustSplitViewSubviews(sPtr);
@@ -713,42 +713,42 @@ WMAddSplitViewSubview(WMSplitView *sPtr, WMView *subview)
     CHECK_CLASS(sPtr, WC_SplitView);
 
     if (!(p = (W_SplitViewSubview*)wmalloc(sizeof(W_SplitViewSubview))))
-    	return;
+        return;
 
     wasMapped = subview->flags.mapped;
     if (wasMapped)
-	W_UnmapView(subview);
+        W_UnmapView(subview);
 
     count = _GetSubviewsCount();
     p->view = subview;
     getConstraints(sPtr, count, &(p->minSize), &(p->maxSize));
     if (sPtr->flags.vertical)
-    	p->size = subview->size.width;
+        p->size = subview->size.width;
     else
-    	p->size = subview->size.height;
+        p->size = subview->size.height;
 
     WMAddToArray(sPtr->subviews, p);
     reparentView(sPtr, subview, 0);
 
-/*
-    We should have something like that...
-    
-    WMSetViewNotifySizeChanges(subview, True);
-    WMAddNotificationObserver(handleSubviewResized, sPtr, 
-			      WMViewSizeDidChangeNotification,
-			      subview);
-    WMSetViewNotifyMoveChanges(subview, True);
-    WMAddNotificationObserver(handleSubviewResized, sPtr, 
-			      WMViewMoveDidChangeNotification,
-			      subview);
-*/
-    if (wasMapped) {
-	W_MapView(subview);
+    /*
+     We should have something like that...
 
-	sPtr->flags.adjustOnPaint = 1;
-	paintSplitView(sPtr);
+     WMSetViewNotifySizeChanges(subview, True);
+     WMAddNotificationObserver(handleSubviewResized, sPtr,
+     WMViewSizeDidChangeNotification,
+     subview);
+     WMSetViewNotifyMoveChanges(subview, True);
+     WMAddNotificationObserver(handleSubviewResized, sPtr,
+     WMViewMoveDidChangeNotification,
+     subview);
+     */
+    if (wasMapped) {
+        W_MapView(subview);
+
+        sPtr->flags.adjustOnPaint = 1;
+        paintSplitView(sPtr);
     } else {
-    	handleViewResized(sPtr, NULL);	
+        handleViewResized(sPtr, NULL);
     }
 }
 
@@ -759,9 +759,9 @@ WMGetSplitViewSubviewAt(WMSplitView *sPtr, int index)
     CHECK_CLASS(sPtr, WC_SplitView);
 
     if (index >= 0 && index < _GetSubviewsCount())
-    	return (_GetSubviewAt(index));
+        return (_GetSubviewAt(index));
     else
-    	return (NULL);
+        return (NULL);
 }
 
 
@@ -776,13 +776,13 @@ WMRemoveSplitViewSubview(WMSplitView *sPtr, WMView *view)
     /* TODO: rewrite this. This code with macros is getting more complex than it worths */
     count = _GetSubviewsCount();
     for (i = 0; i < count; i++) {
-    	p = _GetPSubviewStructAt(i);
-	if (p->view == view) {
-    	    WMDeleteFromArray(sPtr->subviews, i);
-    	    sPtr->flags.adjustOnPaint = 1;
-    	    paintSplitView(sPtr);
-	    break;
-	}
+        p = _GetPSubviewStructAt(i);
+        if (p->view == view) {
+            WMDeleteFromArray(sPtr->subviews, i);
+            sPtr->flags.adjustOnPaint = 1;
+            paintSplitView(sPtr);
+            break;
+        }
     }
 }
 
@@ -796,15 +796,15 @@ WMRemoveSplitViewSubviewAt(WMSplitView *sPtr, int index)
 
     /* TODO: same about rewrite */
     if (index >= 0 && index < _GetSubviewsCount()) {
-    	p = _GetPSubviewStructAt(index);
-    	WMDeleteFromArray(sPtr->subviews, index);
-    	sPtr->flags.adjustOnPaint = 1;
-	paintSplitView(sPtr);
+        p = _GetPSubviewStructAt(index);
+        WMDeleteFromArray(sPtr->subviews, index);
+        sPtr->flags.adjustOnPaint = 1;
+        paintSplitView(sPtr);
     }
 }
 
 
-void 
+void
 WMSetSplitViewConstrainProc(WMSplitView *sPtr, WMSplitViewConstrainProc *proc)
 {
     CHECK_CLASS(sPtr, WC_SplitView);
@@ -834,20 +834,20 @@ void
 WMSetSplitViewVertical(WMSplitView *sPtr, Bool flag)
 {
     int vertical;
-    
+
     CHECK_CLASS(sPtr, WC_SplitView);
 
     vertical = ((flag==0) ? 0 : 1);
     if (sPtr->flags.vertical == vertical)
-    	return;
-    
+        return;
+
     sPtr->flags.vertical = vertical;
-    
-/*    if (sPtr->view->flags.mapped && sPtr->view->flags.realized)*/
-    	handleViewResized(sPtr, NULL);
-/*    else
-    	sPtr->flags.adjustOnPaint = 1;
- */
+
+    /*    if (sPtr->view->flags.mapped && sPtr->view->flags.realized)*/
+    handleViewResized(sPtr, NULL);
+    /*    else
+     sPtr->flags.adjustOnPaint = 1;
+     */
 }
 
 
@@ -861,11 +861,12 @@ WMGetSplitViewDividerThickness(WMSplitView *sPtr)
 
 #if 0
 void
-WMSetSplitViewResizeSubviewsProc(WMSplitView *sPtr, 
-				 WMSplitViewResizeSubviewsProc *proc)
+WMSetSplitViewResizeSubviewsProc(WMSplitView *sPtr,
+                                 WMSplitViewResizeSubviewsProc *proc)
 {
     CHECK_CLASS(sPtr, WC_SplitView);
 
     sPtr->resizeSubviewsProc = proc;
 }
 #endif
+