-When going back from BigScreen to SmallScreen we resize the widgetstack,

 show it and raise the 'main widget'

This should fix all bugs alwin spotted while deploying OWidgetStack
on Opie-Eye

1 files changed, 6 insertions, 1 deletions

diff --git a/libopie2/opieui/big-screen/owidgetstack.cpp b/libopie2/opieui/big-screen/owidgetstack.cpp
index 00194b4..ac46cca 100644
--- a/libopie2/opieui/big-screen/owidgetstack.cpp
+++ b/libopie2/opieui/big-screen/owidgetstack.cpp
@@ -216,225 +216,230 @@ QSizeHint OWidgetStack::minimumSizeHint()const {
  */
 QWidget* OWidgetStack::widget( int id) const {
     return m_list[id];
 }
 
 /**
  * Tries to find the assigned id for the widget
  * or returns -1 if no widget could be found
  * @param wid The widget to look for
  */
 int OWidgetStack::id( QWidget* wid)const{
     if (m_list.isEmpty() )
         return -1;
 
     QMap<int, QWidget*>::ConstIterator it = m_list.begin();
     for ( ; it != m_list.end(); ++it )
         if ( it.data() == wid )
             break;
 
     /* if not at the end return the key */
     return it == m_list.end() ? -1 : it.key();
 }
 
 
 /**
  * This function returns the currently visible
  * widget. In BigScreen mode the mainwindow
  * is returned
  */
 QWidget* OWidgetStack::visibleWidget()const {
     if (m_mode == SmallScreen )
         return m_stack->visibleWidget();
     else
         return m_mWidget;
 
 }
 
 /**
  * This method raises the widget wit the specefic id.
  * Note that in BigScreen mode the widget is made visible
  * but the other ( previous) visible widget(s) will not
  * be made invisible. If you need this use hideWidget().
  *
  * @param id Raise the widget with id
  */
 void OWidgetStack::raiseWidget( int id) {
     return raiseWidget( widget( id ) );
 }
 
 /**
  * This is an overloaded function and only differs in its parameters.
  * @see raiseWidget( int )
  */
 void OWidgetStack::raiseWidget( QWidget* wid) {
     m_last = wid;
     if (m_mode == SmallScreen )
         m_stack->raiseWidget( wid );
     else {
         int ide;
         emit aboutToShow( wid );
         /* if someone is connected and the widget is actually available */
         if ( receivers( SIGNAL(aboutToShow(int) ) ) &&
              ( (ide = id( wid ) ) != -1 ) )
             emit aboutToShow( ide );
 
         /* ### FIXME PLACE THE WIDGET right */
         wid->show();
     }
 }
 
 /**
  * This will hide the currently visible widget
  * and raise the widget specified by the parameter.
  * Note that this method does not use visibleWIdget but remembers
  * the last raisedWidget
  */
 void OWidgetStack::hideWidget( int id) {
     /* hiding our main widget wouldn't be smart */
     if ( m_mode == BigScreen && m_last != m_mWidget )
         m_last->hide();
     raiseWidget( id );
 }
 
 /**
  * This is overloaded and only differs in the parameters
  * it takes.
  */
 void OWidgetStack::hideWidget( QWidget* wid) {
     /* still not smart */
     if ( m_mode == BigScreen && m_last != m_mWidget )
         m_last->hide();
 
     raiseWidget( wid );
 }
 
 
-bool OWidgetStack::eventFilter( QObject* obj, QEvent* e) {
+bool OWidgetStack::eventFilter( QObject*, QEvent* e) {
     if ( e->type() == QEvent::Resize && !m_forced ) {
         QResizeEvent *res = static_cast<QResizeEvent*>( e );
         QSize size = res->size();
         if ( size.width() >= mode_size )
             switchTop();
         else
             switchStack();
     }
     return false;
 }
 
 
 /**
  * @internal_resons
  */
 void OWidgetStack::resizeEvent( QResizeEvent* ev ) {
     QFrame::resizeEvent( ev );
     if (m_mode == SmallScreen )
         m_stack->setGeometry( frameRect() );
     else
         if (m_mWidget )
             m_mWidget->setGeometry( frameRect() );
 
 }
 
 /**
  * setMainWindow gives the OWidgetStack a hint which
  * window should always stay inside the stack.
  * Normally the first added widget is considered to be
  * the mainwindow but you can change this with this
  * function.
  * If in BigScreen mode the current mainwindow will be reparented
  * and hidden. The position will be taken by the new one.
  * If the old MainWindow was hidden the new window will
  * also be hidden. If the window was visible the new mainwindow
  * will be made visible too and the old one hidden. If there
  * was no mainwindow it will be hidden as well.
  *
  * @param wid The new mainwindow
  */
 void OWidgetStack::setMainWindow( QWidget* wid ) {
     if (m_mode == BigScreen ) {
         bool wasVisible = false;
         if (m_mWidget ) {
             wasVisible = !m_mWidget->isHidden();
             /* hidden by default */
             m_mWidget->reparent(0, WType_TopLevel, QPoint(10, 10) );
         }
         wid->reparent(this, 0, frameRect().topLeft() );
 
         if (wasVisible)
             wid->show();
     }
 
     m_mWidget = wid;
 }
 
 /**
  * this is an overloaded member and only differs
  * in the type of arguments.
  * @see setMainWindow(QWidget*)
  */
 void OWidgetStack::setMainWindow( int id) {
     setMainWindow( widget( id ) );
 }
 
 
 /*
  * this function switches to a stack ;)
  */
 void OWidgetStack::switchStack() {
     if (m_stack ) {
         m_stack->setGeometry( frameRect() );
         return;
     }
 
     m_mode = SmallScreen;
     m_stack = new QWidgetStack(this);
+    m_stack->setGeometry( frameRect() );
+    m_stack->show();
 
     connect(m_stack, SIGNAL(aboutToShow(QWidget*) ),
             this, SIGNAL(aboutToShow(QWidget*) ) );
     connect(m_stack, SIGNAL(aboutToShow(int) ),
             this, SIGNAL(aboutToShow(int) ) );
 
     /* now reparent the widgets... luckily QWidgetSatck does most of the work */
     if (m_list.isEmpty() )
         return;
 
     QMap<int, QWidget*>::Iterator it = m_list.begin();
     for ( ; it != m_list.end(); ++it )
         m_stack->addWidget( it.data(), it.key() );
 
+    if ( m_mWidget )
+        m_stack->raiseWidget( m_mWidget );
+
 
 }
 
 /*
  * we will switch to top level mode
  * reparent the list of widgets and then delete the stack
  */
 void OWidgetStack::switchTop() {
     m_mode = BigScreen;
     /* this works because it is guaranteed that switchStack was called at least once*/
     if (!m_stack && m_mWidget) {
         m_mWidget->setGeometry( frameRect() );
         return;
     }else if (!m_stack)
         return;
 
     if (!m_list.isEmpty() ) {
         QMap<int, QWidget*>::Iterator it = m_list.begin();
         for ( ; it != m_list.end(); ++it ) {
             /* better than reparenting twice */
             if ( it.data() == m_mWidget ) {
                 m_mWidget->reparent(this, 0, frameRect().topLeft() );
                 m_mWidget->setGeometry( frameRect() );
                 m_mWidget->show();
             }else
                 /* ### FIXME we need to place the widget better */
                 it.data()->reparent(0, WType_TopLevel, QPoint(10, 10) );
         }
     }
 
     delete m_stack;
     m_stack = 0;
 }
 
 }
 }