ok. next variant of fullscreen toggeling. It seems, that now within all

circumstances the viewer get fullscreen back and we don't run into an
endless loop.

3 files changed, 19 insertions, 40 deletions

diff --git a/noncore/graphics/opie-eye/gui/imageview.cpp b/noncore/graphics/opie-eye/gui/imageview.cpp
index 5b00dea..03f3c1c 100644
--- a/noncore/graphics/opie-eye/gui/imageview.cpp
+++ b/noncore/graphics/opie-eye/gui/imageview.cpp
@@ -1,44 +1,44 @@
 #include "imageview.h"
 
 #include <opie2/odebug.h>
 #include <opie2/oconfig.h>
 #include <opie2/okeyconfigwidget.h>
 
 #include <qpe/resource.h>
 #include <qpe/qpeapplication.h>
 #include <qpopupmenu.h>
 
 using namespace Opie::Core;
 
 ImageView::ImageView(Opie::Core::OConfig *cfg, QWidget* parent, const char* name, WFlags fl )
     : Opie::MM::OImageScrollView(parent,name,fl)
 {
     m_viewManager = 0;
-    m_focus_out = false;
-    block_next_focus = true;
+    focus_in_count = 0;
     m_cfg = cfg;
     m_isFullScreen = false;
+    m_ignore_next_in = false;
     QPEApplication::setStylusOperation(viewport(),QPEApplication::RightOnHold);
     initKeys();
 }
 
 ImageView::~ImageView()
 {
     odebug << "Delete Imageview" << oendl;
     if (m_viewManager) {
         delete m_viewManager;
     }
 }
 
 Opie::Core::OKeyConfigManager* ImageView::manager()
 {
     if (!m_viewManager) {
         initKeys();
     }
     return m_viewManager;
 }
 
 void ImageView::initKeys()
 {
     odebug << "init imageview keys" << oendl;
     if (!m_cfg) {
@@ -86,100 +86,83 @@ void ImageView::initKeys()
                                                 Opie::Core::OKeyPair(Qt::Key_T,0),
                                                 this, SIGNAL(toggleZoomer())));
     m_viewManager->handleWidget( this );
     m_viewManager->load();
 }
 
 void ImageView::keyReleaseEvent(QKeyEvent * e)
 {
     if (!e || e->state()!=0) {
         return;
     }
     if (e->key()==Qt::Key_Escape && fullScreen()) emit hideMe();
 }
 
 void ImageView::slotShowImageInfo()
 {
     emit dispImageInfo(m_lastName);
 }
 
 void ImageView::contentsMousePressEvent ( QMouseEvent * e)
 {
     if (e->button()==1) {
         return OImageScrollView::contentsMousePressEvent(e);
     }
-//    if (!fullScreen()) return;
     odebug << "Popup " << oendl;
     QPopupMenu *m = new QPopupMenu(0);
     if (!m) return;
     bool old = fullScreen();
     m->insertItem(tr("Toggle fullscreen"),this, SIGNAL(toggleFullScreen()));
     if (fullScreen()) {
         m->insertSeparator();
         m->insertItem(tr("Previous image"),this,SIGNAL(dispPrev()));
         m->insertItem(tr("Next image"),this,SIGNAL(dispNext()));
         m->insertSeparator();
         m->insertItem(tr("Toggle autoscale"),this, SIGNAL(toggleAutoscale()));
         m->insertItem(tr("Toggle autorotate"),this, SIGNAL(toggleAutorotate()));
         m->insertItem(tr("Toggle thumbnail"),this, SIGNAL(toggleZoomer()));
     }
     m->setFocus();
     m->exec( QPoint( QCursor::pos().x(), QCursor::pos().y()) );
     delete m;
-    /* if we were fullScreen() and must overlap the taskbar again */
-    if (fullScreen() && old) {
-          enableFullscreen();
-    }
 }
 
 void ImageView::setFullScreen(bool how)
 {
     m_isFullScreen = how;
 }
 
 void ImageView::focusInEvent(QFocusEvent *)
 {
       // Always do it here, no matter the size.
-    odebug << "Focus in" << oendl;
-}
-
-void ImageView::focusOutEvent(QFocusEvent *)
-{
-    odebug << "Focus out" << oendl;
+    odebug << "Focus in (view)" << oendl;
+    //if (fullScreen()) parentWidget()->showNormal();
+    if (m_ignore_next_in){m_ignore_next_in=false;return;}
+    if (fullScreen()) enableFullscreen();
 }
 
 void ImageView::enableFullscreen()
 {
       // This call is needed because showFullScreen won't work
       // correctly if the widget already considers itself to be fullscreen.
+      if (!fullScreen()) return;
+      if (m_ignore_next_in) {m_ignore_next_in = false;return;}
+
       setUpdatesEnabled(false);
-      odebug << "showNormal();" << oendl;
       parentWidget()->showNormal();
-      odebug << "showNormal(); done " << oendl;
       // This is needed because showNormal() forcefully changes the window
       // style to WSTyle_TopLevel.
-      odebug << " reparent(0, WStyle_Customize | WStyle_NoBorder, QPoint(0,0));" << oendl;
       parentWidget()->reparent(0, WStyle_Customize | WStyle_NoBorder, QPoint(0,0));
-      odebug << " reparent(0, WStyle_Customize | WStyle_NoBorder, QPoint(0,0)); done" << oendl;
       // Enable fullscreen.
-      odebug << "showFullScreen();" << oendl;
+      /* this is the trick - I don't now why, but after a showFullScreen QTE toggles the focus
+       * so we must block it here! */
+      m_ignore_next_in = true;
       parentWidget()->showFullScreen();
-      odebug << "showFullScreen(); done" << oendl;
       setUpdatesEnabled(true);
 }
 
