Changeset 102

Timestamp:

Jul 24, 2006, 11:11:03 PM (19 years ago)

Author:

dmik

Message:

Widgets: Improved min/max/fullscreen handling:

• Layout management now works correctly when the window is minimized;
• Fixed duplicate WindowStateChange events;
• WindowMinimized, WindowMaximized, WindowFullScreen are mutually exclusive (note: this fetaure is experimental, since it is partly incompatible with the weird non-exclusive Qt behavior on other platforms).

Location:

trunk

Files:

• include/qwidget.h (modified) (1 diff)
• src/kernel/qapplication_pm.cpp (modified) (7 diffs)
• src/kernel/qwidget.cpp (modified) (3 diffs)
• src/kernel/qwidget_pm.cpp (modified) (5 diffs)

trunk/include/qwidget.h

@@ -985 +985 @@
     HSWITCH  swEntry;                           // window list entry handle
     HPOINTER pmIcon;                            // internal OS/2 icon
+    uint     in_sendWindowState : 1;            // used by QWidget::setWindowState()
+    uint     reserved : 7;                      // reserved for future binary compatibility
 #endif
     QRect    normalGeometry;                    // used by showMin/maximized/FullScreen

trunk/src/kernel/qapplication_pm.cpp

@@ -326 +326 @@
     void        markFrameStrutDirty()   { QWidget::fstrut_dirty = 1; }
 #endif
+    void        updateFrameStrut()      { QWidget::updateFrameStrut(); }
     bool        translateMouseEvent( const QMSG &qmsg );
     bool        translateKeyEvent( const QMSG &qmsg, bool grab );
@@ -1362 +1363 @@
 //#endif
 
-        case WM_MINMAXFRAME: {
-            bool window_state_change = FALSE;
-            PSWP pswp = (PSWP) mp1;
-            if ( pswp->fl & SWP_MAXIMIZE ) {
-                window_state_change = TRUE;
-                widget->setWState( Qt::WState_Maximized );
-                if ( widget->isMinimized() ) {
-                    widget->clearWState( Qt::WState_Minimized );
-                    widget->showChildren( TRUE );
-                    QShowEvent e;
-                    qt_sendSpontaneousEvent( widget, &e );
-                }
-            } else if ( pswp->fl & SWP_MINIMIZE ) {
-                window_state_change = TRUE;
-                widget->setWState( Qt::WState_Minimized );
-                if ( widget->isVisible() ) {
-                    QHideEvent e;
-                    qt_sendSpontaneousEvent( widget, &e );
-                    widget->hideChildren( TRUE );
-                }
-            } else if ( pswp->fl & SWP_RESTORE ) {
-                window_state_change = TRUE;
-                if ( widget->isMinimized() ) {
-                    widget->clearWState( Qt::WState_Minimized );
-                    widget->showChildren( TRUE );
-                    QShowEvent e;
-                    qt_sendSpontaneousEvent( widget, &e );
-                } else {
-                    widget->clearWState( Qt::WState_Maximized );
-                }
-            }
-            if ( window_state_change ) {
-                QEvent e( QEvent::WindowStateChange );
-                qt_sendSpontaneousEvent( widget, &e );
-            }
-            result = FALSE;
-            break;
-        }
-
 /// @todo (dmik) later
 //      case WM_SETTINGCHANGE:
@@ -1790 +1752 @@
                 }
             }
