osplitter.cpp

Go to the documentation of this file.

/*
               =.            This file is part of the OPIE Project
             .=l.            Copyright (c)  2003 hOlgAr <zecke@handhelds.org>
           .>+-=
 _;:,     .>    :=|.         This library is free software; you can
.> <`_,   >  .   <=          redistribute it and/or  modify it under
:`=1 )Y*s>-.--   :           the terms of the GNU Library General Public
.="- .-=="i,     .._         License as published by the Free Software
 - .   .-<_>     .<>         Foundation; either version 2 of the License,
     ._= =}       :          or (at your option) any later version.
    .%`+i>       _;_.
    .i_,=:_.      -<s.       This library is distributed in the hope that
     +  .  -:.       =       it will be useful,  but WITHOUT ANY WARRANTY;
    : ..    .:,     . . .    without even the implied warranty of
    =_        +     =;=|`    MERCHANTABILITY or FITNESS FOR A
  _.=:.       :    :=>`:     PARTICULAR PURPOSE. See the GNU
..}^=.=       =       ;      Library General Public License for more
++=   -.     .`     .:       details.
 :     =  ...= . :.=-
 -.   .:....=;==+<;          You should have received a copy of the GNU
  -_. . .   )=.  =           Library General Public License along with
    --        :-=`           this library; see the file COPYING.LIB.
                             If not, write to the Free Software Foundation,
                             Inc., 59 Temple Place - Suite 330,
                             Boston, MA 02111-1307, USA.

*/

#include "osplitter.h"

/* OPIE */
#include <opie2/otabwidget.h>
#include <opie2/odebug.h>

/* QT */
#include <qvaluelist.h>
#include <qvbox.h>

using namespace Opie::Ui;
using namespace Opie::Ui::Internal;

OSplitter::OSplitter( Orientation orient, QWidget* parent, const char* name, WFlags fl )
        : QFrame( parent, name, fl )
{
    m_orient = orient;
    m_hbox = 0;
    m_size_policy = 330;
    setFontPropagation( AllChildren );
    setPalettePropagation( AllChildren );

    /* start by default with the tab widget */
    m_tabWidget = 0;
    m_parentTab = 0;
    changeTab();

}


OSplitter::~OSplitter()
{
    m_splitter.setAutoDelete( true );
    m_splitter.clear();

    delete m_hbox;
    delete m_tabWidget;
}


void OSplitter::setLabel( const QString& name )
{
    m_name = name;
}

void OSplitter::setIconName( const QString& name )
{
    m_icon = name;
}


QString OSplitter::iconName()const
{
    return m_icon;
}

QString OSplitter::label()const
{
    return m_name;
}

void OSplitter::setSizeChange( int width_height )
{
    m_size_policy = width_height;
    QSize sz(width(), height() );
    QResizeEvent ev(sz, sz );
    resizeEvent(&ev);
}

void OSplitter::addWidget( OSplitter* split )
{
    m_splitter.append( split );

    /*
     * set tab widget
     */
    if (m_tabWidget )
        setTabWidget( m_parentTab );
    else
    {
        OSplitterContainer con;
        con.widget =split;
        addToBox( con );
    }
}

/*
 * If in a tab it should be removed
 * and if in a hbox  the reparent kills it too
 */
void OSplitter::removeWidget( OSplitter* split)
{
    split->setTabWidget( 0 );
    split->reparent( 0, 0, QPoint(0, 0) );
}

void OSplitter::addWidget( QWidget* wid, const QString& icon, const QString& label )
{
#ifdef DEBUG
    if (!wid )
        return;
#endif
    OSplitterContainer cont;
    cont.widget = wid;
    cont.icon =icon;
    cont.name = label;

    m_container.append( cont );

    /*
     *
     */
    if (!m_splitter.isEmpty() && (m_tabWidget || m_parentTab ) )
        setTabWidget( m_parentTab );
    else
    {
        if (m_hbox )
            addToBox( cont );
        else
            addToTab( cont );
    }
}


