qsplitter.cpp

Go to the documentation of this file.

/****************************************************************************
** $Id: qsplitter.cpp,v 1.2 2004/03/01 17:56:47 chicken Exp $
**
**  Splitter widget
**
**  Created:  980105
**
** Copyright (C) 1992-2000 Trolltech AS.  All rights reserved.
**
** This file is part of the widgets module of the Qt GUI Toolkit.
**
** This file may be distributed under the terms of the Q Public License
** as defined by Trolltech AS of Norway and appearing in the file
** LICENSE.QPL included in the packaging of this file.
**
** 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 Qt Enterprise Edition or Qt Professional Edition
** licenses may use this file in accordance with the Qt 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.trolltech.com/pricing.html or email sales@trolltech.com for
**   information about Qt Commercial License Agreements.
** See http://www.trolltech.com/qpl/ for QPL licensing information.
** See http://www.trolltech.com/gpl/ for GPL licensing information.
**
** Contact info@trolltech.com if any conditions of this licensing are
** not clear to you.
**
**********************************************************************/
#include "qsplitter.h"

#include "qdrawutil.h"
#include "qlayoutengine_p.h"
#include "qobjectlist.h"
#include "qapplication.h" //sendPostedEvents

class QSplitterHandle : public QWidget
{
public:
    QSplitterHandle( Qt::Orientation o,
                       QSplitter *parent, const char* name=0 );
    void setOrientation( Qt::Orientation o );
    Qt::Orientation orientation() const { return orient; }

    bool opaque() const { return s->opaqueResize(); }

    QSize sizeHint() const;
    QSizePolicy sizePolicy() const;

    int id() const { return myId; } // data->list.at(id())->wid == this
    void setId( int i ) { myId = i; }

protected:
    void paintEvent( QPaintEvent * );
    void mouseMoveEvent( QMouseEvent * );
    void mousePressEvent( QMouseEvent * );
    void mouseReleaseEvent( QMouseEvent * );

private:
    Qt::Orientation orient;
    bool opaq;
    int myId;

    QSplitter *s;
};

static int mouseOffset;
static int opaqueOldPos = -1; //### there's only one mouse, but this is a bit risky


QSplitterHandle::QSplitterHandle( Qt::Orientation o,
                                  QSplitter *parent, const char * name )
    : QWidget( parent, name )
{
    s = parent;
    setOrientation(o);
}

QSizePolicy QSplitterHandle::sizePolicy() const
{
    //### removeme 3.0
    return QWidget::sizePolicy();
}

QSize QSplitterHandle::sizeHint() const
{
    int sw = style().splitterWidth();
    return QSize(sw,sw).expandedTo( QApplication::globalStrut() );
}

void QSplitterHandle::setOrientation( Qt::Orientation o )
{
    orient = o;
#ifndef QT_NO_CURSOR
    if ( o == QSplitter::Horizontal )
        setCursor( splitHCursor );
    else
        setCursor( splitVCursor );
#endif
}


void QSplitterHandle::mouseMoveEvent( QMouseEvent *e )
{
    if ( !(e->state()&LeftButton) )
        return;
    QCOORD pos = s->pick(parentWidget()->mapFromGlobal(e->globalPos()))
                 - mouseOffset;
    if ( opaque() ) {
        s->moveSplitter( pos, id() );
    } else {
        int min = pos; int max = pos;
        s->getRange( id(), &min, &max );
        s->setRubberband( QMAX( min, QMIN(max, pos )));
    }
}

void QSplitterHandle::mousePressEvent( QMouseEvent *e )
{
    if ( e->button() == LeftButton )
        mouseOffset = s->pick(e->pos());
}

void QSplitterHandle::mouseReleaseEvent( QMouseEvent *e )
{
    if ( !opaque() && e->button() == LeftButton ) {
        QCOORD pos = s->pick(parentWidget()->mapFromGlobal(e->globalPos()));
        s->setRubberband( -1 );
        s->moveSplitter( pos, id() );
    }
}

void QSplitterHandle::paintEvent( QPaintEvent * )
{
    QPainter p( this );
    s->drawSplitter( &p, 0, 0, width(), height() );
}


