Rely on QFRame for the sizeHint

2 files changed, 7 insertions, 5 deletions

diff --git a/libopie/big-screen/osplitter.cpp b/libopie/big-screen/osplitter.cpp
index b09bc94..0c9ed6c 100644
--- a/libopie/big-screen/osplitter.cpp
+++ b/libopie/big-screen/osplitter.cpp
@@ -117,466 +117,467 @@ QString OSplitter::iconName()const {
 
 /**
  * returns the label set with setLabel
  * @see setLabel
  */
 QString OSplitter::label()const {
     return m_name;
 }
 
 /**
  * This function sets the size change policy of the splitter.
  * If this size marked is crossed the splitter will relayout.
  * Note: that depending on the set Orientation it'll either look
  * at the width or height.
  * Note: If you want to from side to side view to tabbed view you need
  * to make sure that the size you supply is not smaller than the minimum
  * size of your added widgets. Note that if you use widgets like QComboBoxes
  * you need to teach them to accept smaller sizes as well @see QWidget::setSizePolicy
  *
  * @param width_height The mark that will be watched. Interpreted depending on the Orientation of the Splitter.
  * @return void
  */
 void OSplitter::setSizeChange( int width_height ) {
     m_size_policy = width_height;
     QSize sz(width(), height() );
     QResizeEvent ev(sz, sz );
     resizeEvent(&ev);
 }
 
 /**
  * This functions allows to add another OSplitter and to share
  * the OTabBar in small screen mode. The ownerships gets transfered.
  * OSplitters are always added after normal widget items
  */
 void OSplitter::addWidget( OSplitter* split ) {
     m_splitter.append( split );
 
     /*
      * set tab widget
      */
     if (m_tabWidget )
         setTabWidget( m_parentTab );
     else{
         Opie::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
  */
 /**
  * This removes the splitter again. You currently need to call this
  * before you delete or otherwise you can get mem corruption
  * or other weird behaviour.
  * Owner ship gets transfered back to you it's current parent
  * is 0
  */
 void OSplitter::removeWidget( OSplitter* split) {
     split->setTabWidget( 0 );
     split->reparent( 0, 0, QPoint(0, 0) );
 }
 
 /**
  * Adds a widget to the Splitter. The widgets gets inserted
  * at the end of either the Box or TabWidget.
  * Ownership gets transfered and the widgets gets reparented.
  * Note: icon and label is only available on small screensizes
  *  if size is smaller than the mark
  * Warning: No null checking of the widget is done. Only on debug
  * a message will be outputtet
  *
  * @param wid The widget which will be added
  * @param icon The icon of the possible Tab
  * @param label The label of the possible Tab
  */
 void OSplitter::addWidget( QWidget* wid, const QString& icon, const QString& label ) {
 #ifdef DEBUG
     if (!wid ) {
         qWarning("Widget is not valid!");
         return;
     }
 #endif
     Opie::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 );
     }
 }
 
 
 /**
  * Removes the widget from the tab widgets if necessary.
  * OSplitter drops ownership of this widget and the widget
  * will be reparented i tto 0.
  * The widget will not be deleted.
  *
  * @param w The widget to be removed
  */
 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 );
 
 }
 
 
 /**
  * This method will give focus to the widget. If in a tabwidget
  * the tabbar will be changed
  *
  * @param w The widget which will be set the current one
  */
 void OSplitter::setCurrentWidget( QWidget*  w) {
     if (m_tabWidget )
         m_tabWidget->setCurrentTab( w );
 //    else
     //      m_hbox->setFocus( w );
 
 }
 
 /**
  * This is an overloaded member function and only differs in the
  * argument it takes.
  * Searches list of widgets for label. It'll pick the first label it finds
  *
  * @param label Label to look for. First match will be taken
  */
 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;
         }
     }
 }
 
 /**
  * This will only work when the TabWidget is active
  * If everything is visible this signal is kindly ignored
  * @see OTabWidget::setCurrentTab(int)
  *
  * @param tab The tab to make current
  */
 void OSplitter::setCurrentWidget( int tab ) {
     if (m_tabWidget )
         m_tabWidget->setCurrentTab( tab );
 }
 
 /**
  * return the currently activated widget if in tab widget mode
  * or null because all widgets are visible
  */
 QWidget* OSplitter::currentWidget() const{
     if (m_tabWidget)
         return m_tabWidget->currentWidget();
     else if (m_parentTab )
         return m_parentTab->currentWidget();
 
     return 0l;
 }