void OSplitter::removeWidget( QWidget* w)
{
    ContainerList::Iterator it;
    for ( it = m_container.begin(); it != m_container.end(); ++it )
        if ( (*it).widget == w )
            break;

    if (it == m_container.end() )
        return;


    /* only tab needs to be removed.. box recognizes it */
    if ( !m_hbox )
        removeFromTab( w );


    /* Find reparent it and remove it from our list */

    w->reparent( 0, 0, QPoint(0, 0));
    it = m_container.remove( it );

}


void OSplitter::setCurrentWidget( QWidget*  w)
{
    if (m_tabWidget )
        m_tabWidget->setCurrentTab( w );
    //    else
    //      m_hbox->setFocus( w );

}

void OSplitter::setCurrentWidget( const QString& label )
{
    ContainerList::Iterator it;
    for (it = m_container.begin(); it != m_container.end(); ++it )
    {
        if ( (*it).name == label )
        {
            setCurrentWidget( (*it).widget );
            break;
        }
    }
}

void OSplitter::setCurrentWidget( int tab )
{
    if (m_tabWidget )
        m_tabWidget->setCurrentTab( tab );
}

QWidget* OSplitter::currentWidget() const
{
    if (m_tabWidget)
        return m_tabWidget->currentWidget();
    else if (m_parentTab )
        return m_parentTab->currentWidget();

    return 0l;
}
/* wrong */
#if 0

QSize OSplitter::sizeHint()const
{
    if (m_parentTab )
        return QFrame::sizeHint();

    if (m_hbox )
        return m_hbox->sizeHint();
    else
        return m_tabWidget->sizeHint();
}

QSize OSplitter::minimumSizeHint()const
{
    if (m_parentTab )
        return QFrame::minimumSizeHint();
    if (m_hbox)
        return m_hbox->sizeHint();
    else
        return m_tabWidget->sizeHint();
}
#endif

void OSplitter::resizeEvent( QResizeEvent* res )
{
    QFrame::resizeEvent( res );
    /*
     *
     */
    bool mode = true;
    if ( res->size().width() > m_size_policy &&
            m_orient == Horizontal )
    {
        changeHBox();
        mode = false;
    }
    else if ( (res->size().width() <= m_size_policy &&
               m_orient == Horizontal ) ||
              (res->size().height() <= m_size_policy &&
               m_orient == Vertical ) )
    {
        changeTab();
    }
    else if ( res->size().height() > m_size_policy &&
              m_orient == Vertical )
    {
        changeVBox();
        mode = false;
    }

    emit sizeChanged(mode, m_orient );
}

/*
 * Adds a container to a tab either the parent tab
 * or our own
 */
void OSplitter::addToTab( const Opie::Ui::Internal::OSplitterContainer& con )
{
    QWidget *wid = con.widget;
    // not needed widgetstack will reparent as well    wid.reparent(m_tabWidget, wid->getWFlags(), QPoint(0, 0) );
    if (m_parentTab )
        m_parentTab->addTab( wid, con.icon, con.name );
    else
        m_tabWidget->addTab( wid, con.icon, con.name );
}


/*
 * adds a container to the box
 */
void OSplitter::addToBox( const Opie::Ui::Internal::OSplitterContainer& con )
{
    QWidget* wid = con.widget;
    wid->reparent(m_hbox, 0,  QPoint(0, 0) );
}


/*
 * Removes a widget from the tab
 */
void OSplitter::removeFromTab( QWidget* wid )
{
    if (m_parentTab )
        m_parentTab->removePage( wid );
    else
        m_tabWidget->removePage( wid );
}

/*
 * switches over to a OTabWidget layout
 * it is recursive
 */