class QSplitterLayoutStruct
{
public:
    QSplitter::ResizeMode mode;
    QCOORD sizer;
    bool isSplitter;
    QWidget *wid;
};

class QSplitterData
{
public:
    QSplitterData() : opaque( FALSE ), firstShow( TRUE ) {}

    QList<QSplitterLayoutStruct> list;
    bool opaque;
    bool firstShow;
};


// NOT REVISED
static QSize minSize( 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));
}

QSplitter::QSplitter( QWidget *parent, const char *name )
    :QFrame(parent,name,WPaintUnclipped)
{
     orient = Horizontal;
     init();
}


QSplitter::QSplitter( Orientation o, QWidget *parent, const char *name )
    :QFrame(parent,name,WPaintUnclipped)
{
     orient = o;
     init();
}


QSplitter::~QSplitter()
{
    data->list.setAutoDelete( TRUE );
    delete data;
}


void QSplitter::init()
{
    data = new QSplitterData;
    if ( orient == Horizontal )
        setSizePolicy( QSizePolicy(QSizePolicy::Fixed,QSizePolicy::Minimum) );
    else
        setSizePolicy( QSizePolicy(QSizePolicy::Minimum,QSizePolicy::Fixed) );
}


void QSplitter::setOrientation( Orientation o )
{
    if ( orient == o )
        return;
    orient = o;

    if ( orient == Horizontal )
        setSizePolicy( QSizePolicy( QSizePolicy::Fixed, QSizePolicy::Minimum ) );
    else
        setSizePolicy( QSizePolicy( QSizePolicy::Minimum, QSizePolicy::Fixed ) );

    QSplitterLayoutStruct *s = data->list.first();
    while ( s ) {
        if ( s->isSplitter )
            ((QSplitterHandle*)s->wid)->setOrientation( o );
        s = data->list.next();  // ### next at end of loop, no iterator
    }
    recalc( isVisible() );
}


void QSplitter::resizeEvent( QResizeEvent * )
{
    doResize();
}


QSplitterLayoutStruct *QSplitter::addWidget( QWidget *w, bool first )
{
    QSplitterLayoutStruct *s;
    QSplitterHandle *newHandle = 0;
    if ( data->list.count() > 0 ) {
        s = new QSplitterLayoutStruct;
        s->mode = KeepSize;
        newHandle = new QSplitterHandle( orientation(), this );
        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;
}


void QSplitter::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();
        }
    }
}


void QSplitter::setRubberband( int p )
{
    QPainter paint( this );
    paint.setPen( gray );
    paint.setBrush( gray );
    paint.setRasterOp( XorROP );
    QRect r = contentsRect();
    const int rBord = 3; //Themable????
    const int sw = style().splitterWidth();
    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;
}


bool QSplitter::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 );
}


void QSplitter::drawSplitter( QPainter *p,
                              QCOORD x, QCOORD y, QCOORD w, QCOORD h )
{
    style().drawSplitter( p, x, y, w, h, colorGroup(), orient );
}


int QSplitter::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;
}


void QSplitter::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 = p < oldP;

    moveAfter( p, id, upLeft );
    moveBefore( p-1, id-1, upLeft );

    storeSizes();
}


void QSplitter::setG( QWidget *w, int p, int s )
{
    if ( orient == Horizontal )
        w->setGeometry( p, contentsRect().y(), s, contentsRect().height() );
    else
        w->setGeometry( contentsRect().x(), p, contentsRect().width(), s );
}


void QSplitter::moveBefore( int pos, int id, bool upLeft )
{
    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 dd = s->sizer;
        if ( upLeft ) {
            setG( w, pos-dd+1, dd );
            moveBefore( pos-dd, id-1, upLeft );
        } else {
            moveBefore( pos-dd, id-1, upLeft );
            setG( w, pos-dd+1, dd );
        }
    } else {
        int left = pick( w->pos() );
        int dd = pos - left + 1;
        dd = QMAX( pick(minSize(w)), QMIN(dd, pick(w->maximumSize())));
        int newLeft = pos-dd+1;
        setG( w, newLeft, dd );
        if ( left != newLeft )
            moveBefore( newLeft-1, id-1, upLeft );
    }
}