-void ImageWidget::show()
-{
-    QWidget::show();
-}
-
-void ImageWidget::hide()
-{
-    QWidget::hide();
-}
-
 ImageWidget::ImageWidget(QWidget * parent, const char * name, WFlags f)
     : QWidget(parent,name,f)
 {
-      // Make sure size is correct
-      setFixedSize(qApp->desktop()->size());
+    // Make sure size is correct
+    setFixedSize(qApp->desktop()->size());
 }
diff --git a/noncore/graphics/opie-eye/gui/imageview.h b/noncore/graphics/opie-eye/gui/imageview.h
index 5f15bc9..f3c37b5 100644
--- a/noncore/graphics/opie-eye/gui/imageview.h
+++ b/noncore/graphics/opie-eye/gui/imageview.h
@@ -10,71 +10,68 @@ namespace Opie {
         class OConfig;
         class OKeyConfigManager;
     }
 }
 
 class ImageView:public Opie::MM::OImageScrollView
 {
     Q_OBJECT
 
     enum ActionIds {
         ViewInfo,
         FullScreen,
         ShowNext,
         ShowPrevious,
         Zoomer,
         Autorotate,
         Autoscale
     };
 
 public:
     ImageView(Opie::Core::OConfig *cfg, QWidget* parent, const char* name = 0, WFlags fl = 0 );
     virtual ~ImageView();
     Opie::Core::OKeyConfigManager* manager();
     void setFullScreen(bool how);
-    virtual void enableFullscreen();
     bool fullScreen(){return m_isFullScreen;}
+    virtual void enableFullscreen();
 
 signals:
     void dispImageInfo(const QString&);
     void dispNext();
     void dispPrev();
     void toggleFullScreen();
     void hideMe();
     void toggleZoomer();
     void toggleAutoscale();
     void toggleAutorotate();
 
 protected:
     Opie::Core::OConfig * m_cfg;
     Opie::Core::OKeyConfigManager*m_viewManager;
     void initKeys();
     bool m_isFullScreen:1;
-    bool m_focus_out:1;
-    bool block_next_focus:1;
-
+    bool m_ignore_next_in:1;
+    int focus_in_count;
     virtual void focusInEvent ( QFocusEvent * );
-    virtual void focusOutEvent ( QFocusEvent * );
+
 
 protected slots:
     virtual void slotShowImageInfo();
     virtual void keyReleaseEvent(QKeyEvent * e);
     virtual void contentsMousePressEvent ( QMouseEvent * e);
 };
 
 class ImageWidget:public QWidget
 {
     Q_OBJECT
 public:
     ImageWidget(QWidget * parent=0, const char * name=0, WFlags f = WStyle_Customize | WStyle_NoBorder);
     virtual ~ImageWidget(){};
 
 protected:
 
 public slots:
-    virtual void show();
-    virtual void hide();
 
 protected slots:
 };
 
 #endif
diff --git a/noncore/graphics/opie-eye/gui/mainwindow.cpp b/noncore/graphics/opie-eye/gui/mainwindow.cpp
index fa1680c..cdaf34c 100644
--- a/noncore/graphics/opie-eye/gui/mainwindow.cpp
+++ b/noncore/graphics/opie-eye/gui/mainwindow.cpp
@@ -377,50 +377,49 @@ void PMainWindow::slotShowInfo( const QString& inf ) {
     m_info->setPath( inf );
     if (m_stack->mode() == Opie::Ui::OWidgetStack::SmallScreen) {
         prevButton->hide();
         nextButton->hide();
         upButton->hide();
         fsButton->hide();
         viewModeButton->hide();
     }
     m_stack->raiseWidget( ImageInfo );
 }
 
 void PMainWindow::slotDisplay( const QString& inf ) {
     if ( !m_disp ) {
         initDisp();
     }
     m_disp->setImage( inf );
     if (m_stack->mode() == Opie::Ui::OWidgetStack::SmallScreen) {
         prevButton->show();
         nextButton->show();
         upButton->hide();
         fsButton->hide();
         viewModeButton->hide();
     }
     if (m_disp->fullScreen()) {
-//        tFrame->showFullScreen();
-        m_disp->enableFullscreen();
+        tFrame->show();//FullScreen();
     } else {
         m_stack->raiseWidget( ImageDisplay );
     }
 }
 
 void PMainWindow::slotReturn() {
     raiseIconView();
 }
 
 
 void PMainWindow::closeEvent( QCloseEvent* ev ) {
     /*
      * return from view
      * or properly quit
      */
     if ( m_stack->visibleWidget() == m_info ||
          m_stack->visibleWidget() == m_disp ) {
         ev->ignore();
         raiseIconView();
         return;
     }
     if (m_disp && m_disp->fullScreen()) {
         /* otherwise opie-eye crashes in bigscreen mode! */
         m_disp->reparent(0,QPoint(0,0));