void OSplitter::changeTab()
{
    /* if we're the owner of the tab widget */
    if (m_tabWidget )
    {
        raise();
        show();
        m_tabWidget->setGeometry( frameRect() );
        return;
    }

    /*
     * and add all widgets this will reparent them
     * delete m_hbox set it to 0
     *
     */
    OTabWidget *tab;
    if ( m_parentTab )
    {
        hide();
        tab = m_parentTab;
        /* expensive but needed cause we're called from setTabWidget and resizeEvent*/
        if (!m_container.isEmpty() )
        {
            ContainerList::Iterator it = m_container.begin();
            for (; it != m_container.end(); ++it )
                m_parentTab->removePage( (*it).widget );
        }
    }
    else
        tab = m_tabWidget = new OTabWidget( this );

    connect(tab, SIGNAL(currentChanged(QWidget*) ),
            this, SIGNAL(currentChanged(QWidget*) ) );

    for ( ContainerList::Iterator it = m_container.begin(); it != m_container.end(); ++it )
    {
        addToTab( (*it) );
    }

    for ( OSplitter* split = m_splitter.first(); split; split = m_splitter.next() )
    {
        split->reparent(this, 0, QPoint(0, 0) );
        split->setTabWidget( tab );
    }


    delete m_hbox;
    m_hbox = 0;
    if (!m_tabWidget )
        return;

    m_tabWidget->setGeometry( frameRect() );
    m_tabWidget->show();

}

/*
 * changes over to a box
 * this is recursive as well
 */
void OSplitter::changeHBox()
{
    if (m_hbox )
    {
        m_hbox->setGeometry( frameRect() );
        return;
    }

    m_hbox = new QHBox( this );
    commonChangeBox();
}

void OSplitter::changeVBox()
{
    if (m_hbox )
    {
        m_hbox->setGeometry( frameRect() );
        return;
    }

    m_hbox = new QVBox( this );

    commonChangeBox();

}

/*
 * common box code
 * first remove and add children
 * the other splitters
 * it is recursive as well due the call to setTabWidget
 */
void OSplitter::commonChangeBox()
{
    for (ContainerList::Iterator it = m_container.begin(); it != m_container.end(); ++it )
    {
        /* only if parent tab.. m_tabWidgets gets deleted and would do that as well */
        if (m_parentTab )
            removeFromTab( (*it).widget );
        addToBox( (*it) );
    }
    for ( OSplitter* split = m_splitter.first(); split; split = m_splitter.next() )
    {
        /* tell them the world had changed */
        split->setTabWidget( 0 );
        OSplitterContainer con;
        con.widget = split;
        //        con.widget = split->m_tabWidget ? static_cast<QWidget*>(split->m_tabWidget)
        //                     : static_cast<QWidget*>(split->m_hbox);
        addToBox( con );
    }



    if (m_parentTab )
        m_parentTab->addTab(m_hbox, iconName(), label() );
    else
    {
        m_hbox->setGeometry( frameRect() );
        m_hbox->show();
        delete m_tabWidget;
        m_tabWidget = 0;
        show(); // also show this widget
    }
}

/*
 * sets the tabwidget, removes tabs, and relayouts the widget
 */
void OSplitter::setTabWidget( OTabWidget* wid)
{
    /* clean up cause m_parentTab will not be available for us */
    if ( m_parentTab )
    {
        if (m_hbox )
            m_parentTab->removePage( m_hbox );
        else if (!m_container.isEmpty() )
        {
            ContainerList::Iterator it = m_container.begin();
            for ( ; it != m_container.end(); ++it )
                m_parentTab->removePage( (*it).widget );
        }
    }
    /* the parent Splitter changed so either make us indepent or dep */

    m_parentTab = wid;

    QWidget *tab =  m_tabWidget;
    QWidget *box =  m_hbox;
    m_hbox = 0; m_tabWidget = 0;

    if ( layoutMode() )
        changeTab();
    else if (m_orient == Horizontal )
        changeHBox();
    else
        changeVBox();

    /* our own crap is added and children from change* */
    delete tab;
    delete box;
}

#if 0
void OSplitter::reparentAll()
{
    if (m_container.isEmpty() )
        return;

    ContainerList::Iterator it = m_container.begin();
    for ( ; it != m_container.end(); ++it )
        (*it).wid->reparent(0, 0, QPoint(0, 0) );


}
#endif

bool OSplitter::layoutMode()const
{
    if ( size().width() > m_size_policy &&
            m_orient == Horizontal )
    {
        return false;
    }
    else if ( size().height() > m_size_policy &&
              m_orient == Vertical )
    {
        return false;
    }

    return true;
}

---