summaryrefslogtreecommitdiffabout
path: root/microkde/KDGanttMinimizeSplitter.cpp
Unidiff
Diffstat (limited to 'microkde/KDGanttMinimizeSplitter.cpp') (more/less context) (ignore whitespace changes)
-rw-r--r--microkde/KDGanttMinimizeSplitter.cpp1636
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 @@
1/* -*- Mode: C++ -*-
2 $Id$
3*/
4
5/****************************************************************************
6 ** Copyright (C) 2002-2004 Klarälvdalens Datakonsult AB. All rights reserved.
7 **
8 ** This file is part of the KDGantt library.
9 **
10 ** This file may be distributed and/or modified under the terms of the
11 ** GNU General Public License version 2 as published by the Free Software
12 ** Foundation and appearing in the file LICENSE.GPL included in the
13 ** packaging of this file.
14 **
15 ** Licensees holding valid commercial KDGantt licenses may use this file in
16 ** accordance with the KDGantt Commercial License Agreement provided with
17 ** the Software.
18 **
19 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
20 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
21 **
22 ** See http://www.klaralvdalens-datakonsult.se/Public/products/ for
23 ** information about KDGantt Commercial License Agreements.
24 **
25 ** Contact info@klaralvdalens-datakonsult.se if any conditions of this
26 ** licensing are not clear to you.
27 **
28 ** As a special exception, permission is given to link this program
29 ** with any edition of Qt, and distribute the resulting executable,
30 ** without including the source code for Qt in the source distribution.
31 **
32 **********************************************************************/
33
34#include "KDGanttMinimizeSplitter.h"
35#ifndef QT_NO_SPLITTER___
36
37#include "qpainter.h"
38#include "qdrawutil.h"
39#include "qbitmap.h"
40#if QT_VERSION >= 300
41#include "qptrlist.h"
42#include "qmemarray.h"
43#else
44#include <qlist.h>
45#include <qarray.h>
46#define QPtrList QList
47#define QMemArray QArray
48#endif
49#include "qlayoutengine_p.h"
50#include "qobjectlist.h"
51#include "qstyle.h"
52#include "qapplication.h" //sendPostedEvents
53#include <qvaluelist.h>
54#include <qcursor.h>
55#ifndef KDGANTT_MASTER_CVS
56//#include "KDGanttMinimizeSplitter.moc"
57#endif
58
59
60
61#ifndef DOXYGEN_SKIP_INTERNAL
62
63#if QT_VERSION >= 232
64static int mouseOffset;
65static int opaqueOldPos = -1; //### there's only one mouse, but this is a bit risky
66
67
68KDGanttSplitterHandle::KDGanttSplitterHandle( Qt::Orientation o,
69 KDGanttMinimizeSplitter *parent, const char * name )
70 : QWidget( parent, name ), _activeButton( 0 ), _collapsed( false )
71{
72
73 if ( QApplication::desktop()->width() > 320 && QApplication::desktop()->width() < 650 ) {
74 mSizeHint = QSize(7,7);
75 mUseOffset = true;
76 } else {
77 mSizeHint = QSize(6,6);
78 mUseOffset = false;
79 }
80 s = parent;
81 setOrientation(o);
82 setMouseTracking( true );
83 //setMaximumHeight( 5 ); // test only
84}
85
86QSize KDGanttSplitterHandle::sizeHint() const
87{
88 return mSizeHint;
89}
90
91void KDGanttSplitterHandle::setOrientation( Qt::Orientation o )
92{
93 orient = o;
94#ifndef QT_NO_CURSOR
95 if ( o == KDGanttMinimizeSplitter::Horizontal )
96 setCursor( splitHCursor );
97 else
98 setCursor( splitVCursor );
99#endif
100}
101
102
103void KDGanttSplitterHandle::mouseMoveEvent( QMouseEvent *e )
104{
105 updateCursor( e->pos() );
106 if ( !(e->state()&LeftButton) )
107 return;
108
109 if ( _activeButton != 0)
110 return;
111
112 QCOORD pos = s->pick(parentWidget()->mapFromGlobal(e->globalPos()))
113 - mouseOffset;
114 if ( true /*opaque()*/ ) {
115 s->moveSplitter( pos, id() );
116 } else {
117 int min = pos; int max = pos;
118 s->getRange( id(), &min, &max );
119 s->setRubberband( QMAX( min, QMIN(max, pos )));
120 }
121 _collapsed = false;
122}
123
124void KDGanttSplitterHandle::mousePressEvent( QMouseEvent *e )
125{
126 if ( e->button() == LeftButton ) {
127 _activeButton = onButton( e->pos() );
128 mouseOffset = s->pick(e->pos());
129 if ( _activeButton != 0)
130 repaint();
131 updateCursor( e->pos() );
132 }
133}
134
135void KDGanttSplitterHandle::updateCursor( const QPoint& p)
136{
137 if ( onButton( p ) != 0 ) {
138 setCursor( arrowCursor );
139 }
140 else {
141 if ( orient == KDGanttMinimizeSplitter::Horizontal )
142 setCursor( splitHCursor );
143 else
144 setCursor( splitVCursor );
145 }
146}
147void KDGanttSplitterHandle::toggle()
148{
149 int pos;
150 int min, max;
151 if ( !_collapsed ) {
152 s->expandPos( id(), &min, &max );
153 if ( s->minimizeDirection() == KDGanttMinimizeSplitter::Left
154 || s->minimizeDirection() == KDGanttMinimizeSplitter::Up ) {
155 pos = min;
156 }
157 else {
158 pos = max;
159 }
160
161 _origPos = s->pick(mapToParent( QPoint( 0,0 ) ));
162 s->moveSplitter( pos, id() );
163 _collapsed = true;
164 }
165 else {
166 s->moveSplitter( _origPos, id() );
167 _collapsed = false;
168 }
169}
170
171void KDGanttSplitterHandle::mouseReleaseEvent( QMouseEvent *e )
172{
173 if ( _activeButton != 0 ) {
174 if ( onButton( e->pos() ) == _activeButton )
175 {
176 toggle();
177 }
178 _activeButton = 0;
179 updateCursor( e->pos() );
180 }
181 else {
182 if ( !opaque() && e->button() == LeftButton ) {
183 QCOORD pos = s->pick(parentWidget()->mapFromGlobal(e->globalPos()))
184 - mouseOffset;
185 s->setRubberband( -1 );
186 s->moveSplitter( pos, id() );
187 }
188 }
189 repaint();
190}
191
192int KDGanttSplitterHandle::onButton( const QPoint& p )
193{
194 QValueList<QPointArray> list = buttonRegions();
195 int index = 1;
196 int add = 12;
197 for( QValueList<QPointArray>::Iterator it = list.begin(); it != list.end(); ++it ) {
198 QRect rect = (*it).boundingRect();
199 rect.setLeft( rect.left()- add );
200 rect.setRight( rect.right() + add);
201 rect.setTop( rect.top()- add );
202 rect.setBottom( rect.bottom() + add);
203 if ( rect.contains( p ) ) {
204 return index;
205 }
206 index++;
207 }
208 return 0;
209}
210
211
212QValueList<QPointArray> KDGanttSplitterHandle::buttonRegions()
213{
214 QValueList<QPointArray> list;
215
216 int sw = 8;
217 int yyy = 1;
218 int xxx = 1;
219 int voffset[] = { (int) -sw*3, (int) sw*3 };
220 for ( int i = 0; i < 2; i++ ) {
221 QPointArray arr;
222 if ( !_collapsed && s->minimizeDirection() == KDGanttMinimizeSplitter::Right ||
223 _collapsed && s->minimizeDirection() == KDGanttMinimizeSplitter::Left) {
224 int mid = height()/2 + voffset[i];
225 arr.setPoints( 3,
226 1-xxx, mid - sw + 4,
227 sw-3-xxx, mid,
228 1-xxx, mid + sw -4);
229 }
230 else if ( !_collapsed && s->minimizeDirection() == KDGanttMinimizeSplitter::Left ||
231 _collapsed && s->minimizeDirection() == KDGanttMinimizeSplitter::Right ) {
232 int mid = height()/2 + voffset[i];
233 arr.setPoints( 3,
234 sw-4, mid - sw + 4,
235 0, mid,
236 sw-4, mid + sw - 4);
237 }
238 else if ( !_collapsed && s->minimizeDirection() == KDGanttMinimizeSplitter::Up ||
239 _collapsed && s->minimizeDirection() == KDGanttMinimizeSplitter::Down) {
240 int mid = width()/2 + voffset[i];
241 arr.setPoints( 3,
242 mid - sw + 4, sw-4,
243 mid, 0,
244 mid + sw - 4, sw-4 );
245 }
246 else if ( !_collapsed && s->minimizeDirection() == KDGanttMinimizeSplitter::Down ||
247 _collapsed && s->minimizeDirection() == KDGanttMinimizeSplitter::Up ) {
248 int mid = width()/2 + voffset[i];
249 arr.setPoints( 3,
250 mid - sw + 4, 1-yyy,
251 mid, sw-3-yyy,
252 mid + sw -4, 1-yyy);
253 }
254 list.append( arr );
255 }
256 return list;
257}
258
259void KDGanttSplitterHandle::paintEvent( QPaintEvent * )
260{
261 QPixmap buffer( size() );
262 QPainter p( &buffer );
263
264 //LR
265 // Draw the splitter rectangle
266 p.setBrush( colorGroup().background() );
267 p.setPen( colorGroup().foreground() );
268 //p.drawRect( rect() );
269 buffer.fill( colorGroup().background() );
270 //buffer.fill( backgroundColor() );
271 // parentWidget()->style().drawPrimitive( QStyle::PE_Panel, &p, rect(), parentWidget()->colorGroup());
272
273 int sw = 8; // Hardcoded, given I didn't use styles anymore, I didn't like to use their size
274
275 // arrow color
276 QColor col;
277 if ( _activeButton )
278 col = colorGroup().background().dark( 250 );
279 else
280 col = colorGroup().background().dark( 150 );
281 //QColor col = backgroundColor().dark( 130 );
282 p.setBrush( col );
283 p.setPen( col );
284
285 QValueList<QPointArray> list = buttonRegions();
286 int index = 1;
287 if ( mUseOffset )
288 p.translate( 0, 1 );
289 for ( QValueList<QPointArray>::Iterator it = list.begin(); it != list.end(); ++it ) {
290 if ( index == _activeButton ) {
291
292 /*
293 if ( ! _collapsed ) {
294 p.save();
295 // p.translate( parentWidget()->style().pixelMetric( QStyle::PM_ButtonShiftHorizontal ),
296 // parentWidget()->style().pixelMetric( QStyle::PM_ButtonShiftVertical ) );
297 p.translate( -1, 0 );
298 p.drawPolygon( *it, true );
299 p.restore(); } else
300 */
301 p.drawPolygon( *it, true );
302
303 }
304 else {
305 /*
306 if ( ! _collapsed ) {
307 p.save();
308 p.translate( -1, 0 );
309 p.drawPolygon( *it, true );
310 p.restore();
311 } else
312 */
313 p.drawPolygon( *it, true );
314
315 }
316 index++;
317 }
318
319 // Draw the lines between the arrows
320 if ( s->minimizeDirection() == KDGanttMinimizeSplitter::Left ||
321 s->minimizeDirection() == KDGanttMinimizeSplitter::Right ) {
322 int mid = height()/2;
323 p.drawLine ( 1, mid - sw, 1, mid + sw );
324 p.drawLine ( 3, mid - sw, 3, mid + sw );
325 }
326 else if ( s->minimizeDirection() == KDGanttMinimizeSplitter::Up ||
327 s->minimizeDirection() == KDGanttMinimizeSplitter::Down ) {
328 int mid = width()/2;
329 p.drawLine( mid -sw, 1, mid +sw, 1 );
330 p.drawLine( mid -sw, 3, mid +sw, 3 );
331 }
332 bitBlt( this, 0, 0, &buffer );
333
334}
335#endif
336
337class QSplitterLayoutStruct
338{
339public:
340 KDGanttMinimizeSplitter::ResizeMode mode;
341 QCOORD sizer;
342 bool isSplitter;
343 QWidget *wid;
344};
345
346class QSplitterData
347{
348public:
349 QSplitterData() : opaque( FALSE ), firstShow( TRUE ) {}
350
351 QPtrList<QSplitterLayoutStruct> list;
352 bool opaque;
353 bool firstShow;
354};
355
356void kdganttGeomCalc( QMemArray<QLayoutStruct> &chain, int start, int count, int pos,
357 int space, int spacer );
358#endif // DOXYGEN_SKIP_INTERNAL
359
360
361/*!
362 \class KDGanttMinimizeSplitter KDGanttMinimizeSplitter.h
363 \brief The KDGanttMinimizeSplitter class implements a splitter
364 widget with minimize buttons.
365
366 This class (and its documentation) is largely a copy of Qt's
367 QSplitter; the copying was necessary because QSplitter is not
368 extensible at all. QSplitter and its documentation are licensed
369 according to the GPL and the Qt Professional License (if you hold
370 such a license) and are (C) Trolltech AS.
371
372 A splitter lets the user control the size of child widgets by
373 dragging the boundary between the children. Any number of widgets
374 may be controlled.
375
376 To show a QListBox, a QListView and a QTextEdit side by side:
377
378 \code
379 KDGanttMinimizeSplitter *split = new KDGanttMinimizeSplitter( parent );
380 QListBox *lb = new QListBox( split );
381 QListView *lv = new QListView( split );
382 QTextEdit *ed = new QTextEdit( split );
383 \endcode
384
385 In KDGanttMinimizeSplitter, the boundary can be either horizontal or
386 vertical. The default is horizontal (the children are side by side)
387 but you can use setOrientation( QSplitter::Vertical ) to set it to
388 vertical.
389
390 Use setResizeMode() to specify
391 that a widget should keep its size when the splitter is resized.
392
393 Although KDGanttMinimizeSplitter normally resizes the children only
394 at the end of a resize operation, if you call setOpaqueResize( TRUE
395 ) the widgets are resized as often as possible.
396
397 The initial distribution of size between the widgets is determined
398 by the initial size of each widget. You can also use setSizes() to
399 set the sizes of all the widgets. The function sizes() returns the
400 sizes set by the user.
401
402 If you hide() a child, its space will be distributed among the other
403 children. It will be reinstated when you show() it again. It is also
404 possible to reorder the widgets within the splitter using
405 moveToFirst() and moveToLast().
406*/
407
408
409
410static QSize minSize( const QWidget* /*w*/ )
411{
412 return QSize(0,0);
413}
414
415// This is the original version of minSize
416static QSize minSizeHint( const QWidget* w )
417{
418 QSize min = w->minimumSize();
419 QSize s;
420 if ( min.height() <= 0 || min.width() <= 0 )
421 s = w->minimumSizeHint();
422 if ( min.height() > 0 )
423 s.setHeight( min.height() );
424 if ( min.width() > 0 )
425 s.setWidth( min.width() );
426 return s.expandedTo(QSize(0,0));
427}
428
429
430
431/*!
432 Constructs a horizontal splitter with the \a parent and \a
433 name arguments being passed on to the QFrame constructor.
434*/
435KDGanttMinimizeSplitter::KDGanttMinimizeSplitter( QWidget *parent, const char *name )
436 :QFrame(parent,name,WPaintUnclipped)
437{
438 mFirstHandle = 0;
439#if QT_VERSION >= 232
440 orient = Horizontal;
441 init();
442#endif
443}
444
445/*!
446 Constructs a splitter with orientation \a o with the \a parent
447 and \a name arguments being passed on to the QFrame constructor.
448*/
449KDGanttMinimizeSplitter::KDGanttMinimizeSplitter( Orientation o, QWidget *parent, const char *name )
450 :QFrame(parent,name,WPaintUnclipped)
451{
452 mFirstHandle = 0;
453#if QT_VERSION >= 232
454 orient = o;
455 init();
456#endif
457}
458
459/*!
460 Destroys the splitter and any children.
461*/
462KDGanttMinimizeSplitter::~KDGanttMinimizeSplitter()
463{
464#if QT_VERSION >= 232
465 data->list.setAutoDelete( TRUE );
466 delete data;
467#endif
468}
469
470
471#if QT_VERSION >= 232
472void KDGanttMinimizeSplitter::init()
473{
474 data = new QSplitterData;
475 if ( orient == Horizontal )
476 setSizePolicy( QSizePolicy(QSizePolicy::Expanding,QSizePolicy::Minimum) );
477 else
478 setSizePolicy( QSizePolicy(QSizePolicy::Minimum,QSizePolicy::Expanding) );
479}
480#endif
481
482
483
484/*!
485 \brief the orientation of the splitter
486
487 By default the orientation is horizontal (the widgets are side by side).
488 The possible orientations are Qt:Vertical and Qt::Horizontal (the default).
489*/
490void KDGanttMinimizeSplitter::setOrientation( Orientation o )
491{
492#if QT_VERSION >= 232
493 if ( orient == o )
494 return;
495 orient = o;
496
497 if ( orient == Horizontal )
498 setSizePolicy( QSizePolicy( QSizePolicy::Expanding, QSizePolicy::Minimum ) );
499 else
500 setSizePolicy( QSizePolicy( QSizePolicy::Minimum, QSizePolicy::Expanding ) );
501
502 QSplitterLayoutStruct *s = data->list.first();
503 while ( s ) {
504 if ( s->isSplitter )
505 ((KDGanttSplitterHandle*)s->wid)->setOrientation( o );
506 s = data->list.next(); // ### next at end of loop, no iterator
507 }
508 recalc( isVisible() );
509#endif
510}
511
512
513#if QT_VERSION >= 232
514/*!
515 \reimp
516*/
517void KDGanttMinimizeSplitter::resizeEvent( QResizeEvent * )
518{
519 doResize();
520}
521
522
523/*
524 Inserts the widget \a w at the end (or at the beginning if \a first
525 is TRUE) of the splitter's list of widgets.
526
527 It is the responsibility of the caller of this function to make sure
528 that \a w is not already in the splitter and to call recalcId if
529 needed. (If \a first is TRUE, then recalcId is very probably
530 needed.)
531*/
532QSplitterLayoutStruct *KDGanttMinimizeSplitter::addWidget( QWidget *w, bool first )
533{
534 QSplitterLayoutStruct *s;
535 KDGanttSplitterHandle *newHandle = 0;
536 if ( data->list.count() > 0 ) {
537 s = new QSplitterLayoutStruct;
538 s->mode = KeepSize;
539 QString tmp = "qt_splithandle_";
540 tmp += w->name();
541 newHandle = new KDGanttSplitterHandle( orientation(), this, tmp.latin1() );
542 if ( ! mFirstHandle )
543 mFirstHandle = newHandle;
544 s->wid = newHandle;
545 newHandle->setId(data->list.count());
546 s->isSplitter = TRUE;
547 s->sizer = pick( newHandle->sizeHint() );
548 if ( first )
549 data->list.insert( 0, s );
550 else
551 data->list.append( s );
552 }
553 s = new QSplitterLayoutStruct;
554 s->mode = Stretch;
555 s->wid = w;
556 if ( !testWState( WState_Resized ) && w->sizeHint().isValid() )
557 s->sizer = pick( w->sizeHint() );
558 else
559 s->sizer = pick( w->size() );
560 s->isSplitter = FALSE;
561 if ( first )
562 data->list.insert( 0, s );
563 else
564 data->list.append( s );
565 if ( newHandle && isVisible() )
566 newHandle->show(); //will trigger sending of post events
567 return s;
568}
569
570
571/*!
572 Tells the splitter that a child widget has been inserted or removed.
573 The event is passed in \a c.
574*/
575void KDGanttMinimizeSplitter::childEvent( QChildEvent *c )
576{
577 if ( c->type() == QEvent::ChildInserted ) {
578 if ( !c->child()->isWidgetType() )
579 return;
580
581 if ( ((QWidget*)c->child())->testWFlags( WType_TopLevel ) )
582 return;
583
584 QSplitterLayoutStruct *s = data->list.first();
585 while ( s ) {
586 if ( s->wid == c->child() )
587 return;
588 s = data->list.next();
589 }
590 addWidget( (QWidget*)c->child() );
591 recalc( isVisible() );
592
593 } else if ( c->type() == QEvent::ChildRemoved ) {
594 QSplitterLayoutStruct *p = 0;
595 if ( data->list.count() > 1 )
596 p = data->list.at(1); //remove handle _after_ first widget.
597 QSplitterLayoutStruct *s = data->list.first();
598 while ( s ) {
599 if ( s->wid == c->child() ) {
600 data->list.removeRef( s );
601 delete s;
602 if ( p && p->isSplitter ) {
603 data->list.removeRef( p );
604 delete p->wid; //will call childEvent
605 delete p;
606 }
607 recalcId();
608 doResize();
609 return;
610 }
611 p = s;
612 s = data->list.next();
613 }
614 }
615}
616
617
618/*!
619 Shows a rubber band at position \a p. If \a p is negative, the
620 rubber band is removed.
621*/
622void KDGanttMinimizeSplitter::setRubberband( int p )
623{
624 QPainter paint( this );
625 paint.setPen( gray );
626 paint.setBrush( gray );
627 paint.setRasterOp( XorROP );
628 QRect r = contentsRect();
629 const int rBord = 3; //Themable????
630#if QT_VERSION >= 300
631 int sw = style().pixelMetric(QStyle::PM_SplitterWidth, this);
632#else
633 int sw = style().splitterWidth();
634#endif
635 if ( orient == Horizontal ) {
636 if ( opaqueOldPos >= 0 )
637 paint.drawRect( opaqueOldPos + sw/2 - rBord , r.y(),
638 2*rBord, r.height() );
639 if ( p >= 0 )
640 paint.drawRect( p + sw/2 - rBord, r.y(), 2*rBord, r.height() );
641 } else {
642 if ( opaqueOldPos >= 0 )
643 paint.drawRect( r.x(), opaqueOldPos + sw/2 - rBord,
644 r.width(), 2*rBord );
645 if ( p >= 0 )
646 paint.drawRect( r.x(), p + sw/2 - rBord, r.width(), 2*rBord );
647 }
648 opaqueOldPos = p;
649}
650
651
652/*! \reimp */
653bool KDGanttMinimizeSplitter::event( QEvent *e )
654{
655 if ( e->type() == QEvent::LayoutHint || ( e->type() == QEvent::Show && data->firstShow ) ) {
656 recalc( isVisible() );
657 if ( e->type() == QEvent::Show )
658 data->firstShow = FALSE;
659 }
660 return QWidget::event( e );
661}
662
663
664/*!
665 \obsolete
666
667 Draws the splitter handle in the rectangle described by \a x, \a y,
668 \a w, \a h using painter \a p.
669 \sa QStyle::drawPrimitive()
670*/
671void KDGanttMinimizeSplitter::drawSplitter( QPainter *p,
672 QCOORD x, QCOORD y, QCOORD w, QCOORD h )
673{
674#if 0
675 // LR
676 style().drawPrimitive(QStyle::PE_Splitter, p, QRect(x, y, w, h), colorGroup(),
677 (orientation() == Qt::Horizontal ?
678 QStyle::Style_Horizontal : 0));
679#endif
680}
681
682
683/*!
684 Returns the id of the splitter to the right of or below the widget \a w,
685 or 0 if there is no such splitter
686 (i.e. it is either not in this KDGanttMinimizeSplitter or it is at the end).
687*/
688int KDGanttMinimizeSplitter::idAfter( QWidget* w ) const
689{
690 QSplitterLayoutStruct *s = data->list.first();
691 bool seen_w = FALSE;
692 while ( s ) {
693 if ( s->isSplitter && seen_w )
694 return data->list.at();
695 if ( !s->isSplitter && s->wid == w )
696 seen_w = TRUE;
697 s = data->list.next();
698 }
699 return 0;
700}
701
702
703/*!
704 Moves the left/top edge of the splitter handle with id \a id as
705 close as possible to position \a p, which is the distance from the
706 left (or top) edge of the widget.
707
708 For Arabic and Hebrew the layout is reversed, and using this
709 function to set the position of the splitter might lead to
710 unexpected results, since in Arabic and Hebrew the position of
711 splitter one is to the left of the position of splitter zero.
712
713 \sa idAfter()
714*/
715void KDGanttMinimizeSplitter::moveSplitter( QCOORD p, int id )
716{
717 p = adjustPos( p, id );
718 QSplitterLayoutStruct *s = data->list.at(id);
719 int oldP = orient == Horizontal ? s->wid->x() : s->wid->y();
720 bool upLeft;
721 if ( false && orient == Horizontal ) {
722 p += s->wid->width();
723 upLeft = p > oldP;
724 } else
725 upLeft = p < oldP;
726
727 moveAfter( p, id, upLeft );
728 moveBefore( p-1, id-1, upLeft );
729
730 storeSizes();
731}
732
733
734void KDGanttMinimizeSplitter::setG( QWidget *w, int p, int s, bool isSplitter )
735{
736 if ( orient == Horizontal ) {
737 if ( false && orient == Horizontal && !isSplitter )
738 p = contentsRect().width() - p - s;
739 w->setGeometry( p, contentsRect().y(), s, contentsRect().height() );
740 } else
741 w->setGeometry( contentsRect().x(), p, contentsRect().width(), s );
742}
743
744
745/*
746 Places the right/bottom edge of the widget at \a id at position \a pos.
747
748 \sa idAfter()
749*/
750void KDGanttMinimizeSplitter::moveBefore( int pos, int id, bool upLeft )
751{
752 if( id < 0 )
753 return;
754 QSplitterLayoutStruct *s = data->list.at(id);
755 if ( !s )
756 return;
757 QWidget *w = s->wid;
758 if ( w->isHidden() ) {
759 moveBefore( pos, id-1, upLeft );
760 } else if ( s->isSplitter ) {
761 int pos1, pos2;
762 int dd = s->sizer;
763 if( false && orient == Horizontal ) {
764 pos1 = pos;
765 pos2 = pos + dd;
766 } else {
767 pos2 = pos - dd;
768 pos1 = pos2 + 1;
769 }
770 if ( upLeft ) {
771 setG( w, pos1, dd, TRUE );
772 moveBefore( pos2, id-1, upLeft );
773 } else {
774 moveBefore( pos2, id-1, upLeft );
775 setG( w, pos1, dd, TRUE );
776 }
777 } else {
778 int dd, newLeft, nextPos;
779 if( false && orient == Horizontal ) {
780 dd = w->geometry().right() - pos;
781 dd = QMAX( pick(minSize(w)), QMIN(dd, pick(w->maximumSize())));
782 newLeft = pos+1;
783 nextPos = newLeft + dd;
784 } else {
785 dd = pos - pick( w->pos() ) + 1;
786 dd = QMAX( pick(minSize(w)), QMIN(dd, pick(w->maximumSize())));
787 newLeft = pos-dd+1;
788 nextPos = newLeft - 1;
789 }
790 setG( w, newLeft, dd, TRUE );
791 moveBefore( nextPos, id-1, upLeft );
792 }
793}
794
795
796/*
797 Places the left/top edge of the widget at \a id at position \a pos.
798
799 \sa idAfter()
800*/
801void KDGanttMinimizeSplitter::moveAfter( int pos, int id, bool upLeft )
802{
803 QSplitterLayoutStruct *s = id < int(data->list.count()) ?
804 data->list.at(id) : 0;
805 if ( !s )
806 return;
807 QWidget *w = s->wid;
808 if ( w->isHidden() ) {
809 moveAfter( pos, id+1, upLeft );
810 } else if ( pick( w->pos() ) == pos ) {
811 //No need to do anything if it's already there.
812 return;
813 } else if ( s->isSplitter ) {
814 int dd = s->sizer;
815 int pos1, pos2;
816 if( false && orient == Horizontal ) {
817 pos2 = pos - dd;
818 pos1 = pos2 + 1;
819 } else {
820 pos1 = pos;
821 pos2 = pos + dd;
822 }
823 if ( upLeft ) {
824 setG( w, pos1, dd, TRUE );
825 moveAfter( pos2, id+1, upLeft );
826 } else {
827 moveAfter( pos2, id+1, upLeft );
828 setG( w, pos1, dd, TRUE );
829 }
830 } else {
831 int left = pick( w->pos() );
832 int right, dd,/* newRight,*/ newLeft, nextPos;
833 if ( false && orient == Horizontal ) {
834 dd = pos - left + 1;
835 dd = QMAX( pick(minSize(w)), QMIN(dd, pick(w->maximumSize())));
836 newLeft = pos-dd+1;
837 nextPos = newLeft - 1;
838 } else {
839 right = pick( w->geometry().bottomRight() );
840 dd = right - pos + 1;
841 dd = QMAX( pick(minSize(w)), QMIN(dd, pick(w->maximumSize())));
842 /*newRight = pos+dd-1;*/
843 newLeft = pos;
844 nextPos = newLeft + dd;
845 }
846 setG( w, newLeft, dd, TRUE );
847 /*if( right != newRight )*/
848 moveAfter( nextPos, id+1, upLeft );
849 }
850}
851
852
853void KDGanttMinimizeSplitter::expandPos( int id, int* min, int* max )
854{
855 QSplitterLayoutStruct *s = data->list.at(id-1);
856 QWidget* w = s->wid;
857 *min = pick( w->mapToParent( QPoint(0,0) ) );
858
859 if ( (uint) id == data->list.count() ) {
860 pick( size() );
861 }
862 else {
863 QSplitterLayoutStruct *s = data->list.at(id+1);
864 QWidget* w = s->wid;
865 *max = pick( w->mapToParent( QPoint( w->width(), w->height() ) ) ) -8;
866 }
867}
868
869
870/*!
871 Returns the valid range of the splitter with id \a id in \a *min and \a *max.
872
873 \sa idAfter()
874*/
875
876void KDGanttMinimizeSplitter::getRange( int id, int *min, int *max )
877{
878 int minB = 0;//before
879 int maxB = 0;
880 int minA = 0;
881 int maxA = 0;//after
882 int n = data->list.count();
883 if ( id < 0 || id >= n )
884 return;
885 int i;
886 for ( i = 0; i < id; i++ ) {
887 QSplitterLayoutStruct *s = data->list.at(i);
888 if ( s->wid->isHidden() ) {
889 //ignore
890 } else if ( s->isSplitter ) {
891 minB += s->sizer;
892 maxB += s->sizer;
893 } else {
894 minB += pick( minSize(s->wid) );
895 maxB += pick( s->wid->maximumSize() );
896 }
897 }
898 for ( i = id; i < n; i++ ) {
899 QSplitterLayoutStruct *s = data->list.at(i);
900 if ( s->wid->isHidden() ) {
901 //ignore
902 } else if ( s->isSplitter ) {
903 minA += s->sizer;
904 maxA += s->sizer;
905 } else {
906 minA += pick( minSize(s->wid) );
907 maxA += pick( s->wid->maximumSize() );
908 }
909 }
910 QRect r = contentsRect();
911 if ( orient == Horizontal && false ) {
912#if QT_VERSION >= 300
913 int splitterWidth = style().pixelMetric(QStyle::PM_SplitterWidth, this);
914#else
915 int splitterWidth = style().splitterWidth();
916#endif
917
918 if ( min )
919 *min = pick(r.topRight()) - QMIN( maxB, pick(r.size())-minA ) - splitterWidth;
920 if ( max )
921 *max = pick(r.topRight()) - QMAX( minB, pick(r.size())-maxA ) - splitterWidth;
922 } else {
923 if ( min )
924 *min = pick(r.topLeft()) + QMAX( minB, pick(r.size())-maxA );
925 if ( max )
926 *max = pick(r.topLeft()) + QMIN( maxB, pick(r.size())-minA );
927 }
928}
929
930
931/*!
932 Returns the closest legal position to \a p of the splitter with id \a id.
933
934 \sa idAfter()
935*/
936
937int KDGanttMinimizeSplitter::adjustPos( int p, int id )
938{
939 int min = 0;
940 int max = 0;
941 getRange( id, &min, &max );
942 p = QMAX( min, QMIN( p, max ) );
943
944 return p;
945}
946
947
948void KDGanttMinimizeSplitter::doResize()
949{
950 QRect r = contentsRect();
951 int i;
952 int n = data->list.count();
953 QMemArray<QLayoutStruct> a( n );
954 for ( i = 0; i< n; i++ ) {
955 a[i].init();
956 QSplitterLayoutStruct *s = data->list.at(i);
957 if ( s->wid->isHidden() ) {
958 a[i].stretch = 0;
959 a[i].sizeHint = a[i].minimumSize = 0;
960 a[i].maximumSize = 0;
961 } else if ( s->isSplitter ) {
962 a[i].stretch = 0;
963 a[i].sizeHint = a[i].minimumSize = a[i].maximumSize = s->sizer;
964 a[i].empty = FALSE;
965 } else if ( s->mode == KeepSize ) {
966 a[i].stretch = 0;
967 a[i].minimumSize = pick( minSize(s->wid) );
968 a[i].sizeHint = s->sizer;
969 a[i].maximumSize = pick( s->wid->maximumSize() );
970 a[i].empty = FALSE;
971 } else if ( s->mode == FollowSizeHint ) {
972 a[i].stretch = 0;
973 a[i].minimumSize = a[i].sizeHint = pick( s->wid->sizeHint() );
974 a[i].maximumSize = pick( s->wid->maximumSize() );
975 a[i].empty = FALSE;
976 } else { //proportional
977 a[i].stretch = s->sizer;
978 a[i].maximumSize = pick( s->wid->maximumSize() );
979 a[i].sizeHint = a[i].minimumSize = pick( minSize(s->wid) );
980 a[i].empty = FALSE;
981 }
982 }
983
984 kdganttGeomCalc( a, 0, n, pick( r.topLeft() ), pick( r.size() ), 0 );
985
986 for ( i = 0; i< n; i++ ) {
987 QSplitterLayoutStruct *s = data->list.at(i);
988 setG( s->wid, a[i].pos, a[i].size );
989 }
990
991}
992
993
994void KDGanttMinimizeSplitter::recalc( bool update )
995{
996 int fi = 2*frameWidth();
997 int maxl = fi;
998 int minl = fi;
999 int maxt = QWIDGETSIZE_MAX;
1000 int mint = fi;
1001 int n = data->list.count();
1002 bool first = TRUE;
1003 /*
1004 The splitter before a hidden widget is always hidden.
1005 The splitter before the first visible widget is hidden.
1006 The splitter before any other visible widget is visible.
1007 */
1008 for ( int i = 0; i< n; i++ ) {
1009 QSplitterLayoutStruct *s = data->list.at(i);
1010 if ( !s->isSplitter ) {
1011 QSplitterLayoutStruct *p = (i > 0) ? p = data->list.at( i-1 ) : 0;
1012 if ( p && p->isSplitter )
1013 if ( first || s->wid->isHidden() )
1014 p->wid->hide(); //may trigger new recalc
1015 else
1016 p->wid->show(); //may trigger new recalc
1017 if ( !s->wid->isHidden() )
1018 first = FALSE;
1019 }
1020 }
1021
1022 bool empty=TRUE;
1023 for ( int j = 0; j< n; j++ ) {
1024 QSplitterLayoutStruct *s = data->list.at(j);
1025 if ( !s->wid->isHidden() ) {
1026 empty = FALSE;
1027 if ( s->isSplitter ) {
1028 minl += s->sizer;
1029 maxl += s->sizer;
1030 } else {
1031 QSize minS = minSize(s->wid);
1032 minl += pick( minS );
1033 maxl += pick( s->wid->maximumSize() );
1034 mint = QMAX( mint, trans( minS ));
1035 int tm = trans( s->wid->maximumSize() );
1036 if ( tm > 0 )
1037 maxt = QMIN( maxt, tm );
1038 }
1039 }
1040 }
1041 if ( empty ) {
1042 if ( parentWidget() != 0 && parentWidget()->inherits("KDGanttMinimizeSplitter") ) {
1043 // nested splitters; be nice
1044 maxl = maxt = 0;
1045 } else {
1046 // KDGanttMinimizeSplitter with no children yet
1047 maxl = QWIDGETSIZE_MAX;
1048 }
1049 } else {
1050 maxl = QMIN( maxl, QWIDGETSIZE_MAX );
1051 }
1052 if ( maxt < mint )
1053 maxt = mint;
1054
1055 if ( orient == Horizontal ) {
1056 setMaximumSize( maxl, maxt );
1057 setMinimumSize( minl, mint );
1058 } else {
1059 setMaximumSize( maxt, maxl );
1060 setMinimumSize( mint, minl );
1061 }
1062 if ( update )
1063 doResize();
1064}
1065
1066/*!
1067 Sets resize mode of \a w to \a mode.
1068
1069 \sa ResizeMode
1070*/
1071
1072void KDGanttMinimizeSplitter::setResizeMode( QWidget *w, ResizeMode mode )
1073{
1074 processChildEvents();
1075 QSplitterLayoutStruct *s = data->list.first();
1076 while ( s ) {
1077 if ( s->wid == w ) {
1078 s->mode = mode;
1079 return;
1080 }
1081 s = data->list.next();
1082 }
1083 s = addWidget( w, TRUE );
1084 s->mode = mode;
1085}
1086
1087
1088/*!
1089 Returns TRUE if opaque resize is on; otherwise returns FALSE.
1090
1091 \sa setOpaqueResize()
1092*/
1093
1094bool KDGanttMinimizeSplitter::opaqueResize() const
1095{
1096 return data->opaque;
1097}
1098
1099
1100/*!
1101 If \a on is TRUE then opaque resizing is turned on; otherwise
1102 opaque resizing is turned off.
1103 Opaque resizing is initially turned off.
1104
1105 \sa opaqueResize()
1106*/
1107
1108void KDGanttMinimizeSplitter::setOpaqueResize( bool on )
1109{
1110 data->opaque = on;
1111}
1112
1113
1114/*!
1115 Moves widget \a w to the leftmost/top position.
1116*/
1117
1118void KDGanttMinimizeSplitter::moveToFirst( QWidget *w )
1119{
1120 processChildEvents();
1121 bool found = FALSE;
1122 QSplitterLayoutStruct *s = data->list.first();
1123 while ( s ) {
1124 if ( s->wid == w ) {
1125 found = TRUE;
1126 QSplitterLayoutStruct *p = data->list.prev();
1127 if ( p ) { // not already at first place
1128 data->list.take(); //take p
1129 data->list.take(); // take s
1130 data->list.insert( 0, p );
1131 data->list.insert( 0, s );
1132 }
1133 break;
1134 }
1135 s = data->list.next();
1136 }
1137 if ( !found )
1138 addWidget( w, TRUE );
1139 recalcId();
1140}
1141
1142
1143/*!
1144 Moves widget \a w to the rightmost/bottom position.
1145*/
1146
1147void KDGanttMinimizeSplitter::moveToLast( QWidget *w )
1148{
1149 processChildEvents();
1150 bool found = FALSE;
1151 QSplitterLayoutStruct *s = data->list.first();
1152 while ( s ) {
1153 if ( s->wid == w ) {
1154 found = TRUE;
1155 data->list.take(); // take s
1156 QSplitterLayoutStruct *p = data->list.current();
1157 if ( p ) { // the splitter handle after s
1158 data->list.take(); //take p
1159 data->list.append( p );
1160 }
1161 data->list.append( s );
1162 break;
1163 }
1164 s = data->list.next();
1165 }
1166 if ( !found )
1167 addWidget( w);
1168 recalcId();
1169}
1170
1171
1172void KDGanttMinimizeSplitter::recalcId()
1173{
1174 int n = data->list.count();
1175 for ( int i = 0; i < n; i++ ) {
1176 QSplitterLayoutStruct *s = data->list.at(i);
1177 if ( s->isSplitter )
1178 ((KDGanttSplitterHandle*)s->wid)->setId(i);
1179 }
1180}
1181
1182
1183/*!\reimp
1184*/
1185QSize KDGanttMinimizeSplitter::sizeHint() const
1186{
1187 constPolish();
1188 int l = 0;
1189 int t = 0;
1190 if ( children() ) {
1191 const QObjectList * c = children();
1192 QObjectListIt it( *c );
1193 QObject * o;
1194
1195 while( (o=it.current()) != 0 ) {
1196 ++it;
1197 if ( o->isWidgetType() &&
1198 !((QWidget*)o)->isHidden() ) {
1199 QSize s = ((QWidget*)o)->sizeHint();
1200 if ( s.isValid() ) {
1201 l += pick( s );
1202 t = QMAX( t, trans( s ) );
1203 }
1204 }
1205 }
1206 }
1207 return orientation() == Horizontal ? QSize( l, t ) : QSize( t, l );
1208}
1209
1210
1211/*!
1212\reimp
1213*/
1214
1215QSize KDGanttMinimizeSplitter::minimumSizeHint() const
1216{
1217 constPolish();
1218 int l = 0;
1219 int t = 0;
1220 if ( children() ) {
1221 const QObjectList * c = children();
1222 QObjectListIt it( *c );
1223 QObject * o;
1224
1225 while( (o=it.current()) != 0 ) {
1226 ++it;
1227 if ( o->isWidgetType() &&
1228 !((QWidget*)o)->isHidden() ) {
1229 QSize s = minSizeHint((QWidget*)o);
1230 if ( s.isValid() ) {
1231 l += pick( s );
1232 t = QMAX( t, trans( s ) );
1233 }
1234 }
1235 }
1236 }
1237 return orientation() == Horizontal ? QSize( l, t ) : QSize( t, l );
1238}
1239
1240
1241/*
1242 Calculates stretch parameters from current sizes
1243*/
1244
1245void KDGanttMinimizeSplitter::storeSizes()
1246{
1247 QSplitterLayoutStruct *s = data->list.first();
1248 while ( s ) {
1249 if ( !s->isSplitter )
1250 s->sizer = pick( s->wid->size() );
1251 s = data->list.next();
1252 }
1253}
1254
1255
1256#if 0 // ### remove this code ASAP
1257
1258/*!
1259 Hides \a w if \a hide is TRUE and updates the splitter.
1260
1261 \warning Due to a limitation in the current implementation,
1262 calling QWidget::hide() will not work.
1263*/
1264
1265void KDGanttMinimizeSplitter::setHidden( QWidget *w, bool hide )
1266{
1267 if ( w == w1 ) {
1268 w1show = !hide;
1269 } else if ( w == w2 ) {
1270 w2show = !hide;
1271 } else {
1272#ifdef QT_CHECK_RANGE
1273 qWarning( "KDGanttMinimizeSplitter::setHidden(), unknown widget" );
1274#endif
1275 return;
1276 }
1277 if ( hide )
1278 w->hide();
1279 else
1280 w->show();
1281 recalc( TRUE );
1282}
1283
1284
1285/*!
1286 Returns the hidden status of \a w
1287*/
1288
1289bool KDGanttMinimizeSplitter::isHidden( QWidget *w ) const
1290{
1291 if ( w == w1 )
1292 return !w1show;
1293 else if ( w == w2 )
1294 return !w2show;
1295#ifdef QT_CHECK_RANGE
1296 else
1297 qWarning( "KDGanttMinimizeSplitter::isHidden(), unknown widget" );
1298#endif
1299 return FALSE;
1300}
1301#endif
1302
1303
1304/*!
1305 Returns a list of the size parameters of all the widgets in this
1306 splitter.
1307
1308 Giving the values to another splitter's setSizes() function will
1309 produce a splitter with the same layout as this one.
1310
1311 Note that if you want to iterate over the list, you should
1312 iterate over a copy, e.g.
1313 \code
1314 QValueList<int> list = mySplitter.sizes();
1315 QValueList<int>::Iterator it = list.begin();
1316 while( it != list.end() ) {
1317 myProcessing( *it );
1318 ++it;
1319 }
1320 \endcode
1321
1322 \sa setSizes()
1323*/
1324
1325QValueList<int> KDGanttMinimizeSplitter::sizes() const
1326{
1327 if ( !testWState(WState_Polished) ) {
1328 QWidget* that = (QWidget*) this;
1329 that->polish();
1330 }
1331 QValueList<int> list;
1332 QSplitterLayoutStruct *s = data->list.first();
1333 while ( s ) {
1334 if ( !s->isSplitter )
1335 list.append( s->sizer );
1336 s = data->list.next();
1337 }
1338 return list;
1339}
1340
1341
1342
1343/*!
1344 Sets the size parameters to the values given in \a list.
1345 If the splitter is horizontal, the values set the sizes from
1346 left to right. If it is vertical, the sizes are applied from
1347 top to bottom.
1348 Extra values in \a list are ignored.
1349
1350 If \a list contains too few values, the result is undefined
1351 but the program will still be well-behaved.
1352
1353 \sa sizes()
1354*/
1355
1356void KDGanttMinimizeSplitter::setSizes( QValueList<int> list )
1357{
1358 processChildEvents();
1359 QValueList<int>::Iterator it = list.begin();
1360 QSplitterLayoutStruct *s = data->list.first();
1361 while ( s && it != list.end() ) {
1362 if ( !s->isSplitter ) {
1363 s->sizer = *it;
1364 ++it;
1365 }
1366 s = data->list.next();
1367 }
1368 doResize();
1369}
1370
1371
1372/*!
1373 Gets all posted child events, ensuring that the internal state of
1374 the splitter is consistent.
1375*/
1376
1377void KDGanttMinimizeSplitter::processChildEvents()
1378{
1379 QApplication::sendPostedEvents( this, QEvent::ChildInserted );
1380}
1381
1382
1383/*!
1384 \reimp
1385*/
1386
1387void KDGanttMinimizeSplitter::styleChange( QStyle& old )
1388{
1389
1390#if QT_VERSION >= 300
1391 int sw = style().pixelMetric(QStyle::PM_SplitterWidth, this);
1392#else
1393 int sw = style().splitterWidth();
1394#endif
1395 QSplitterLayoutStruct *s = data->list.first();
1396 while ( s ) {
1397 if ( s->isSplitter )
1398 s->sizer = sw;
1399 s = data->list.next();
1400 }
1401 doResize();
1402 QFrame::styleChange( old );
1403}
1404
1405#endif
1406
1407/*!
1408 Specifies the direction of the minimize buttons.
1409 If the orientation of the splitter is horizontal then with
1410 KDGanttMinimizeSplitter::Left or KDGanttMinimizeSplitter::Right should be used,
1411 otherwise either KDGanttMinimizeSplitter::Up or KDGanttMinimizeSplitter::Down
1412 should be used.
1413*/
1414void KDGanttMinimizeSplitter::setMinimizeDirection( Direction direction )
1415{
1416 _direction = direction;
1417}
1418
1419/*!
1420 Returns the direction of the minimize buttons.
1421*/
1422KDGanttMinimizeSplitter::Direction KDGanttMinimizeSplitter::minimizeDirection() const
1423{
1424 return _direction;
1425}
1426
1427/*
1428 This is a copy of qGeomCalc() in qlayoutengine.cpp which
1429 unfortunately isn't exported.
1430*/
1431static inline int toFixed( int i ) { return i * 256; }
1432static inline int fRound( int i ) {
1433 return ( i % 256 < 128 ) ? i / 256 : 1 + i / 256;
1434}
1435void kdganttGeomCalc( QMemArray<QLayoutStruct> &chain, int start, int count, int pos,
1436 int space, int spacer )
1437{
1438 typedef int fixed;
1439 int cHint = 0;
1440 int cMin = 0;
1441 int cMax = 0;
1442 int sumStretch = 0;
1443 int spacerCount = 0;
1444
1445 bool wannaGrow = FALSE; // anyone who really wants to grow?
1446 // bool canShrink = FALSE; // anyone who could be persuaded to shrink?
1447
1448 int i;
1449 for ( i = start; i < start + count; i++ ) {
1450 chain[i].done = FALSE;
1451 cHint += chain[i].sizeHint;
1452 cMin += chain[i].minimumSize;
1453 cMax += chain[i].maximumSize;
1454 sumStretch += chain[i].stretch;
1455 if ( !chain[i].empty )
1456 spacerCount++;
1457 wannaGrow = wannaGrow || chain[i].expansive;
1458 }
1459
1460 int extraspace = 0;
1461 if ( spacerCount )
1462 spacerCount--; // only spacers between things
1463 if ( space < cMin + spacerCount * spacer ) {
1464 //qDebug("not enough space");
1465 for ( i = start; i < start+count; i++ ) {
1466 chain[i].size = chain[i].minimumSize;
1467 chain[i].done = TRUE;
1468 }
1469 } else if ( space < cHint + spacerCount*spacer ) {
1470 // Less space than sizeHint, but more than minimum.
1471 // Currently take space equally from each, like in Qt 2.x.
1472 // Commented-out lines will give more space to stretchier items.
1473 int n = count;
1474 int space_left = space - spacerCount*spacer;
1475 int overdraft = cHint - space_left;
1476 //first give to the fixed ones:
1477 for ( i = start; i < start+count; i++ ) {
1478 if ( !chain[i].done && chain[i].minimumSize >= chain[i].sizeHint) {
1479 chain[i].size = chain[i].sizeHint;
1480 chain[i].done = TRUE;
1481 space_left -= chain[i].sizeHint;
1482 // sumStretch -= chain[i].stretch;
1483 n--;
1484 }
1485 }
1486 bool finished = n == 0;
1487 while ( !finished ) {
1488 finished = TRUE;
1489 fixed fp_over = toFixed( overdraft );
1490 fixed fp_w = 0;
1491
1492 for ( i = start; i < start+count; i++ ) {
1493 if ( chain[i].done )
1494 continue;
1495 // if ( sumStretch <= 0 )
1496 fp_w += fp_over / n;
1497 // else
1498 // fp_w += (fp_over * chain[i].stretch) / sumStretch;
1499 int w = fRound( fp_w );
1500 chain[i].size = chain[i].sizeHint - w;
1501 fp_w -= toFixed( w ); //give the difference to the next
1502 if ( chain[i].size < chain[i].minimumSize ) {
1503 chain[i].done = TRUE;
1504 chain[i].size = chain[i].minimumSize;
1505 finished = FALSE;
1506 overdraft -= chain[i].sizeHint - chain[i].minimumSize;
1507 // sumStretch -= chain[i].stretch;
1508 n--;
1509 break;
1510 }
1511 }
1512 }
1513 } else { //extra space
1514 int n = count;
1515 int space_left = space - spacerCount*spacer;
1516 // first give to the fixed ones, and handle non-expansiveness
1517 for ( i = start; i < start + count; i++ ) {
1518 if ( !chain[i].done && (chain[i].maximumSize <= chain[i].sizeHint
1519 || wannaGrow && !chain[i].expansive) ) {
1520 chain[i].size = chain[i].sizeHint;
1521 chain[i].done = TRUE;
1522 space_left -= chain[i].sizeHint;
1523 sumStretch -= chain[i].stretch;
1524 n--;
1525 }
1526 }
1527 extraspace = space_left;
1528 /*
1529 Do a trial distribution and calculate how much it is off.
1530 If there are more deficit pixels than surplus pixels, give
1531 the minimum size items what they need, and repeat.
1532 Otherwise give to the maximum size items, and repeat.
1533
1534 I have a wonderful mathematical proof for the correctness
1535 of this principle, but unfortunately this comment is too
1536 small to contain it.
1537 */
1538 int surplus, deficit;
1539 do {
1540 surplus = deficit = 0;
1541 fixed fp_space = toFixed( space_left );
1542 fixed fp_w = 0;
1543 for ( i = start; i < start+count; i++ ) {
1544 if ( chain[i].done )
1545 continue;
1546 extraspace = 0;
1547 if ( sumStretch <= 0 )
1548 fp_w += fp_space / n;
1549 else
1550 fp_w += (fp_space * chain[i].stretch) / sumStretch;
1551 int w = fRound( fp_w );
1552 chain[i].size = w;
1553 fp_w -= toFixed( w ); // give the difference to the next
1554 if ( w < chain[i].sizeHint ) {
1555 deficit += chain[i].sizeHint - w;
1556 } else if ( w > chain[i].maximumSize ) {
1557 surplus += w - chain[i].maximumSize;
1558 }
1559 }
1560 if ( deficit > 0 && surplus <= deficit ) {
1561 // give to the ones that have too little
1562 for ( i = start; i < start+count; i++ ) {
1563 if ( !chain[i].done &&
1564 chain[i].size < chain[i].sizeHint ) {
1565 chain[i].size = chain[i].sizeHint;
1566 chain[i].done = TRUE;
1567 space_left -= chain[i].sizeHint;
1568 sumStretch -= chain[i].stretch;
1569 n--;
1570 }
1571 }
1572 }
1573 if ( surplus > 0 && surplus >= deficit ) {
1574 // take from the ones that have too much
1575 for ( i = start; i < start+count; i++ ) {
1576 if ( !chain[i].done &&
1577 chain[i].size > chain[i].maximumSize ) {
1578 chain[i].size = chain[i].maximumSize;
1579 chain[i].done = TRUE;
1580 space_left -= chain[i].maximumSize;
1581 sumStretch -= chain[i].stretch;
1582 n--;
1583 }
1584 }
1585 }
1586 } while ( n > 0 && surplus != deficit );
1587 if ( n == 0 )
1588 extraspace = space_left;
1589 }
1590
1591 // as a last resort, we distribute the unwanted space equally
1592 // among the spacers (counting the start and end of the chain).
1593
1594 //### should do a sub-pixel allocation of extra space
1595 int extra = extraspace / ( spacerCount + 2 );
1596 int p = pos + extra;
1597 for ( i = start; i < start+count; i++ ) {
1598 chain[i].pos = p;
1599 p = p + chain[i].size;
1600 if ( !chain[i].empty )
1601 p += spacer+extra;
1602 }
1603}
1604
1605#endif
1606
1607/*!
1608 \enum KDGanttMinimizeSplitter::Direction
1609
1610 The values of this enumeration describe into which direction the
1611 splitter will collapse its child widgets. By extension, it also
1612 specifies the orientation of the splitter; collapsing to the left or
1613 to the right results in a horizontal splitter, collapsing to the top
1614 or bottom in a vertical splitter.
1615*/
1616
1617/*!
1618 \fn Orientation KDGanttMinimizeSplitter::orientation() const
1619
1620 Returns the orientation of the splitter.
1621*/
1622
1623/*! \enum KDGanttMinimizeSplitter::ResizeMode
1624
1625 This enum type describes how KDGanttMinimizeSplitter will resize each of its child widgets. The currently defined values are:
1626
1627 Stretch: the widget will be resized when the splitter
1628 itself is resized.
1629
1630 KeepSize: KDGanttMinimizeSplitter will try to keep this widget's size
1631 unchanged.
1632
1633 FollowSizeHint: KDGanttMinimizeSplitter will resize the widget when the
1634 widget's size hint changes.
1635*/
1636