+            if ( (swp.fl & SWP_RESTORE) &&
+                 !(swp.fl & (SWP_MOVE | SWP_SIZE)) ) {
+                QRect r = widget->top()->normalGeometry;
+                if ( r.isValid() ) {
+                    // store normal geometry in window words
+                    USHORT x = r.x();
+                    USHORT y = r.y();
+                    USHORT w = r.width();
+                    USHORT h = r.height();
+                    // flip y coordinate 
+                    y = QApplication::desktop()->height() - (y + h);
+                    WinSetWindowUShort( hwnd, QWS_XRESTORE, x );
+                    WinSetWindowUShort( hwnd, QWS_YRESTORE, y );
+                    WinSetWindowUShort( hwnd, QWS_CXRESTORE, w );
+                    WinSetWindowUShort( hwnd, QWS_CYRESTORE, h );
+                    widget->top()->normalGeometry.setWidth( 0 );
+                }
+            }
             if ( swp.fl & (SWP_ACTIVATE | SWP_ZORDER) ) {
                 // get the modal widget that made this window blocked
@@ -1853 +1833 @@
                 while ( (popup=QApplication::activePopupWidget()) && maxiter-- )
                     popup->close();
+            }
+            break;
+        }
+
+        case WM_WINDOWPOSCHANGED: {
+            // We detect spontaneous min/max/restore events here instead of
+            // WM_MINMAXFRAME, because WM_MINMAXFRAME is a pre-process message
+            // (i.e. no actual changes have been made) We need actual changes
+            // in order to update the frame strut and send WindowStateChange. 
+            result = TRUE;
+            rc = QtOldFrameProc( hwnd, msg, mp1, mp2 );
+            ULONG awp = LONGFROMMP( mp2 );
+            bool window_state_change = FALSE;
+            if ( awp & AWP_MAXIMIZED ) {
+                window_state_change = TRUE;
+                widget->setWState( Qt::WState_Maximized );
+                widget->clearWState( Qt::WState_FullScreen );
+                if ( widget->isMinimized() ) {
+                    widget->clearWState( Qt::WState_Minimized );
+                    widget->showChildren( TRUE );
+                    QShowEvent e;
+                    qt_sendSpontaneousEvent( widget, &e );
+                }
+            } else if ( awp & AWP_MINIMIZED ) {
+                window_state_change = TRUE;
+                widget->setWState( Qt::WState_Minimized );
+                widget->clearWState( Qt::WState_Maximized );
+                widget->clearWState( Qt::WState_FullScreen );
+                if ( widget->isVisible() ) {
+                    QHideEvent e;
+                    qt_sendSpontaneousEvent( widget, &e );
+                    widget->hideChildren( TRUE );
+                }
+            } else if ( awp & AWP_RESTORED ) {
+                window_state_change = TRUE;
+                if ( widget->isMinimized() ) {
+                    widget->showChildren( TRUE );
+                    QShowEvent e;
+                    qt_sendSpontaneousEvent( widget, &e );
+                }
+                widget->clearWState( Qt::WState_Minimized );
+                widget->clearWState( Qt::WState_Maximized );
+            }
+            if ( window_state_change ) {
+                widget->updateFrameStrut();
+                if ( !widget->top()->in_sendWindowState ) {
+                    // send WindowStateChange event if this message is NOT
+                    // originated from QWidget::setWindowState().
+                    QEvent e( QEvent::WindowStateChange );
+                    qt_sendSpontaneousEvent( widget, &e );
+                }
             }
             break;
@@ -3258 +3289 @@
         QSize newSize( SHORT1FROMMP(qmsg.mp2), SHORT2FROMMP(qmsg.mp2) );
         if ( qmsg.msg == WM_SIZE && size() != newSize ) {
-            if ( !(fStyle & WS_MINIMIZED) )
-                crect.setSize( newSize );
+            crect.setSize( newSize );
         }
         return TRUE;
@@ -3269 +3299 @@
         QSize newSize( SHORT1FROMMP(qmsg.mp2), SHORT2FROMMP(qmsg.mp2) );
         cr.setSize( newSize );
-        if ( !(fStyle & WS_MINIMIZED) )
-            crect = cr;
+        crect = cr;
         if ( isTopLevel() ) {                   // update caption/icon text
             createTLExtra();
@@ -3284 +3313 @@
             }
         }