void QSplitter::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;
        if ( upLeft ) {
            setG( w, pos, dd );
            moveAfter( pos+dd, id+1, upLeft );
        } else {
            moveAfter( pos+dd, id+1, upLeft );
            setG( w, pos, dd );
        }
    } else {
        int right = pick( w->geometry().bottomRight() );

        int dd = right - pos + 1;
        dd = QMAX( pick(minSize(w)), QMIN(dd, pick(w->maximumSize())));
        int newRight = pos+dd-1;
        setG( w, pos, dd );
        moveAfter( newRight+1, id+1, upLeft );
    }
}


void QSplitter::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 ( min )
        *min = pick(r.topLeft()) + QMAX( minB, pick(r.size())-maxA );
    if ( max )
        *max = pick(r.topLeft()) + QMIN( maxB, pick(r.size())-minA );

}


int QSplitter::adjustPos( int p, int id )
{
    int min = 0;
    int max = 0;
    getRange( id, &min, &max );
    p = QMAX( min, QMIN( p, max ) );

    return p;
}


void QSplitter::doResize()
{
    QRect r = contentsRect();
    int i;
    int n = data->list.count();
    QArray<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;
        }
    }

    qGeomCalc( a, 0, n, pick( r.topLeft() ), pick( r.size() ), 0 );
    for ( i = 0; i< n; i++ ) {
        QSplitterLayoutStruct *s = data->list.at(i);
        if ( orient == Horizontal )
            s->wid->setGeometry( a[i].pos, r.top(), a[i].size, r.height() );
        else
            s->wid->setGeometry( r.left(), a[i].pos, r.width(), a[i].size );
    }

}


void QSplitter::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 )
        maxl = maxt = 0;
    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();
}

void QSplitter::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;
}


bool QSplitter::opaqueResize() const
{
    return data->opaque;
}


void QSplitter::setOpaqueResize( bool on )
{
    data->opaque = on;
}


void QSplitter::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();
}


void QSplitter::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 QSplitter::recalcId()
{
    int n = data->list.count();
    for ( int i = 0; i < n; i++ ) {
        QSplitterLayoutStruct *s = data->list.at(i);
        if ( s->isSplitter )
            ((QSplitterHandle*)s->wid)->setId(i);
    }
}


QSize QSplitter::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 );
}


QSize QSplitter::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 = minSize((QWidget*)o);
                if ( s.isValid() ) {
                    l += pick( s );
                    t = QMAX( t, trans( s ) );
                }
            }
        }
    }
    return orientation() == Horizontal ? QSize( l, t ) : QSize( t, l );
}



QSizePolicy QSplitter::sizePolicy() const
{
    return QSizePolicy( QSizePolicy::Expanding, QSizePolicy::Expanding );
}


void QSplitter::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

void QSplitter::setHidden( QWidget *w, bool hide )
{
    if ( w == w1 ) {
        w1show = !hide;
    } else if ( w == w2 ) {
        w2show = !hide;
    } else {
#ifdef CHECK_RANGE
        qWarning( "QSplitter::setHidden(), unknown widget" );
#endif
        return;
    }
    if ( hide )
        w->hide();
    else
        w->show();
    recalc( TRUE );
}


bool QSplitter::isHidden( QWidget *w ) const
{
    if ( w == w1 )
        return !w1show;
     else if ( w == w2 )
        return !w2show;
#ifdef CHECK_RANGE
    else
        qWarning( "QSplitter::isHidden(), unknown widget" );
#endif
    return FALSE;
}
#endif


QValueList<int> QSplitter::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;
}



void QSplitter::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();
}


void QSplitter::processChildEvents()
{
    QApplication::sendPostedEvents( this, QEvent::ChildInserted );
}


void QSplitter::styleChange( QStyle& old )
{
    int sw = style().splitterWidth();
    QSplitterLayoutStruct *s = data->list.first();
    while ( s ) {
        if ( s->isSplitter )
            s->sizer = sw;
        s = data->list.next();
    }
    doResize();
    QFrame::styleChange( old );
}

---