-
-
+/* wrong */
+#if 0
 /**
  * @reimplented for internal reasons
  * returns the sizeHint of one of its sub widgets
  */
 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
 
 /**
  * @reimplemented for internal reasons
  */
 void OSplitter::resizeEvent( QResizeEvent* res ) {
     QFrame::resizeEvent( res );
     /*
      *
      */
 //    qWarning("Old size was width = %d height = %d", res->oldSize().width(), res->oldSize().height() );
     bool mode = true;
     qWarning("New size is  width = %d height = %d  %s", res->size().width(), res->size().height(), name() );
     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 ) {
         qWarning("Changng to vbox %s", name() );
         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::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::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;
     }
 
     qWarning(" New Tab Widget %s", name() );
     /*
      * 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 ) {
         qWarning("Widget is %s", (*it).name.latin1() );
         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;
     }
 
     qWarning("new HBox %s", name() );
     m_hbox = new QHBox( this );
     commonChangeBox();
 }
 
 void OSplitter::changeVBox() {
     if (m_hbox ) {
         m_hbox->setGeometry( frameRect() );
         return;
     }
 
     qWarning("New VBOX %s", name() );
     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() {
     qWarning(" Name of Splitters is %s", name() );
 
     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 );
         qWarning("Adding to box %s", (*it).name.latin1() );
         addToBox( (*it) );
     }
     for ( OSplitter* split = m_splitter.first(); split; split = m_splitter.next() ) {
         /* tell them the world had changed */
         split->setTabWidget( 0 );
         Opie::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 {
         qWarning(" setting Box geometry for %s", name() );
         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
 
 /**
  *  @internal
  */
 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;
 }
diff --git a/libopie/big-screen/osplitter.h b/libopie/big-screen/osplitter.h
index 33a085f..61a247b 100644
--- a/libopie/big-screen/osplitter.h
+++ b/libopie/big-screen/osplitter.h
@@ -1,145 +1,146 @@
 /*
                =.            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.
 
 */
 
 #ifndef OPIE_SPLITTER_H
 #define OPIE_SPLITTER_H
 
 #include <qstring.h>
 
 #include <qframe.h>
 #include <qvaluelist.h>
 #include <qlist.h>
 
 #include "obigscreen_p.h"
 
 /* forward declarations */
 class OTabWidget;
 class QHBox;
 //template class QValueList<Opie::OSplitterContainer>;
 
 /*
  * TODO
  * -check API docu
  * -one more example
  * -allow inserting at a position
  */
 
 /**
  *
  * If you've widgets that could be placed side by side but you think
  * on small resolutions is not enough place but it would really make sense
  * on bigger resolutions this class will help you.
  * You can add as many widgets you want to it. Set a poliy on which width/height it
  * should switch the layout.
  * You can either say to place widgets vertical or horizontal.
  * This class uses QHBox, QVBox and QTAbWidget internally.
  * OSplitter takes ownership of the widgets
  *
  * @since 1.2
  *
  * @short a small dynamically changing its layout to store two or more widgets side by side
  * @version 0.1
  * @author zecke
  */
 class OSplitter : public QFrame{
     Q_OBJECT
 public:
     typedef QValueList<Opie::OSplitterContainer> ContainerList;
     OSplitter( Qt::Orientation = Horizontal,  QWidget *parent = 0,
                const char* name = 0, WFlags fl = 0 );
     ~OSplitter();
 
     void setLabel( const QString& name );
     void setIconName( const QString& name );
     QString label()const;
     QString iconName()const;
 
     void setSizeChange( int width_height );
 
     void addWidget( OSplitter* splitter );
     void addWidget( QWidget* wid, const QString& icon, const QString& label );
     void removeWidget( QWidget* );
     void removeWidget( OSplitter* );
 
     void setCurrentWidget( QWidget* );
     void setCurrentWidget( const QString& label );
     void setCurrentWidget( int );
     QWidget* currentWidget()const;
 
+
 signals:
     /**
      * Emitted if in tab  and comes directly from the tab widget
      *
      */
     void currentChanged( QWidget* );
 
     /**
      * emitted whenever a border is crossed
      * true if in small screen mode
      * false if in bigscreen
      * this signal is emitted after the layout switch
      * @param b The layout mode
      * @param ori The orientation
      */
     void sizeChanged( bool b, Orientation ori);
 public:
-    QSize sizeHint()const;
-    QSize minimumSizeHint()const;
+//    QSize sizeHint()const;
+//    QSize minimumSizeHint()const;
 
 protected:
     void resizeEvent( QResizeEvent* );
 
 private:
     /* true if OTabMode */
     bool layoutMode()const;
 //    void reparentAll();
     void setTabWidget( OTabWidget*);
     void addToTab( const Opie::OSplitterContainer& );
     void addToBox( const Opie::OSplitterContainer& );
     void removeFromTab( QWidget* );
     void changeTab();
     void changeHBox();
     void changeVBox();
     void commonChangeBox();
     QHBox *m_hbox;
     OTabWidget *m_tabWidget;
     OTabWidget *m_parentTab;
     Orientation m_orient;
     int m_size_policy;
 
     ContainerList m_container;
     QList<OSplitter> m_splitter;
 
     QString m_icon, m_name;
 
     struct Private;
     Private *d;
 };
 
 
 #endif