-        if ( !(fStyle & WS_MINIMIZED) && oldSize != newSize) {
+        if ( oldSize != newSize) {
 #if !defined (QT_PM_NO_WIDGETMASK)
             // Spontaneous (external to Qt) WM_SIZE messages should occur only

trunk/src/kernel/qwidget.cpp

@@ -1471 +1471 @@
     if (isMinimized()) return;
 
+#ifdef Q_WS_PM
+    setWindowState(WindowMinimized);
+#else
     setWindowState((windowState() & ~WindowActive) | WindowMinimized);
+#endif    
     show();
     if (!isTopLevel())
@@ -1587 +1591 @@
     if (isFullScreen()) return;
 
+#ifdef Q_WS_PM
+    setWindowState(WindowFullScreen);
+#else
     setWindowState(windowState() | WindowFullScreen);
+#endif    
     show();
     if (!isTopLevel())
@@ -1610 +1618 @@
     if (isMaximized()) return;
 
+#ifdef Q_WS_PM
+    setWindowState(WindowMaximized);
+#else
     setWindowState((windowState() & ~WindowMinimized) | WindowMaximized);
+#endif    
     show();
     if (!isTopLevel())

trunk/src/kernel/qwidget_pm.cpp

@@ -1577 +1577 @@
 }
 
-void QWidget::setWindowState(uint newstate)
+void QWidget::setWindowState( uint newstate )
 {
     uint oldstate = windowState();
 
-    //@@TODO (dmik): should we deactivate the widget when no WindowActive
-    //  is specified? Guess no, because such behavior can be seen in Win32
-    //  (the only exception is when WindowMinimized is set w/o WindowActive).
-    //  As well as nothing is done in Win32 when only WindowActive is
-    //  specified.
-    ULONG fl = (newstate & WindowActive) ?
-        SWP_ACTIVATE :
-        // mimic Win32 behavior
-        (newstate & WindowMinimized) ? SWP_DEACTIVATE :
-        // mimic Win32 behavior
-        ((oldstate & WindowMinimized) &&
-            (newstate & WindowMaximized)) ? SWP_ACTIVATE :
-        0;
-
-    if (isTopLevel()) {
+    if ( newstate == oldstate )
+        return;
+    
+    ULONG fl = (newstate & WindowActive) ? SWP_ACTIVATE : 0;
+
+    /// @todo (dmik):
+    //  Ugrh. I cannot see any good logic in those weird window state
+    //  manipulations (see setWindowState() dox, original showMinimized(),
+    //  showMaximized(). showFullScreen() and showNormal() implementations).
+    //  So, treat all of three flags as exclusive for now (note: the below
+    //  code relies on this).
+    uint op = 0;
+    if ( newstate & WindowFullScreen ) op = WindowFullScreen;
+    else if ( newstate & WindowMinimized ) op = WindowMinimized;
+    else if ( newstate & WindowMaximized ) op = WindowMaximized;
+
+    if ( op == WindowMinimized )
+        fl = SWP_DEACTIVATE;
+    
+    if ( isTopLevel() && isVisible() ) {
         WId id = winFId();
         QTLWExtra *top = topData();
 
-        if ((oldstate & WindowMaximized) != (newstate & WindowMaximized)) {
-            if (isVisible() && !(newstate & WindowMinimized)) {
-                ULONG f = (newstate & WindowMaximized) ? SWP_MAXIMIZE : SWP_RESTORE;
-                WinSetWindowPos( id, 0, 0, 0, 0, 0, fl | f );
-                QRect r = topData()->normalGeometry;
-                if (!(newstate & WindowMaximized) && r.width() >= 0) {
-                    if (pos() != r.topLeft() || size() !=r.size()) {
-                        top->normalGeometry = QRect( 0, 0, -1, -1 );
-                        r.addCoords( top->fleft, top->ftop, top->fleft, top->ftop);
-                        setGeometry( r );
-                    }
-                }
-            }
-        }
-
-        if ((oldstate & WindowFullScreen) != (newstate & WindowFullScreen)) {
-            if (newstate & WindowFullScreen) {
-                if ( top->normalGeometry.width() < 0 && !(oldstate & WindowMaximized) )
-                    top->normalGeometry = QRect( pos(), size() );
-                QRect r = QApplication::desktop()->screenGeometry(this);
-                r.addCoords( -top->fleft, -top->fbottom, top->fright, top->ftop );
-                WinSetWindowPos(
-                        id, 0, r.x(), r.y(), r.width(), r.height(),
-                        fl | SWP_SIZE | SWP_MOVE
-                );
-//@@TODO (dmik): we do not need to call updateFrameStrut() because the frame
-//  is not changed, but who will update our crect?..
-//              updateFrameStrut();
-            } else {
-                ULONG f = fl;
-                // the widget is still maximized
-                if ( newstate & WindowMaximized ) {
-                    if (isVisible())
-                        f |= SWP_MAXIMIZE;
+        // set flag for the WM_WINDOWPOSCHANGED handler in QtFrameProc
+        top->in_sendWindowState = 1;
+        
+        if ( op == WindowMinimized || op == WindowMaximized ) {
+            fl |= op == WindowMinimized ? SWP_MINIMIZE : SWP_MAXIMIZE;
+            WinSetWindowPos( id, 0, 0, 0, 0, 0, fl );
+        } else if ( op == WindowFullScreen ) {
+            if ( !(oldstate & (WindowMinimized | WindowMaximized)) ) {
+                top->normalGeometry = frameGeometry();
+            } else {
+                // extract normal geometry from window words
+                USHORT x = WinQueryWindowUShort( id, QWS_XRESTORE );
+                USHORT y = WinQueryWindowUShort( id, QWS_YRESTORE );
+                USHORT w = WinQueryWindowUShort( id, QWS_CXRESTORE );
+                USHORT h = WinQueryWindowUShort( id, QWS_CYRESTORE );
+                // restore first to update the frame strut
+                if ( oldstate & WindowMinimized )
+                    WinSetWindowPos( id, 0, 0, 0, 0, 0, SWP_RESTORE );
+                // flip y coordinate 
+                y = QApplication::desktop()->height() - (y + h);
+                top->normalGeometry = QRect( x, y, w, h );
+            }
+            QRect r = QApplication::desktop()->screenGeometry( this );
+            r.addCoords( -top->fleft, -top->fbottom, top->fright, top->ftop );
+            WinSetWindowPos( id, 0, r.x(), r.y(), r.width(), r.height(),
+                             fl | SWP_SIZE | SWP_MOVE );
+        } else {
+            if ( oldstate & WindowFullScreen ) {
+                QRect r = top->normalGeometry;
+                if ( r != frameGeometry() ) {
+                    r.addCoords( top->fleft, top->ftop, -top->fright, -top->fbottom );
+                    setGeometry( r );
                 }
-                if ( f ) WinSetWindowPos( id, 0, 0, 0, 0, 0, f );
-                if ( !(newstate & WindowMaximized) ) {
-                    QRect r = top->normalGeometry;
-                    top->normalGeometry = QRect( 0, 0, -1, -1 );
-                    r.addCoords( top->fleft, top->ftop, top->fleft, top->ftop);
-                    setGeometry( r );
-                }
-//@@TODO (dmik): we do not need to call updateFrameStrut() because the frame
-//  is not changed, but who will update our crect?..
-//              else {
-//                    updateFrameStrut();
-//                }
-            }
-        }
-
-        if ((oldstate & WindowMinimized) != (newstate & WindowMinimized)) {
-            if (isVisible()) {
-                ULONG f =
-                    (newstate & WindowMinimized) ? SWP_MINIMIZE :
-                    (newstate & WindowMaximized) ? SWP_MAXIMIZE : SWP_RESTORE;
-                WinSetWindowPos( id, 0, 0, 0, 0, 0, fl | f );
+                top->normalGeometry.setWidth( 0 );
+            } else {
+                QRect r = top->normalGeometry;
+                if ( r.isValid() ) {
+                    // store normal geometry in window words
+                    USHORT x = r.x();
+                    USHORT y = r.y();
+                    USHORT w = r.width();
+                    USHORT h = r.height();
+                    // flip y coordinate 
+                    y = QApplication::desktop()->height() - (y + h);
+                    WinSetWindowUShort( id, QWS_XRESTORE, x );
+                    WinSetWindowUShort( id, QWS_YRESTORE, y );
+                    WinSetWindowUShort( id, QWS_CXRESTORE, w );
+                    WinSetWindowUShort( id, QWS_CYRESTORE, h );
+                    top->normalGeometry.setWidth( 0 );
+                }
+                WinSetWindowPos( id, 0, 0, 0, 0, 0, fl | SWP_RESTORE );
             }
-        }
+        }
+        
+        top->in_sendWindowState = 0;
     }
 
     widget_state &= ~(WState_Minimized | WState_Maximized | WState_FullScreen);
     if (newstate & WindowMinimized)
-        widget_state |= WState_Minimized;
+        widget_state |= WState_Minimized;
     if (newstate & WindowMaximized)
-        widget_state |= WState_Maximized;
+        widget_state |= WState_Maximized;
     if (newstate & WindowFullScreen)
-        widget_state |= WState_FullScreen;
-
+        widget_state |= WState_FullScreen;
+        
     QEvent e(QEvent::WindowStateChange);
     QApplication::sendEvent(this, &e);
@@ -1716 +1718 @@
     ULONG fl = 0;
     if ( isTopLevel() ) {
-        // we do this check here bevause setWindowState() does not actually
+        // we do this check here because setWindowState() does not actually
         // change the window state when the window is not visible, assuming
         // it will be done here.
@@ -1723 +1725 @@
         else if (testWState(WState_Maximized))
             fl |= SWP_MAXIMIZE;
+        else if (testWState(WState_FullScreen)) {
+            QTLWExtra *top = topData();
+            topData()->normalGeometry = QRect( pos(), size() );
+            QRect r = QApplication::desktop()->screenGeometry( this );
+            r.addCoords( -top->fleft, -top->fbottom, top->fright, top->ftop );
+            WinSetWindowPos( winFId(), 0, r.x(), r.y(), r.width(), r.height(),
+                             fl | SWP_SIZE | SWP_MOVE );
+        }
 
         if (
@@ -1830 +1840 @@
     clearWState(WState_Maximized);
     clearWState(WState_FullScreen);
-    if (isTopLevel())
-        topData()->normalGeometry = QRect(0, 0, -1, -1);
     if ( testWState(WState_ConfigPending) ) {   // processing config event
         qPMRequestConfig( winId(), isMove ? 2 : 1, x, y, w, h );
@@ -2557 +2565 @@
     extra->topextra->swEntry = 0;
     extra->topextra->pmIcon = 0;
+    extra->topextra->in_sendWindowState = 0;
 }