Initial revision

1 files changed, 1636 insertions, 0 deletions

diff --git a/microkde/KDGanttMinimizeSplitter.cpp b/microkde/KDGanttMinimizeSplitter.cpp
new file mode 100644
index 0000000..60b8bc7
--- a/dev/null
+++ b/microkde/KDGanttMinimizeSplitter.cpp
@@ -0,0 +1,1636 @@
+/* -*- Mode: C++ -*-
+   $Id$
+*/
+
+/****************************************************************************
+ ** Copyright (C)  2002-2004 Klarälvdalens Datakonsult AB.  All rights reserved.
+ **
+ ** This file is part of the KDGantt library.
+ **
+ ** This file may be distributed and/or modified under the terms of the
+ ** GNU General Public License version 2 as published by the Free Software
+ ** Foundation and appearing in the file LICENSE.GPL included in the
+ ** packaging of this file.
+ **
+ ** Licensees holding valid commercial KDGantt licenses may use this file in
+ ** accordance with the KDGantt Commercial License Agreement provided with
+ ** the Software.
+ **
+ ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
+ ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ **
+ ** See http://www.klaralvdalens-datakonsult.se/Public/products/ for
+ **   information about KDGantt Commercial License Agreements.
+ **
+ ** Contact info@klaralvdalens-datakonsult.se if any conditions of this
+ ** licensing are not clear to you.
+ **
+ ** As a special exception, permission is given to link this program
+ ** with any edition of Qt, and distribute the resulting executable,
+ ** without including the source code for Qt in the source distribution.
+ **
+ **********************************************************************/
+
+#include "KDGanttMinimizeSplitter.h"
+#ifndef QT_NO_SPLITTER___
+
+#include "qpainter.h"
+#include "qdrawutil.h"
+#include "qbitmap.h"
+#if QT_VERSION >= 300
+#include "qptrlist.h"
+#include "qmemarray.h"
+#else
+#include <qlist.h>
+#include <qarray.h>
+#define QPtrList QList
+#define QMemArray QArray
+#endif
+#include "qlayoutengine_p.h"
+#include "qobjectlist.h"
+#include "qstyle.h"
+#include "qapplication.h" //sendPostedEvents
+#include <qvaluelist.h>
+#include <qcursor.h>
+#ifndef KDGANTT_MASTER_CVS
+//#include "KDGanttMinimizeSplitter.moc"
+#endif
+
+
+
+#ifndef DOXYGEN_SKIP_INTERNAL
+
+#if QT_VERSION >= 232
+static int mouseOffset;
+static int opaqueOldPos = -1; //### there's only one mouse, but this is a bit risky
+
+
+KDGanttSplitterHandle::KDGanttSplitterHandle( Qt::Orientation o,
+				  KDGanttMinimizeSplitter *parent, const char * name )
+    : QWidget( parent, name ), _activeButton( 0 ), _collapsed( false )
+{
+
+    if ( QApplication::desktop()->width() > 320 &&  QApplication::desktop()->width() < 650 ) {
+        mSizeHint = QSize(7,7);
+        mUseOffset = true;
+    } else {
+        mSizeHint = QSize(6,6);
+        mUseOffset = false;
+    }
+    s = parent;
+    setOrientation(o);
+    setMouseTracking( true );
+    //setMaximumHeight( 5 ); // test only
+}
+
+QSize KDGanttSplitterHandle::sizeHint() const
+{
+    return  mSizeHint;
+}
+
+void KDGanttSplitterHandle::setOrientation( Qt::Orientation o )
+{
+    orient = o;
+#ifndef QT_NO_CURSOR
+    if ( o == KDGanttMinimizeSplitter::Horizontal )
+	setCursor( splitHCursor );
+    else
+	setCursor( splitVCursor );
+#endif
+}
+
+
+void KDGanttSplitterHandle::mouseMoveEvent( QMouseEvent *e )
+{
+    updateCursor( e->pos() );
+    if ( !(e->state()&LeftButton) )
+	return;
+
+    if ( _activeButton != 0)
+        return;
+
+    QCOORD pos = s->pick(parentWidget()->mapFromGlobal(e->globalPos()))
+		 - mouseOffset;
+    if ( true /*opaque()*/ ) {
+	s->moveSplitter( pos, id() );
+    } else {
+	int min = pos; int max = pos;
+	s->getRange( id(), &min, &max );
+	s->setRubberband( QMAX( min, QMIN(max, pos )));
+    }
+    _collapsed = false;
+}
+
+void KDGanttSplitterHandle::mousePressEvent( QMouseEvent *e )
+{
+    if ( e->button() == LeftButton ) {
+        _activeButton = onButton( e->pos() );
+        mouseOffset = s->pick(e->pos());
+        if ( _activeButton != 0)
+            repaint();
+        updateCursor( e->pos() );
+    }
+}
+
+void KDGanttSplitterHandle::updateCursor( const QPoint& p)
+{
+    if ( onButton( p ) != 0 ) {
+        setCursor( arrowCursor );
+    }
+    else {
+        if ( orient == KDGanttMinimizeSplitter::Horizontal )
+            setCursor( splitHCursor );
+        else
+            setCursor( splitVCursor );
+    }
+}
+void KDGanttSplitterHandle::toggle()
+{
+    int pos;
+    int min, max;
+    if ( !_collapsed ) {
+        s->expandPos( id(), &min, &max );
+        if ( s->minimizeDirection() == KDGanttMinimizeSplitter::Left
+             || s->minimizeDirection() == KDGanttMinimizeSplitter::Up ) {
+            pos = min;
+        }
+        else {
+            pos = max;
+        }
+
+        _origPos = s->pick(mapToParent( QPoint( 0,0 ) ));
+        s->moveSplitter( pos, id() );
+        _collapsed = true;
+    }
+    else {
+        s->moveSplitter( _origPos, id() );
+        _collapsed = false;
+    }
+}
+
+void KDGanttSplitterHandle::mouseReleaseEvent( QMouseEvent *e )
+{
+    if ( _activeButton != 0 ) {
+        if ( onButton( e->pos() ) == _activeButton )
+        {
+            toggle();
+        }
+        _activeButton = 0;
+        updateCursor( e->pos() );
+    }
+    else {
+        if ( !opaque() && e->button() == LeftButton ) {
+            QCOORD pos = s->pick(parentWidget()->mapFromGlobal(e->globalPos()))
+                - mouseOffset;
+            s->setRubberband( -1 );
+            s->moveSplitter( pos, id() );
+        }
+    }
+    repaint();
+}
+
+int KDGanttSplitterHandle::onButton( const QPoint& p )
+{
+    QValueList<QPointArray> list = buttonRegions();
+    int index = 1;
+    int add = 12;
+    for( QValueList<QPointArray>::Iterator it = list.begin(); it != list.end(); ++it ) {
+        QRect rect = (*it).boundingRect();
+        rect.setLeft( rect.left()- add );
+        rect.setRight( rect.right() + add);
+        rect.setTop( rect.top()- add );
+        rect.setBottom( rect.bottom() + add);
+        if ( rect.contains( p ) ) {
+            return index;
+        }
+        index++;
+    }
+    return 0;
+}
+
+
+QValueList<QPointArray> KDGanttSplitterHandle::buttonRegions()
+{
+    QValueList<QPointArray> list;
+
+    int sw = 8;
+    int yyy = 1;
+    int xxx = 1;
+    int voffset[] = { (int) -sw*3, (int) sw*3 };
+    for ( int i = 0; i < 2; i++ ) {
+        QPointArray arr;
+        if ( !_collapsed && s->minimizeDirection() == KDGanttMinimizeSplitter::Right ||
+             _collapsed  && s->minimizeDirection() == KDGanttMinimizeSplitter::Left) {
+            int mid = height()/2 + voffset[i];
+            arr.setPoints( 3,
+                           1-xxx, mid - sw + 4,
+                           sw-3-xxx, mid,
+                           1-xxx, mid + sw -4);
+        }
+        else if ( !_collapsed &&  s->minimizeDirection() == KDGanttMinimizeSplitter::Left ||
+                  _collapsed  && s->minimizeDirection() == KDGanttMinimizeSplitter::Right ) {
+            int mid = height()/2 + voffset[i];
+            arr.setPoints( 3,
+                           sw-4, mid - sw + 4,
+                           0, mid,
+                           sw-4, mid + sw - 4);
+        }
+        else if ( !_collapsed &&  s->minimizeDirection() == KDGanttMinimizeSplitter::Up ||
+                  _collapsed  && s->minimizeDirection() == KDGanttMinimizeSplitter::Down) {
+            int mid = width()/2 + voffset[i];
+            arr.setPoints( 3,
+                           mid - sw + 4, sw-4,
+                           mid, 0,
+                           mid + sw - 4, sw-4 );
+        }
+        else if ( !_collapsed && s->minimizeDirection() == KDGanttMinimizeSplitter::Down ||
+                  _collapsed  && s->minimizeDirection() == KDGanttMinimizeSplitter::Up ) {
+            int mid = width()/2 + voffset[i];
+            arr.setPoints( 3,
+                           mid - sw + 4, 1-yyy,
+                           mid, sw-3-yyy,
+                           mid + sw -4, 1-yyy);
+        }
+        list.append( arr );
+    }
+    return list;
+}
+
+void KDGanttSplitterHandle::paintEvent( QPaintEvent * )
+{
+    QPixmap buffer( size() );
+    QPainter p( &buffer );
+
+    //LR
+    // Draw the splitter rectangle
+    p.setBrush( colorGroup().background() );
+    p.setPen( colorGroup().foreground() );
+    //p.drawRect( rect() );
+    buffer.fill( colorGroup().background() );
+    //buffer.fill( backgroundColor() );
+    // parentWidget()->style().drawPrimitive( QStyle::PE_Panel, &p, rect(), parentWidget()->colorGroup());
+
+    int sw = 8; // Hardcoded, given I didn't use styles anymore, I didn't like to use their size
+
+    // arrow color
+    QColor col;
+    if ( _activeButton )
+        col = colorGroup().background().dark( 250 );
+    else
+        col = colorGroup().background().dark( 150 );
+    //QColor col = backgroundColor().dark( 130 );
+    p.setBrush( col );
+    p.setPen( col  );
+
+    QValueList<QPointArray> list = buttonRegions();
+    int index = 1;
+    if ( mUseOffset )
+        p.translate( 0, 1 );
+    for ( QValueList<QPointArray>::Iterator it = list.begin(); it != list.end(); ++it ) {
+        if ( index == _activeButton ) { 
+           
+            /*
+            if ( ! _collapsed ) {
+            p.save();
+            // p.translate( parentWidget()->style().pixelMetric( QStyle::PM_ButtonShiftHorizontal ),
+            //           parentWidget()->style().pixelMetric( QStyle::PM_ButtonShiftVertical ) );
+            p.translate( -1, 0 );
+            p.drawPolygon( *it, true );
+            p.restore(); } else
+            */
+            p.drawPolygon( *it, true );
+                
+        }
+        else {
+            /*
+            if ( ! _collapsed ) {
+            p.save();
+            p.translate( -1, 0 );
+            p.drawPolygon( *it, true );
+            p.restore();
+            } else
+            */
+            p.drawPolygon( *it, true );
+                
+        }
+        index++;
+    }
+
+    // Draw the lines between the arrows
+    if ( s->minimizeDirection() == KDGanttMinimizeSplitter::Left ||
+         s->minimizeDirection() == KDGanttMinimizeSplitter::Right ) {
+        int mid = height()/2;
+        p.drawLine ( 1, mid - sw, 1, mid + sw );
+        p.drawLine ( 3, mid - sw, 3, mid + sw );
+    }
+    else if ( s->minimizeDirection() == KDGanttMinimizeSplitter::Up ||
+              s->minimizeDirection() == KDGanttMinimizeSplitter::Down ) {
+        int mid = width()/2;
+        p.drawLine( mid -sw, 1, mid +sw, 1 );
+        p.drawLine( mid -sw, 3, mid +sw, 3 );
+    }
+    bitBlt( this, 0, 0, &buffer );
+
+}
+#endif
+
+class QSplitterLayoutStruct
+{
+public:
+    KDGanttMinimizeSplitter::ResizeMode mode;
+    QCOORD sizer;
+    bool isSplitter;
+    QWidget *wid;
+};
+
+class QSplitterData
+{
+public:
+    QSplitterData() : opaque( FALSE ), firstShow( TRUE ) {}
+
+    QPtrList<QSplitterLayoutStruct> list;
+    bool opaque;
+    bool firstShow;
+};
+
+void kdganttGeomCalc( QMemArray<QLayoutStruct> &chain, int start, int count, int pos,
+                 int space, int spacer );
+#endif // DOXYGEN_SKIP_INTERNAL
+
+
+/*!
+  \class KDGanttMinimizeSplitter KDGanttMinimizeSplitter.h
+  \brief The KDGanttMinimizeSplitter class implements a splitter
+  widget with minimize buttons.
+
+  This class (and its documentation) is largely a copy of Qt's
+  QSplitter; the copying was necessary because QSplitter is not
+  extensible at all. QSplitter and its documentation are licensed
+  according to the GPL and the Qt Professional License (if you hold
+  such a license) and are (C) Trolltech AS.
+
+  A splitter lets the user control the size of child widgets by
+  dragging the boundary between the children. Any number of widgets
+  may be controlled.
+
+  To show a QListBox, a QListView and a QTextEdit side by side:
+
+  \code
+    KDGanttMinimizeSplitter *split = new KDGanttMinimizeSplitter( parent );
+    QListBox *lb = new QListBox( split );
+    QListView *lv = new QListView( split );
+    QTextEdit *ed = new QTextEdit( split );
+  \endcode
+
+  In KDGanttMinimizeSplitter, the boundary can be either horizontal or
+  vertical.  The default is horizontal (the children are side by side)
+  but you can use setOrientation( QSplitter::Vertical ) to set it to
+  vertical.
+
+  Use setResizeMode() to specify
+  that a widget should keep its size when the splitter is resized.
+
+  Although KDGanttMinimizeSplitter normally resizes the children only
+  at the end of a resize operation, if you call setOpaqueResize( TRUE
+  ) the widgets are resized as often as possible.
+
+  The initial distribution of size between the widgets is determined
+  by the initial size of each widget. You can also use setSizes() to
+  set the sizes of all the widgets. The function sizes() returns the
+  sizes set by the user.
+
+  If you hide() a child, its space will be distributed among the other
+  children. It will be reinstated when you show() it again. It is also
+  possible to reorder the widgets within the splitter using
+  moveToFirst() and moveToLast().
+*/
+
+
+
+static QSize minSize( const QWidget* /*w*/ )
+{
+    return QSize(0,0);
+}
+
+// This is the original version of minSize
+static QSize minSizeHint( const QWidget* w )
+{
+    QSize min = w->minimumSize();
+    QSize s;
+    if ( min.height() <= 0 || min.width() <= 0 )
+	s = w->minimumSizeHint();
+    if ( min.height() > 0 )
+	s.setHeight( min.height() );
+    if ( min.width() > 0 )
+	s.setWidth( min.width() );
+    return s.expandedTo(QSize(0,0));
+}
+
+
+
+/*!
+  Constructs a horizontal splitter with the \a parent and \a
+  name arguments being passed on to the QFrame constructor.
+*/
+KDGanttMinimizeSplitter::KDGanttMinimizeSplitter( QWidget *parent, const char *name )
+    :QFrame(parent,name,WPaintUnclipped)
+{
+    mFirstHandle = 0;
+#if QT_VERSION >= 232
+     orient = Horizontal;
+     init();
+#endif
+}
+
+/*!
+  Constructs a splitter with orientation \a o with the \a parent
+  and \a name arguments being passed on to the QFrame constructor.
+*/
+KDGanttMinimizeSplitter::KDGanttMinimizeSplitter( Orientation o, QWidget *parent, const char *name )
+    :QFrame(parent,name,WPaintUnclipped)
+{ 
+    mFirstHandle = 0;
+#if QT_VERSION >= 232
+     orient = o;
+     init();
+#endif
+}
+
+/*!
+  Destroys the splitter and any children.
+*/
+KDGanttMinimizeSplitter::~KDGanttMinimizeSplitter()
+{
+#if QT_VERSION >= 232
+    data->list.setAutoDelete( TRUE );
+    delete data;
+#endif
+}
+
+
+#if QT_VERSION >= 232
+void KDGanttMinimizeSplitter::init()
+{
+    data = new QSplitterData;
+    if ( orient == Horizontal )
+	setSizePolicy( QSizePolicy(QSizePolicy::Expanding,QSizePolicy::Minimum) );
+    else
+	setSizePolicy( QSizePolicy(QSizePolicy::Minimum,QSizePolicy::Expanding) );
+}
+#endif
+
+
+
+/*!
+  \brief the orientation of the splitter
+
+  By default the orientation is horizontal (the widgets are side by side).
+  The possible orientations are Qt:Vertical and Qt::Horizontal (the default).
+*/
+void KDGanttMinimizeSplitter::setOrientation( Orientation o )
+{
+#if QT_VERSION >= 232
+    if ( orient == o )
+	return;
+    orient = o;
+
+    if ( orient == Horizontal )
+	setSizePolicy( QSizePolicy( QSizePolicy::Expanding, QSizePolicy::Minimum ) );
+    else
+	setSizePolicy( QSizePolicy( QSizePolicy::Minimum, QSizePolicy::Expanding ) );
+
+    QSplitterLayoutStruct *s = data->list.first();
+    while ( s ) {
+	if ( s->isSplitter )
+	    ((KDGanttSplitterHandle*)s->wid)->setOrientation( o );
+	s = data->list.next();  // ### next at end of loop, no iterator
+    }
+    recalc( isVisible() );
+#endif
+}
+
+
+#if QT_VERSION >= 232
+/*!
+  \reimp
+*/
+void KDGanttMinimizeSplitter::resizeEvent( QResizeEvent * )
+{
+    doResize();
+}
+
+
+/*
+  Inserts the widget \a w at the end (or at the beginning if \a first
+  is TRUE) of the splitter's list of widgets.
+
+  It is the responsibility of the caller of this function to make sure
+  that \a w is not already in the splitter and to call recalcId if
+  needed.  (If \a first is TRUE, then recalcId is very probably
+  needed.)
+*/
+QSplitterLayoutStruct *KDGanttMinimizeSplitter::addWidget( QWidget *w, bool first )
+{
+    QSplitterLayoutStruct *s;
+    KDGanttSplitterHandle *newHandle = 0;
+    if ( data->list.count() > 0 ) {
+	s = new QSplitterLayoutStruct;
+	s->mode = KeepSize;
+	QString tmp = "qt_splithandle_";
+	tmp += w->name();
+	newHandle = new KDGanttSplitterHandle( orientation(), this, tmp.latin1() );
+    if ( ! mFirstHandle )
+        mFirstHandle = newHandle;
+	s->wid = newHandle;
+	newHandle->setId(data->list.count());
+	s->isSplitter = TRUE;
+	s->sizer = pick( newHandle->sizeHint() );
+	if ( first )
+	    data->list.insert( 0, s );
+	else
+	    data->list.append( s );
+    }
+    s = new QSplitterLayoutStruct;
+    s->mode = Stretch;
+    s->wid = w;
+    if ( !testWState( WState_Resized ) && w->sizeHint().isValid() )
+	s->sizer = pick( w->sizeHint() );
+    else
+	s->sizer = pick( w->size() );
+    s->isSplitter = FALSE;
+    if ( first )
+	data->list.insert( 0, s );
+    else
+	data->list.append( s );
+    if ( newHandle && isVisible() )
+	newHandle->show(); //will trigger sending of post events
+    return s;
+}
+
+
+/*!
+  Tells the splitter that a child widget has been inserted or removed.
+  The event is passed in \a c.
+*/
+void KDGanttMinimizeSplitter::childEvent( QChildEvent *c )
+{
+    if ( c->type() == QEvent::ChildInserted ) {
+	if ( !c->child()->isWidgetType() )
+	    return;
+
+	if ( ((QWidget*)c->child())->testWFlags( WType_TopLevel ) )
+	    return;
+
+	QSplitterLayoutStruct *s = data->list.first();
+	while ( s ) {
+	    if ( s->wid == c->child() )
+		return;
+	    s = data->list.next();
+	}
+	addWidget( (QWidget*)c->child() );
+	recalc( isVisible() );
+
+    } else if ( c->type() == QEvent::ChildRemoved ) {
+	QSplitterLayoutStruct *p = 0;
+	if ( data->list.count() > 1 )
+	    p = data->list.at(1); //remove handle _after_ first widget.
+	QSplitterLayoutStruct *s = data->list.first();
+	while ( s ) {
+	    if ( s->wid == c->child() ) {
+		data->list.removeRef( s );
+		delete s;
+		if ( p && p->isSplitter ) {
+		    data->list.removeRef( p );
+		    delete p->wid; //will call childEvent
+		    delete p;
+		}
+		recalcId();
+		doResize();
+		return;
+	    }
+	    p = s;
+	    s = data->list.next();
+	}
+    }
+}
+
+
+/*!
+  Shows a rubber band at position \a p. If \a p is negative, the
+  rubber band is removed.
+*/
+void KDGanttMinimizeSplitter::setRubberband( int p )
+{
+    QPainter paint( this );
+    paint.setPen( gray );
+    paint.setBrush( gray );
+    paint.setRasterOp( XorROP );
+    QRect r = contentsRect();
+    const int rBord = 3; //Themable????
+#if QT_VERSION >= 300
+    int sw = style().pixelMetric(QStyle::PM_SplitterWidth, this);
+#else
+    int sw = style().splitterWidth();
+#endif
+    if ( orient == Horizontal ) {
+	if ( opaqueOldPos >= 0 )
+	    paint.drawRect( opaqueOldPos + sw/2 - rBord , r.y(),
+			    2*rBord, r.height() );
+	if ( p >= 0 )
+	    paint.drawRect( p  + sw/2 - rBord, r.y(), 2*rBord, r.height() );
+    } else {
+	if ( opaqueOldPos >= 0 )
+	    paint.drawRect( r.x(), opaqueOldPos + sw/2 - rBord,
+			    r.width(), 2*rBord );
+	if ( p >= 0 )
+	    paint.drawRect( r.x(), p + sw/2 - rBord, r.width(), 2*rBord );
+    }
+    opaqueOldPos = p;
+}
+
+
+/*! \reimp */
+bool KDGanttMinimizeSplitter::event( QEvent *e )
+{
+    if ( e->type() == QEvent::LayoutHint || ( e->type() == QEvent::Show && data->firstShow ) ) {
+	recalc( isVisible() );
+	if ( e->type() == QEvent::Show )
+	    data->firstShow = FALSE;
+    }
+    return QWidget::event( e );
+}
+
+
+/*!
+  \obsolete
+
+  Draws the splitter handle in the rectangle described by \a x, \a y,
+  \a w, \a h using painter \a p.
+  \sa QStyle::drawPrimitive()
+*/
+void KDGanttMinimizeSplitter::drawSplitter( QPainter *p,
+			      QCOORD x, QCOORD y, QCOORD w, QCOORD h )
+{
+#if 0
+    // LR
+    style().drawPrimitive(QStyle::PE_Splitter, p, QRect(x, y, w, h), colorGroup(),
+			  (orientation() == Qt::Horizontal ?
+			   QStyle::Style_Horizontal : 0));
+#endif
+}
+
+
+/*!
+  Returns the id of the splitter to the right of or below the widget \a w,
+  or 0 if there is no such splitter
+  (i.e. it is either not in this KDGanttMinimizeSplitter or it is at the end).
+*/
+int KDGanttMinimizeSplitter::idAfter( QWidget* w ) const
+{
+    QSplitterLayoutStruct *s = data->list.first();
+    bool seen_w = FALSE;
+    while ( s ) {
+	if ( s->isSplitter && seen_w )
+	    return data->list.at();
+	if ( !s->isSplitter && s->wid == w )
+	    seen_w = TRUE;
+	s = data->list.next();
+    }
+    return 0;
+}
+
+
+/*!
+  Moves the left/top edge of the splitter handle with id \a id as
+  close as possible to position \a p, which is the distance from the
+  left (or top) edge of the widget.
+
+  For Arabic and Hebrew the layout is reversed, and using this
+  function to set the position of the splitter might lead to
+  unexpected results, since in Arabic and Hebrew the position of
+  splitter one is to the left of the position of splitter zero.
+
+  \sa idAfter()
+*/
+void KDGanttMinimizeSplitter::moveSplitter( QCOORD p, int id )
+{
+    p = adjustPos( p, id );
+    QSplitterLayoutStruct *s = data->list.at(id);
+    int oldP = orient == Horizontal ? s->wid->x() : s->wid->y();
+    bool upLeft;
+    if ( false && orient == Horizontal ) {
+	p += s->wid->width();
+	upLeft = p > oldP;
+    } else
+	upLeft = p < oldP;
+
+    moveAfter( p, id, upLeft );
+    moveBefore( p-1, id-1, upLeft );
+
+    storeSizes();
+}
+
+
+void KDGanttMinimizeSplitter::setG( QWidget *w, int p, int s, bool isSplitter )
+{
+    if ( orient == Horizontal ) {
+	if ( false && orient == Horizontal && !isSplitter )
+	    p = contentsRect().width() - p - s;
+	w->setGeometry( p, contentsRect().y(), s, contentsRect().height() );
+    } else
+	w->setGeometry( contentsRect().x(), p, contentsRect().width(), s );
+}
+
+
+/*
+  Places the right/bottom edge of the widget at \a id at position \a pos.
+
+  \sa idAfter()
+*/
+void KDGanttMinimizeSplitter::moveBefore( int pos, int id, bool upLeft )
+{
+    if( id < 0 )
+	return;
+    QSplitterLayoutStruct *s = data->list.at(id);
+    if ( !s )
+	return;
+    QWidget *w = s->wid;
+    if ( w->isHidden() ) {
+	moveBefore( pos, id-1, upLeft );
+    } else if ( s->isSplitter ) {
+	int pos1, pos2;
+	int dd = s->sizer;
+	if( false && orient == Horizontal ) {
+	    pos1 = pos;
+	    pos2 = pos + dd;
+	} else {
+	    pos2 = pos - dd;
+	    pos1 = pos2 + 1;
+	}
+	if ( upLeft ) {
+	    setG( w, pos1, dd, TRUE );
+	    moveBefore( pos2, id-1, upLeft );
+	} else {
+	    moveBefore( pos2, id-1, upLeft );
+	    setG( w, pos1, dd, TRUE );
+	}
+    } else {
+	int dd, newLeft, nextPos;
+	if( false && orient == Horizontal ) {
+	    dd = w->geometry().right() - pos;
+	    dd = QMAX( pick(minSize(w)), QMIN(dd, pick(w->maximumSize())));
+	    newLeft = pos+1;
+	    nextPos = newLeft + dd;
+	} else {
+	    dd = pos - pick( w->pos() ) + 1;
+	    dd = QMAX( pick(minSize(w)), QMIN(dd, pick(w->maximumSize())));
+	    newLeft = pos-dd+1;
+	    nextPos = newLeft - 1;
+	}
+	setG( w, newLeft, dd, TRUE );
+	moveBefore( nextPos, id-1, upLeft );
+    }
+}
+
+
+/*
+  Places the left/top edge of the widget at \a id at position \a pos.
+
+  \sa idAfter()
+*/
+void KDGanttMinimizeSplitter::moveAfter( int pos, int id, bool upLeft )
+{
+    QSplitterLayoutStruct *s = id < int(data->list.count()) ?
+			       data->list.at(id) : 0;
+    if ( !s )
+	return;
+    QWidget *w = s->wid;
+    if ( w->isHidden() ) {
+	moveAfter( pos, id+1, upLeft );
+    } else if ( pick( w->pos() ) == pos ) {
+	//No need to do anything if it's already there.
+	return;
+    } else if ( s->isSplitter ) {
+	int dd = s->sizer;
+	int pos1, pos2;
+	if( false && orient == Horizontal ) {
+	    pos2 = pos - dd;
+	    pos1 = pos2 + 1;
+	} else {
+	    pos1 = pos;
+	    pos2 = pos + dd;
+	}
+	if ( upLeft ) {
+	    setG( w, pos1, dd, TRUE );
+	    moveAfter( pos2, id+1, upLeft );
+	} else {
+	    moveAfter( pos2, id+1, upLeft );
+	    setG( w, pos1, dd, TRUE );
+	}
+    } else {
+	int left = pick( w->pos() );
+	int right, dd,/* newRight,*/ newLeft, nextPos;
+	if ( false && orient == Horizontal ) {
+	    dd = pos - left + 1;
+	    dd = QMAX( pick(minSize(w)), QMIN(dd, pick(w->maximumSize())));
+	    newLeft = pos-dd+1;
+	    nextPos = newLeft - 1;
+	} else {
+	    right = pick( w->geometry().bottomRight() );
+	    dd = right - pos + 1;
+	    dd = QMAX( pick(minSize(w)), QMIN(dd, pick(w->maximumSize())));
+	    /*newRight = pos+dd-1;*/
+	    newLeft = pos;
+	    nextPos = newLeft + dd;
+	}
+	setG( w, newLeft, dd, TRUE );
+	/*if( right != newRight )*/
+	moveAfter( nextPos, id+1, upLeft );
+    }
+}
+
+
+void KDGanttMinimizeSplitter::expandPos( int id, int*  min, int* max )
+{
+    QSplitterLayoutStruct *s = data->list.at(id-1);
+    QWidget* w = s->wid;
+    *min = pick( w->mapToParent( QPoint(0,0) ) );
+
+    if ( (uint) id == data->list.count() ) {
+        pick( size() );
+    }
+    else {
+        QSplitterLayoutStruct *s = data->list.at(id+1);
+        QWidget* w = s->wid;
+        *max = pick( w->mapToParent( QPoint( w->width(), w->height() ) ) ) -8;
+    }
+}
+
+
+/*!
+  Returns the valid range of the splitter with id \a id in \a *min and \a *max.
+
+  \sa idAfter()
+*/
+
+void KDGanttMinimizeSplitter::getRange( int id, int *min, int *max )
+{
+    int minB = 0;	//before
+    int maxB = 0;
+    int minA = 0;
+    int maxA = 0;	//after
+    int n = data->list.count();
+    if ( id < 0 || id >= n )
+	return;
+    int i;
+    for ( i = 0; i < id; i++ ) {
+	QSplitterLayoutStruct *s = data->list.at(i);
+	if ( s->wid->isHidden() ) {
+	    //ignore
+	} else if ( s->isSplitter ) {
+	    minB += s->sizer;
+	    maxB += s->sizer;
+	} else {
+	    minB += pick( minSize(s->wid) );
+	    maxB += pick( s->wid->maximumSize() );
+	}
+    }
+    for ( i = id; i < n; i++ ) {
+	QSplitterLayoutStruct *s = data->list.at(i);
+	if ( s->wid->isHidden() ) {
+	    //ignore
+	} else if ( s->isSplitter ) {
+	    minA += s->sizer;
+	    maxA += s->sizer;
+	} else {
+	    minA += pick( minSize(s->wid) );
+	    maxA += pick( s->wid->maximumSize() );
+	}
+    }
+    QRect r = contentsRect();
+    if ( orient == Horizontal && false ) {
+#if QT_VERSION >= 300
+    int splitterWidth = style().pixelMetric(QStyle::PM_SplitterWidth, this);
+#else
+    int splitterWidth = style().splitterWidth();
+#endif
+      
+	if ( min )
+	    *min = pick(r.topRight()) - QMIN( maxB, pick(r.size())-minA ) - splitterWidth;
+	if ( max )
+	    *max = pick(r.topRight()) - QMAX( minB, pick(r.size())-maxA ) - splitterWidth;
+    } else {
+	if ( min )
+	    *min = pick(r.topLeft()) + QMAX( minB, pick(r.size())-maxA );
+	if ( max )
+	    *max = pick(r.topLeft()) + QMIN( maxB, pick(r.size())-minA );
+    }
+}
+
+
+/*!
+  Returns the closest legal position to \a p of the splitter with id \a id.
+
+  \sa idAfter()
+*/
+
+int KDGanttMinimizeSplitter::adjustPos( int p, int id )
+{
+    int min = 0;
+    int max = 0;
+    getRange( id, &min, &max );
+    p = QMAX( min, QMIN( p, max ) );
+
+    return p;
+}
+
+
+void KDGanttMinimizeSplitter::doResize()
+{
+    QRect r = contentsRect();
+    int i;
+    int n = data->list.count();
+    QMemArray<QLayoutStruct> a( n );
+    for ( i = 0; i< n; i++ ) {
+	a[i].init();
+	QSplitterLayoutStruct *s = data->list.at(i);
+	if ( s->wid->isHidden() ) {
+	    a[i].stretch = 0;
+	    a[i].sizeHint = a[i].minimumSize = 0;
+	    a[i].maximumSize = 0;
+	} else if ( s->isSplitter ) {
+	    a[i].stretch = 0;
+	    a[i].sizeHint = a[i].minimumSize = a[i].maximumSize = s->sizer;
+	    a[i].empty = FALSE;
+	} else if ( s->mode == KeepSize ) {
+	    a[i].stretch = 0;
+	    a[i].minimumSize = pick( minSize(s->wid) );
+	    a[i].sizeHint = s->sizer;
+	    a[i].maximumSize = pick( s->wid->maximumSize() );
+	    a[i].empty = FALSE;
+	} else if ( s->mode == FollowSizeHint ) {
+	    a[i].stretch = 0;
+	    a[i].minimumSize = a[i].sizeHint = pick( s->wid->sizeHint() );
+	    a[i].maximumSize = pick( s->wid->maximumSize() );
+	    a[i].empty = FALSE;
+	} else { //proportional
+	    a[i].stretch = s->sizer;
+	    a[i].maximumSize = pick( s->wid->maximumSize() );
+	    a[i].sizeHint = a[i].minimumSize = pick( minSize(s->wid) );
+	    a[i].empty = FALSE;
+	}
+    }
+
+    kdganttGeomCalc( a, 0, n, pick( r.topLeft() ), pick( r.size() ), 0 );
+
+    for ( i = 0; i< n; i++ ) {
+	QSplitterLayoutStruct *s = data->list.at(i);
+	setG( s->wid, a[i].pos, a[i].size );
+    }
+
+}
+
+
+void KDGanttMinimizeSplitter::recalc( bool update )
+{
+    int fi = 2*frameWidth();
+    int maxl = fi;
+    int minl = fi;
+    int maxt = QWIDGETSIZE_MAX;
+    int mint = fi;
+    int n = data->list.count();
+    bool first = TRUE;
+    /*
+      The splitter before a hidden widget is always hidden.
+      The splitter before the first visible widget is hidden.
+      The splitter before any other visible widget is visible.
+    */
+    for ( int i = 0; i< n; i++ ) {
+	QSplitterLayoutStruct *s = data->list.at(i);
+	if ( !s->isSplitter ) {
+	    QSplitterLayoutStruct *p = (i > 0) ? p = data->list.at( i-1 ) : 0;
+	    if ( p && p->isSplitter )
+		if ( first || s->wid->isHidden() )
+		    p->wid->hide(); //may trigger new recalc
+		else
+		    p->wid->show(); //may trigger new recalc
+	    if ( !s->wid->isHidden() )
+		first = FALSE;
+	}
+    }
+
+    bool empty=TRUE;
+    for ( int j = 0; j< n; j++ ) {
+	QSplitterLayoutStruct *s = data->list.at(j);
+	if ( !s->wid->isHidden() ) {
+	    empty = FALSE;
+	    if ( s->isSplitter ) {
+		minl += s->sizer;
+		maxl += s->sizer;
+	    } else {
+		QSize minS = minSize(s->wid);
+		minl += pick( minS );
+		maxl += pick( s->wid->maximumSize() );
+		mint = QMAX( mint, trans( minS ));
+		int tm = trans( s->wid->maximumSize() );
+		if ( tm > 0 )
+		    maxt = QMIN( maxt, tm );
+	    }
+	}
+    }
+    if ( empty ) {
+        if ( parentWidget() != 0 && parentWidget()->inherits("KDGanttMinimizeSplitter") ) {
+            // nested splitters; be nice
+            maxl = maxt = 0;
+        } else {
+            // KDGanttMinimizeSplitter with no children yet
+            maxl = QWIDGETSIZE_MAX;
+        }
+    } else {
+        maxl = QMIN( maxl, QWIDGETSIZE_MAX );
+    }
+    if ( maxt < mint )
+	maxt = mint;
+
+    if ( orient == Horizontal ) {
+	setMaximumSize( maxl, maxt );
+	setMinimumSize( minl, mint );
+    } else {
+	setMaximumSize( maxt, maxl );
+	setMinimumSize( mint, minl );
+    }
+    if ( update )
+	doResize();
+}
+
+/*!
+  Sets resize mode of \a w to \a mode.
+
+  \sa ResizeMode
+*/
+
+void KDGanttMinimizeSplitter::setResizeMode( QWidget *w, ResizeMode mode )
+{
+    processChildEvents();
+    QSplitterLayoutStruct *s = data->list.first();
+    while ( s ) {
+	if ( s->wid == w  ) {
+	    s->mode = mode;
+	    return;
+	}
+	s = data->list.next();
+    }
+    s = addWidget( w, TRUE );
+    s->mode = mode;
+}
+
+
+/*!
+  Returns TRUE if opaque resize is on; otherwise returns FALSE.
+
+  \sa setOpaqueResize()
+*/
+
+bool KDGanttMinimizeSplitter::opaqueResize() const
+{
+    return data->opaque;
+}
+
+
+/*!
+    If \a on is TRUE then opaque resizing is turned on; otherwise
+    opaque resizing is turned off.
+  Opaque resizing is initially turned off.
+
+  \sa opaqueResize()
+*/
+
+void KDGanttMinimizeSplitter::setOpaqueResize( bool on )
+{
+    data->opaque = on;
+}
+
+
+/*!
+  Moves widget \a w to the leftmost/top position.
+*/
+
+void KDGanttMinimizeSplitter::moveToFirst( QWidget *w )
+{
+    processChildEvents();
+    bool found = FALSE;
+    QSplitterLayoutStruct *s = data->list.first();
+    while ( s ) {
+	if ( s->wid == w  ) {
+	    found = TRUE;
+	    QSplitterLayoutStruct *p = data->list.prev();
+	    if ( p ) { // not already at first place
+		data->list.take(); //take p
+		data->list.take(); // take s
+		data->list.insert( 0, p );
+		data->list.insert( 0, s );
+	    }
+	    break;
+	}
+	s = data->list.next();
+    }
+     if ( !found )
+	addWidget( w, TRUE );
+     recalcId();
+}
+
+
+/*!
+  Moves widget \a w to the rightmost/bottom position.
+*/
+
+void KDGanttMinimizeSplitter::moveToLast( QWidget *w )
+{
+    processChildEvents();
+    bool found = FALSE;
+    QSplitterLayoutStruct *s = data->list.first();
+    while ( s ) {
+	if ( s->wid == w  ) {
+	    found = TRUE;
+	    data->list.take(); // take s
+	    QSplitterLayoutStruct *p = data->list.current();
+	    if ( p ) { // the splitter handle after s
+		data->list.take(); //take p
+		data->list.append( p );
+	    }
+	    data->list.append( s );
+	    break;
+	}
+	s = data->list.next();
+    }
+     if ( !found )
+	addWidget( w);
+     recalcId();
+}
+
+
+void KDGanttMinimizeSplitter::recalcId()
+{
+    int n = data->list.count();
+    for ( int i = 0; i < n; i++ ) {
+	QSplitterLayoutStruct *s = data->list.at(i);
+	if ( s->isSplitter )
+	    ((KDGanttSplitterHandle*)s->wid)->setId(i);
+    }
+}
+
+
+/*!\reimp
+*/
+QSize KDGanttMinimizeSplitter::sizeHint() const
+{
+    constPolish();
+    int l = 0;
+    int t = 0;
+    if ( children() ) {
+	const QObjectList * c = children();
+	QObjectListIt it( *c );
+	QObject * o;
+
+	while( (o=it.current()) != 0 ) {
+	    ++it;
+	    if ( o->isWidgetType() &&
+		 !((QWidget*)o)->isHidden() ) {
+		QSize s = ((QWidget*)o)->sizeHint();
+		if ( s.isValid() ) {
+		    l += pick( s );
+		    t = QMAX( t, trans( s ) );
+		}
+	    }
+	}
+    }
+    return orientation() == Horizontal ? QSize( l, t ) : QSize( t, l );
+}
+
+
+/*!
+\reimp
+*/
+
+QSize KDGanttMinimizeSplitter::minimumSizeHint() const
+{
+    constPolish();
+    int l = 0;
+    int t = 0;
+    if ( children() ) {
+	const QObjectList * c = children();
+	QObjectListIt it( *c );
+	QObject * o;
+
+	while( (o=it.current()) != 0 ) {
+	    ++it;
+	    if ( o->isWidgetType() &&
+		 !((QWidget*)o)->isHidden() ) {
+		QSize s = minSizeHint((QWidget*)o);
+		if ( s.isValid() ) {
+		    l += pick( s );
+		    t = QMAX( t, trans( s ) );
+		}
+	    }
+	}
+    }
+    return orientation() == Horizontal ? QSize( l, t ) : QSize( t, l );
+}
+
+
+/*
+  Calculates stretch parameters from current sizes
+*/
+
+void KDGanttMinimizeSplitter::storeSizes()
+{
+    QSplitterLayoutStruct *s = data->list.first();
+    while ( s ) {
+	if ( !s->isSplitter )
+	    s->sizer = pick( s->wid->size() );
+	s = data->list.next();
+    }
+}
+
+
+#if 0 // ### remove this code ASAP
+
+/*!
+  Hides \a w if \a hide is TRUE and updates the splitter.
+
+  \warning Due to a limitation in the current implementation,
+  calling QWidget::hide() will not work.
+*/
+
+void KDGanttMinimizeSplitter::setHidden( QWidget *w, bool hide )
+{
+    if ( w == w1 ) {
+	w1show = !hide;
+    } else if ( w == w2 ) {
+	w2show = !hide;
+    } else {
+#ifdef QT_CHECK_RANGE
+	qWarning( "KDGanttMinimizeSplitter::setHidden(), unknown widget" );
+#endif
+	return;
+    }
+    if ( hide )
+	w->hide();
+    else
+	w->show();
+    recalc( TRUE );
+}
+
+
+/*!
+  Returns the hidden status of \a w
+*/
+
+bool KDGanttMinimizeSplitter::isHidden( QWidget *w ) const
+{
+    if ( w == w1 )
+	return !w1show;
+     else if ( w == w2 )
+	return !w2show;
+#ifdef QT_CHECK_RANGE
+    else
+	qWarning( "KDGanttMinimizeSplitter::isHidden(), unknown widget" );
+#endif
+    return FALSE;
+}
+#endif
+
+
+/*!
+  Returns a list of the size parameters of all the widgets in this
+  splitter.
+
+  Giving the values to another splitter's setSizes() function will
+  produce a splitter with the same layout as this one.
+
+  Note that if you want to iterate over the list, you should
+  iterate over a copy, e.g.
+    \code
+    QValueList<int> list = mySplitter.sizes();
+    QValueList<int>::Iterator it = list.begin();
+    while( it != list.end() ) {
+	myProcessing( *it );
+	++it;
+    }
+    \endcode
+
+  \sa setSizes()
+*/
+
+QValueList<int> KDGanttMinimizeSplitter::sizes() const
+{
+    if ( !testWState(WState_Polished) ) {
+	QWidget* that = (QWidget*) this;
+	that->polish();
+    }
+    QValueList<int> list;
+    QSplitterLayoutStruct *s = data->list.first();
+    while ( s ) {
+	if ( !s->isSplitter )
+	    list.append( s->sizer );
+	s = data->list.next();
+    }
+    return list;
+}
+
+
+
+/*!
+  Sets the size parameters to the values given in \a list.
+  If the splitter is horizontal, the values set the sizes from
+  left to right. If it is vertical, the sizes are applied from
+  top to bottom.
+  Extra values in \a list are ignored.
+
+  If \a list contains too few values, the result is undefined
+  but the program will still be well-behaved.
+
+  \sa sizes()
+*/
+
+void KDGanttMinimizeSplitter::setSizes( QValueList<int> list )
+{
+    processChildEvents();
+    QValueList<int>::Iterator it = list.begin();
+    QSplitterLayoutStruct *s = data->list.first();
+    while ( s && it != list.end() ) {
+	if ( !s->isSplitter ) {
+	    s->sizer = *it;
+	    ++it;
+	}
+	s = data->list.next();
+    }
+    doResize();
+}
+
+
+/*!
+  Gets all posted child events, ensuring that the internal state of
+  the splitter is consistent.
+*/
+
+void KDGanttMinimizeSplitter::processChildEvents()
+{
+    QApplication::sendPostedEvents( this, QEvent::ChildInserted );
+}
+
+
+/*!
+  \reimp
+*/
+
+void KDGanttMinimizeSplitter::styleChange( QStyle& old )
+{
+
+#if QT_VERSION >= 300
+    int sw = style().pixelMetric(QStyle::PM_SplitterWidth, this);
+#else
+    int sw = style().splitterWidth();
+#endif
+    QSplitterLayoutStruct *s = data->list.first();
+    while ( s ) {
+	if ( s->isSplitter )
+	    s->sizer = sw;
+	s = data->list.next();
+    }
+    doResize();
+    QFrame::styleChange( old );
+}
+
+#endif
+
+/*!
+  Specifies the direction of the minimize buttons.
+  If the orientation of the splitter is horizontal then with
+  KDGanttMinimizeSplitter::Left or KDGanttMinimizeSplitter::Right should be used,
+  otherwise either KDGanttMinimizeSplitter::Up or KDGanttMinimizeSplitter::Down
+  should be used.
+*/
+void KDGanttMinimizeSplitter::setMinimizeDirection( Direction direction )
+{
+    _direction = direction;
+}
+
+/*!
+  Returns the direction of the minimize buttons.
+*/
+KDGanttMinimizeSplitter::Direction KDGanttMinimizeSplitter::minimizeDirection() const
+{
+    return _direction;
+}
+
+/*
+  This is a copy of qGeomCalc() in qlayoutengine.cpp which
+  unfortunately isn't exported.
+*/
+static inline int toFixed( int i ) { return i * 256; }
+static inline int fRound( int i ) {
+    return ( i % 256 < 128 ) ? i / 256 : 1 + i / 256;
+}
+void kdganttGeomCalc( QMemArray<QLayoutStruct> &chain, int start, int count, int pos,
+		int space, int spacer )
+{
+    typedef int fixed;
+    int cHint = 0;
+    int cMin = 0;
+    int cMax = 0;
+    int sumStretch = 0;
+    int spacerCount = 0;
+
+    bool wannaGrow = FALSE; // anyone who really wants to grow?
+    //    bool canShrink = FALSE; // anyone who could be persuaded to shrink?
+
+    int i;
+    for ( i = start; i < start + count; i++ ) {
+	chain[i].done = FALSE;
+	cHint += chain[i].sizeHint;
+	cMin += chain[i].minimumSize;
+	cMax += chain[i].maximumSize;
+	sumStretch += chain[i].stretch;
+	if ( !chain[i].empty )
+	    spacerCount++;
+	wannaGrow = wannaGrow || chain[i].expansive;
+    }
+
+    int extraspace = 0;
+    if ( spacerCount )
+	spacerCount--; // only spacers between things
+    if ( space < cMin + spacerCount * spacer ) {
+	//	qDebug("not enough space");
+	for ( i = start; i < start+count; i++ ) {
+	    chain[i].size = chain[i].minimumSize;
+	    chain[i].done = TRUE;
+	}
+    } else if ( space < cHint + spacerCount*spacer ) {
+	// Less space than sizeHint, but more than minimum.
+	// Currently take space equally from each, like in Qt 2.x.
+	// Commented-out lines will give more space to stretchier items.
+	int n = count;
+	int space_left = space - spacerCount*spacer;
+	int overdraft = cHint - space_left;
+	//first give to the fixed ones:
+	for ( i = start; i < start+count; i++ ) {
+	    if ( !chain[i].done && chain[i].minimumSize >= chain[i].sizeHint) {
+		chain[i].size = chain[i].sizeHint;
+		chain[i].done = TRUE;
+		space_left -= chain[i].sizeHint;
+		// sumStretch -= chain[i].stretch;
+		n--;
+	    }
+	}
+	bool finished = n == 0;
+	while ( !finished ) {
+	    finished = TRUE;
+	    fixed fp_over = toFixed( overdraft );
+	    fixed fp_w = 0;
+
+	    for ( i = start; i < start+count; i++ ) {
+		if ( chain[i].done )
+		    continue;
+		// if ( sumStretch <= 0 )
+		fp_w += fp_over / n;
+		// else
+		//    fp_w += (fp_over * chain[i].stretch) / sumStretch;
+		int w = fRound( fp_w );
+		chain[i].size = chain[i].sizeHint - w;
+		fp_w -= toFixed( w ); //give the difference to the next
+		if ( chain[i].size < chain[i].minimumSize ) {
+		    chain[i].done = TRUE;
+		    chain[i].size = chain[i].minimumSize;
+		    finished = FALSE;
+		    overdraft -= chain[i].sizeHint - chain[i].minimumSize;
+		    // sumStretch -= chain[i].stretch;
+		    n--;
+		    break;
+		}
+	    }
+	}
+    } else { //extra space
+	int n = count;
+	int space_left = space - spacerCount*spacer;
+	// first give to the fixed ones, and handle non-expansiveness
+	for ( i = start; i < start + count; i++ ) {
+	    if ( !chain[i].done && (chain[i].maximumSize <= chain[i].sizeHint
+				    || wannaGrow && !chain[i].expansive) ) {
+		chain[i].size = chain[i].sizeHint;
+		chain[i].done = TRUE;
+		space_left -= chain[i].sizeHint;
+		sumStretch -= chain[i].stretch;
+		n--;
+	    }
+	}
+	extraspace = space_left;
+	/*
+	  Do a trial distribution and calculate how much it is off.
+	  If there are more deficit pixels than surplus pixels, give
+	  the minimum size items what they need, and repeat.
+	  Otherwise give to the maximum size items, and repeat.
+
+	  I have a wonderful mathematical proof for the correctness
+	  of this principle, but unfortunately this comment is too
+	  small to contain it.
+	*/
+	int surplus, deficit;
+	do {
+	    surplus = deficit = 0;
+	    fixed fp_space = toFixed( space_left );
+	    fixed fp_w = 0;
+	    for ( i = start; i < start+count; i++ ) {
+		if ( chain[i].done )
+		    continue;
+		extraspace = 0;
+		if ( sumStretch <= 0 )
+		    fp_w += fp_space / n;
+		else
+		    fp_w += (fp_space * chain[i].stretch) / sumStretch;
+		int w = fRound( fp_w );
+		chain[i].size = w;
+		fp_w -= toFixed( w ); // give the difference to the next
+		if ( w < chain[i].sizeHint ) {
+		    deficit +=  chain[i].sizeHint - w;
+		} else if ( w > chain[i].maximumSize ) {
+		    surplus += w - chain[i].maximumSize;
+		}
+	    }
+	    if ( deficit > 0 && surplus <= deficit ) {
+		// give to the ones that have too little
+		for ( i = start; i < start+count; i++ ) {
+		    if ( !chain[i].done &&
+			 chain[i].size < chain[i].sizeHint ) {
+			chain[i].size = chain[i].sizeHint;
+			chain[i].done = TRUE;
+			space_left -= chain[i].sizeHint;
+			sumStretch -= chain[i].stretch;
+			n--;
+		    }
+		}
+	    }
+	    if ( surplus > 0 && surplus >= deficit ) {
+		// take from the ones that have too much
+		for ( i = start; i < start+count; i++ ) {
+		    if ( !chain[i].done &&
+			 chain[i].size > chain[i].maximumSize ) {
+			chain[i].size = chain[i].maximumSize;
+			chain[i].done = TRUE;
+			space_left -= chain[i].maximumSize;
+			sumStretch -= chain[i].stretch;
+			n--;
+		    }
+		}
+	    }
+	} while ( n > 0 && surplus != deficit );
+	if ( n == 0 )
+	    extraspace = space_left;
+    }
+
+    // as a last resort, we distribute the unwanted space equally
+    // among the spacers (counting the start and end of the chain).
+
+    //### should do a sub-pixel allocation of extra space
+    int extra = extraspace / ( spacerCount + 2 );
+    int p = pos + extra;
+    for ( i = start; i < start+count; i++ ) {
+	chain[i].pos = p;
+	p = p + chain[i].size;
+	if ( !chain[i].empty )
+	    p += spacer+extra;
+    }
+}
+
+#endif
+
+/*!
+  \enum KDGanttMinimizeSplitter::Direction
+
+  The values of this enumeration describe into which direction the
+  splitter will collapse its child widgets. By extension, it also
+  specifies the orientation of the splitter; collapsing to the left or
+  to the right results in a horizontal splitter, collapsing to the top
+  or bottom in a vertical splitter.
+*/
+
+/*!
+  \fn Orientation KDGanttMinimizeSplitter::orientation() const
+
+  Returns the orientation of the splitter.
+*/
+
+/*! \enum KDGanttMinimizeSplitter::ResizeMode
+
+  This enum type describes how KDGanttMinimizeSplitter will resize each of its child widgets.  The currently defined values are:
+
+  Stretch: the widget will be resized when the splitter
+  itself is resized.
+
+  KeepSize: KDGanttMinimizeSplitter will try to keep this widget's size
+  unchanged.
+
+  FollowSizeHint: KDGanttMinimizeSplitter will resize the widget when the
+  widget's size hint changes.
+*/
+