convert WINDOWSTATE_STATE to scoped enum

Change-Id: I5448c7e46042850f18970c7613ec5a37df57bce7

9 files changed, 70 insertions, 69 deletions

diff --git a/vcl/headless/svpframe.cxx b/vcl/headless/svpframe.cxx
index ee6d58891ca6..0b971f4a2a31 100644
--- a/vcl/headless/svpframe.cxx
+++ b/vcl/headless/svpframe.cxx
@@ -340,7 +340,7 @@ void SvpSalFrame::SetWindowState( const SalFrameState *pState )
 
 bool SvpSalFrame::GetWindowState( SalFrameState* pState )
 {
-    pState->mnState = WINDOWSTATE_STATE_NORMAL;
+    pState->mnState = WindowStateState::Normal;
     pState->mnX      = maGeometry.nX;
     pState->mnY      = maGeometry.nY;
     pState->mnWidth  = maGeometry.nWidth;
diff --git a/vcl/inc/salwtype.hxx b/vcl/inc/salwtype.hxx
index 2fffde7c1264..d9c473b32a43 100644
--- a/vcl/inc/salwtype.hxx
+++ b/vcl/inc/salwtype.hxx
@@ -32,6 +32,7 @@ namespace vcl { class Window; }
 class FontSelectPattern;
 enum class InputContextFlags;
 enum class WindowStateMask;
+enum class WindowStateState;
 
 #define SALEVENT_MOUSEMOVE              ((sal_uInt16)1)
 #define SALEVENT_MOUSELEAVE             ((sal_uInt16)2)
@@ -234,7 +235,7 @@ struct SalFrameState
     long            mnMaximizedY;
     long            mnMaximizedWidth;
     long            mnMaximizedHeight;
-    sal_uLong       mnState;
+    WindowStateState mnState;
 };
 
 struct SalInputContext
diff --git a/vcl/osx/salframe.cxx b/vcl/osx/salframe.cxx
index 0d535dc636c9..2e4681508829 100644
--- a/vcl/osx/salframe.cxx
+++ b/vcl/osx/salframe.cxx
@@ -551,7 +551,7 @@ void AquaSalFrame::SetWindowState( const SalFrameState* pState )
     aStateRect = [NSWindow frameRectForContentRect: aStateRect styleMask: mnStyleMask];
 
     [mpNSWindow setFrame: aStateRect display: NO];
-    if( pState->mnState == WINDOWSTATE_STATE_MINIMIZED )
+    if( pState->mnState == WindowStateState::Minimized )
         [mpNSWindow miniaturize: NSApp];
     else if( [mpNSWindow isMiniaturized] )
         [mpNSWindow deminiaturize: NSApp];
@@ -560,7 +560,7 @@ void AquaSalFrame::SetWindowState( const SalFrameState* pState )
        the program specified one), but comes closest since the default behavior is
        "maximized" if the user did not intervene
     */
-    if( pState->mnState == WINDOWSTATE_STATE_MAXIMIZED )
+    if( pState->mnState == WindowStateState::Maximized )
     {
         if(! [mpNSWindow isZoomed])
             [mpNSWindow zoom: NSApp];
@@ -624,11 +624,11 @@ bool AquaSalFrame::GetWindowState( SalFrameState* pState )
     pState->mnHeight    = long(aStateRect.size.height);
 
     if( [mpNSWindow isMiniaturized] )
-        pState->mnState = WINDOWSTATE_STATE_MINIMIZED;
+        pState->mnState = WindowStateState::Minimized;
     else if( ! [mpNSWindow isZoomed] )
-        pState->mnState = WINDOWSTATE_STATE_NORMAL;
+        pState->mnState = WindowStateState::Normal;
     else
-        pState->mnState = WINDOWSTATE_STATE_MAXIMIZED;
+        pState->mnState = WindowStateState::Maximized;
 
     return TRUE;
 }
diff --git a/vcl/source/window/syswin.cxx b/vcl/source/window/syswin.cxx
index 5a6effbadd35..660328b99825 100644
--- a/vcl/source/window/syswin.cxx
+++ b/vcl/source/window/syswin.cxx
@@ -459,13 +459,13 @@ static void ImplWindowStateFromStr(WindowStateData& rData,
     {
         // #94144# allow Minimize again, should be masked out when read from configuration
         // 91625 - ignore Minimize
-        sal_uInt32 nState = (sal_uInt32)aTokenStr.toInt32();
-        //nState &= ~(WINDOWSTATE_STATE_MINIMIZED);
+        WindowStateState nState = (WindowStateState)aTokenStr.toInt32();
+        //nState &= ~(WindowStateState::Minimized);
         rData.SetState( nState );
         nValidMask |= WindowStateMask::State;
     }
     else
-        rData.SetState( 0 );
+        rData.SetState( WindowStateState::NONE );
 
     // read maximized pos/size
     aTokenStr = rStr.getToken(0, ',', nIndex);
@@ -541,7 +541,7 @@ static OString ImplWindowStateToStr(const WindowStateData& rData)
     {
         // #94144# allow Minimize again, should be masked out when read from configuration
         // 91625 - ignore Minimize
-        sal_uInt32 nState = rData.GetState();
+        WindowStateState nState = rData.GetState();
         rStrBuf.append(static_cast<sal_Int32>(nState));
     }
     rStrBuf.append(';');
@@ -631,7 +631,7 @@ void SystemWindow::SetWindowStateData( const WindowStateData& rData )
 
     if ( pWindow->mpWindowImpl->mbFrame )
     {
-        const sal_uInt32 nState     = rData.GetState();
+        const WindowStateState nState = rData.GetState();
         SalFrameState   aState;
         aState.mnMask               = rData.GetMask();
         aState.mnX                  = rData.GetX();
@@ -655,8 +655,8 @@ void SystemWindow::SetWindowStateData( const WindowStateData& rData )
         aState.mnMaximizedHeight    = rData.GetMaximizedHeight();
         // #94144# allow Minimize again, should be masked out when read from configuration
         // 91625 - ignore Minimize
-        //nState &= ~(WINDOWSTATE_STATE_MINIMIZED);
-        aState.mnState  = nState & WINDOWSTATE_STATE_SYSTEMMASK;
+        //nState &= ~(WindowStateState::Minimized);
+        aState.mnState  = nState & WindowStateState::SystemMask;
 
         // normalize window positions onto screen
         ImplMoveToScreen( aState.mnX, aState.mnY, aState.mnWidth, aState.mnHeight, pWindow );
@@ -664,7 +664,7 @@ void SystemWindow::SetWindowStateData( const WindowStateData& rData )
 
         // #96568# avoid having multiple frames at the same screen location
         //  do the check only if not maximized
-        if( !((rData.GetMask() & WindowStateMask::State) && (nState & WINDOWSTATE_STATE_MAXIMIZED)) )
+        if( !((rData.GetMask() & WindowStateMask::State) && (nState & WindowStateState::Maximized)) )
             if( rData.GetMask() & (WindowStateMask::Pos|WindowStateMask::Width|WindowStateMask::Height) )
             {
                 Rectangle aDesktop = GetDesktopRectPixel();
@@ -711,7 +711,7 @@ void SystemWindow::SetWindowStateData( const WindowStateData& rData )
         // do a synchronous resize for layout reasons
         //  but use rData only when the window is not to be maximized (#i38089#)
         //  otherwise we have no useful size information
-        if( (rData.GetMask() & WindowStateMask::State) && (nState & WINDOWSTATE_STATE_MAXIMIZED) )
+        if( (rData.GetMask() & WindowStateMask::State) && (nState & WindowStateState::Maximized) )
         {
             // query maximized size from frame
             SalFrameGeometry aGeometry = mpWindowImpl->mpFrame->GetGeometry();
@@ -760,8 +760,8 @@ void SystemWindow::SetWindowStateData( const WindowStateData& rData )
         // 91625 - ignore Minimize
         if ( nValidMask & WindowStateMask::State )
         {
-            const sal_uInt32 nState = rData.GetState();
-            if ( nState & WINDOWSTATE_STATE_ROLLUP )
+            const WindowStateState nState = rData.GetState();
+            if ( nState & WindowStateState::Rollup )
                 RollUp();
             else
                 RollDown();
@@ -821,7 +821,7 @@ void SystemWindow::GetWindowStateData( WindowStateData& rData ) const
                 // #94144# allow Minimize again, should be masked out when read from configuration
                 // 91625 - ignore Minimize
                 if ( !(nValidMask&WindowStateMask::Minimized) )
-                    aState.mnState &= ~(WINDOWSTATE_STATE_MINIMIZED);
+                    aState.mnState &= ~(WindowStateState::Minimized);
                 rData.SetState( aState.mnState );
             }
             rData.SetMask( nValidMask );
@@ -833,12 +833,12 @@ void SystemWindow::GetWindowStateData( WindowStateData& rData ) const
     {
         Point   aPos = GetPosPixel();
         Size    aSize = GetSizePixel();
-        sal_uInt32 nState = 0;
+        WindowStateState nState = WindowStateState::NONE;
 
         if ( IsRollUp() )
         {
             aSize.Height() += maOrgSize.Height();
-            nState = WINDOWSTATE_STATE_ROLLUP;
+            nState = WindowStateState::Rollup;
         }
 
         if ( nValidMask & WindowStateMask::X )
diff --git a/vcl/source/window/wrkwin.cxx b/vcl/source/window/wrkwin.cxx
index 1783d918c666..2ebe8d808b62 100644
--- a/vcl/source/window/wrkwin.cxx
+++ b/vcl/source/window/wrkwin.cxx
@@ -209,7 +209,7 @@ bool WorkWindow::IsMinimized() const
     //return mpWindowImpl->mpFrameData->mbMinimized;
     SalFrameState aState;
     mpWindowImpl->mpFrame->GetWindowState(&aState);
-    return (( aState.mnState & WINDOWSTATE_STATE_MINIMIZED ) != 0);
+    return bool(aState.mnState & WindowStateState::Minimized);
 }
 
 bool WorkWindow::SetPluginParent( SystemParentData* pParent )
@@ -229,7 +229,7 @@ bool WorkWindow::SetPluginParent( SystemParentData* pParent )
     return bRet;
 }
 
-void WorkWindow::ImplSetFrameState( sal_uLong aFrameState )
+void WorkWindow::ImplSetFrameState( WindowStateState aFrameState )
 {
     SalFrameState   aState;
     aState.mnMask   = WindowStateMask::State;
@@ -239,12 +239,12 @@ void WorkWindow::ImplSetFrameState( sal_uLong aFrameState )
 
 void WorkWindow::Minimize()
 {
-    ImplSetFrameState( WINDOWSTATE_STATE_MINIMIZED );
+    ImplSetFrameState( WindowStateState::Minimized );
 }
 
 void WorkWindow::Restore()
 {
-    ImplSetFrameState( WINDOWSTATE_STATE_NORMAL );
+    ImplSetFrameState( WindowStateState::Normal );
 }
 
 bool WorkWindow::Close()
@@ -260,7 +260,7 @@ bool WorkWindow::Close()
 
 void WorkWindow::Maximize( bool bMaximize )
 {
-    ImplSetFrameState( bMaximize ? WINDOWSTATE_STATE_MAXIMIZED : WINDOWSTATE_STATE_NORMAL );
+    ImplSetFrameState( bMaximize ? WindowStateState::Maximized : WindowStateState::Normal );
 }
 
 bool WorkWindow::IsMaximized() const
@@ -270,9 +270,9 @@ bool WorkWindow::IsMaximized() const
     SalFrameState aState;
     if( mpWindowImpl->mpFrame->GetWindowState( &aState ) )
     {
-        if( aState.mnState & (WINDOWSTATE_STATE_MAXIMIZED          |
-                              WINDOWSTATE_STATE_MAXIMIZED_HORZ     |
-                              WINDOWSTATE_STATE_MAXIMIZED_VERT ) )
+        if( aState.mnState & (WindowStateState::Maximized          |
+                              WindowStateState::MaximizedHorz     |
+                              WindowStateState::MaximizedVert ) )
             bRet = true;
     }
     return bRet;
diff --git a/vcl/unx/generic/window/salframe.cxx b/vcl/unx/generic/window/salframe.cxx
index 9060664c9efd..21fcebd37582 100644
--- a/vcl/unx/generic/window/salframe.cxx
+++ b/vcl/unx/generic/window/salframe.cxx
@@ -1632,7 +1632,7 @@ void X11SalFrame::SetWindowState( const SalFrameState *pState )
          */
         if( ! IsChildWindow() &&
             (pState->mnMask & WindowStateMask::State) &&
-            (pState->mnState & WINDOWSTATE_STATE_MAXIMIZED) &&
+            (pState->mnState & WindowStateState::Maximized) &&
             (pState->mnMask & FRAMESTATE_MASK_GEOMETRY) == FRAMESTATE_MASK_GEOMETRY &&
             (pState->mnMask & FRAMESTATE_MASK_MAXIMIZED_GEOMETRY) == FRAMESTATE_MASK_MAXIMIZED_GEOMETRY
             )
@@ -1732,15 +1732,15 @@ void X11SalFrame::SetWindowState( const SalFrameState *pState )
     // request for status change
     if (pState->mnMask & WindowStateMask::State)
     {
-        if (pState->mnState & WINDOWSTATE_STATE_MAXIMIZED)
+        if (pState->mnState & WindowStateState::Maximized)
         {
             nShowState_ = SHOWSTATE_NORMAL;
-            if( ! (pState->mnState & (WINDOWSTATE_STATE_MAXIMIZED_HORZ|WINDOWSTATE_STATE_MAXIMIZED_VERT) ) )
+            if( ! (pState->mnState & (WindowStateState::MaximizedHorz|WindowStateState::MaximizedVert) ) )
                 Maximize();
             else
             {
-                bool bHorz = (pState->mnState & WINDOWSTATE_STATE_MAXIMIZED_HORZ) != 0;
-                bool bVert = (pState->mnState & WINDOWSTATE_STATE_MAXIMIZED_VERT) != 0;
+                bool bHorz(pState->mnState & WindowStateState::MaximizedHorz);
+                bool bVert(pState->mnState & WindowStateState::MaximizedVert);
                 GetDisplay()->getWMAdaptor()->maximizeFrame( this, bHorz, bVert );
             }
             maRestorePosSize.Left() = pState->mnX;
@@ -1751,18 +1751,18 @@ void X11SalFrame::SetWindowState( const SalFrameState *pState )
         else if( mbMaximizedHorz || mbMaximizedVert )
             GetDisplay()->getWMAdaptor()->maximizeFrame( this, false, false );
 
-        if (pState->mnState & WINDOWSTATE_STATE_MINIMIZED)
+        if (pState->mnState & WindowStateState::Minimized)
         {
             if (nShowState_ == SHOWSTATE_UNKNOWN)
                 nShowState_ = SHOWSTATE_NORMAL;
             Minimize();
         }
-        if (pState->mnState & WINDOWSTATE_STATE_NORMAL)
+        if (pState->mnState & WindowStateState::Normal)
         {
             if (nShowState_ != SHOWSTATE_NORMAL)
                 Restore();
         }
-        if (pState->mnState & WINDOWSTATE_STATE_ROLLUP)
+        if (pState->mnState & WindowStateState::Rollup)
             GetDisplay()->getWMAdaptor()->shade( this, true );
     }
 }
@@ -1770,9 +1770,9 @@ void X11SalFrame::SetWindowState( const SalFrameState *pState )
 bool X11SalFrame::GetWindowState( SalFrameState* pState )
 {
     if( SHOWSTATE_MINIMIZED == nShowState_ )
-        pState->mnState = WINDOWSTATE_STATE_MINIMIZED;
+        pState->mnState = WindowStateState::Minimized;
     else
-        pState->mnState = WINDOWSTATE_STATE_NORMAL;
+        pState->mnState = WindowStateState::Normal;
 
     Rectangle aPosSize;
     if( maRestorePosSize.IsEmpty() )
@@ -1781,11 +1781,11 @@ bool X11SalFrame::GetWindowState( SalFrameState* pState )
         aPosSize = maRestorePosSize;
 
     if( mbMaximizedHorz )
-        pState->mnState |= WINDOWSTATE_STATE_MAXIMIZED_HORZ;
+        pState->mnState |= WindowStateState::MaximizedHorz;
     if( mbMaximizedVert )
-        pState->mnState |= WINDOWSTATE_STATE_MAXIMIZED_VERT;
+        pState->mnState |= WindowStateState::MaximizedVert;
     if( mbShaded )
-        pState->mnState |= WINDOWSTATE_STATE_ROLLUP;
+        pState->mnState |= WindowStateState::Rollup;
 
     pState->mnX      = aPosSize.Left();
     pState->mnY      = aPosSize.Top();
@@ -1797,7 +1797,7 @@ bool X11SalFrame::GetWindowState( SalFrameState* pState )
     if (! maRestorePosSize.IsEmpty() )
     {
         GetPosSize( aPosSize );
-        pState->mnState |= WINDOWSTATE_STATE_MAXIMIZED;
+        pState->mnState |= WindowStateState::Maximized;
         pState->mnMaximizedX      = aPosSize.Left();
         pState->mnMaximizedY      = aPosSize.Top();
         pState->mnMaximizedWidth  = aPosSize.GetWidth();
diff --git a/vcl/unx/gtk/gtksalframe.cxx b/vcl/unx/gtk/gtksalframe.cxx
index fae99b769bd4..3a8014c41948 100644
--- a/vcl/unx/gtk/gtksalframe.cxx
+++ b/vcl/unx/gtk/gtksalframe.cxx
@@ -1836,7 +1836,7 @@ void GtkSalFrame::SetWindowState( const SalFrameState* pState )
 
     if( (pState->mnMask & WindowStateMask::State) &&
         ! ( m_nState & GDK_WINDOW_STATE_MAXIMIZED ) &&
-        (pState->mnState & WINDOWSTATE_STATE_MAXIMIZED) &&
+        (pState->mnState & WindowStateState::Maximized) &&
         (pState->mnMask & nMaxGeometryMask) == nMaxGeometryMask )
     {
         resizeWindow( pState->mnWidth, pState->mnHeight );
@@ -1876,7 +1876,7 @@ void GtkSalFrame::SetWindowState( const SalFrameState* pState )
     }
     if( pState->mnMask & WindowStateMask::State && ! isChild() )
     {
-        if( pState->mnState & WINDOWSTATE_STATE_MAXIMIZED )
+        if( pState->mnState & WindowStateState::Maximized )
             gtk_window_maximize( GTK_WINDOW(m_pWindow) );
         else
             gtk_window_unmaximize( GTK_WINDOW(m_pWindow) );
@@ -1888,7 +1888,7 @@ void GtkSalFrame::SetWindowState( const SalFrameState* pState )
         *  on windows with a parent (that is transient frames) since these tend
         *  to not be represented in an icon task list.
         */
-        if( (pState->mnState & WINDOWSTATE_STATE_MINIMIZED)
+        if( (pState->mnState & WindowStateState::Minimized)
             && ! m_pParent )
             gtk_window_iconify( GTK_WINDOW(m_pWindow) );
         else
@@ -1899,14 +1899,14 @@ void GtkSalFrame::SetWindowState( const SalFrameState* pState )
 
 bool GtkSalFrame::GetWindowState( SalFrameState* pState )
 {
-    pState->mnState = WINDOWSTATE_STATE_NORMAL;
+    pState->mnState = WindowStateState::Normal;
     pState->mnMask  = WindowStateMask::State;
     // rollup ? gtk 2.2 does not seem to support the shaded state
     if( (m_nState & GDK_WINDOW_STATE_ICONIFIED) )
-        pState->mnState |= WINDOWSTATE_STATE_MINIMIZED;
+        pState->mnState |= WindowStateState::Minimized;
     if( m_nState & GDK_WINDOW_STATE_MAXIMIZED )
     {
-        pState->mnState |= WINDOWSTATE_STATE_MAXIMIZED;
+        pState->mnState |= WindowStateState::Maximized;
         pState->mnX                 = m_aRestorePosSize.Left();
         pState->mnY                 = m_aRestorePosSize.Top();
         pState->mnWidth             = m_aRestorePosSize.GetWidth();
diff --git a/vcl/unx/gtk3/gtk3gtkframe.cxx b/vcl/unx/gtk3/gtk3gtkframe.cxx
index 51d40c9be852..099bae155c9d 100644
--- a/vcl/unx/gtk3/gtk3gtkframe.cxx
+++ b/vcl/unx/gtk3/gtk3gtkframe.cxx
@@ -1662,7 +1662,7 @@ void GtkSalFrame::SetWindowState( const SalFrameState* pState )
 
     if( (pState->mnMask & WindowStateMask::State) &&
         ! ( m_nState & GDK_WINDOW_STATE_MAXIMIZED ) &&
-        (pState->mnState & WINDOWSTATE_STATE_MAXIMIZED) &&
+        (pState->mnState & WindowStateState::Maximized) &&
         (pState->mnMask & nMaxGeometryMask) == nMaxGeometryMask )
     {
         resizeWindow( pState->mnWidth, pState->mnHeight );
@@ -1697,7 +1697,7 @@ void GtkSalFrame::SetWindowState( const SalFrameState* pState )
     }
     if( pState->mnMask & WindowStateMask::State && ! isChild() )
     {
-        if( pState->mnState & WINDOWSTATE_STATE_MAXIMIZED )
+        if( pState->mnState & WindowStateState::Maximized )
             gtk_window_maximize( GTK_WINDOW(m_pWindow) );
         else
             gtk_window_unmaximize( GTK_WINDOW(m_pWindow) );
@@ -1709,7 +1709,7 @@ void GtkSalFrame::SetWindowState( const SalFrameState* pState )
         *  on windows with a parent (that is transient frames) since these tend
         *  to not be represented in an icon task list.
         */
-        if( (pState->mnState & WINDOWSTATE_STATE_MINIMIZED)
+        if( (pState->mnState & WindowStateState::Minimized)
             && ! m_pParent )
             gtk_window_iconify( GTK_WINDOW(m_pWindow) );
         else
@@ -1742,14 +1742,14 @@ namespace
 
 bool GtkSalFrame::GetWindowState( SalFrameState* pState )
 {
-    pState->mnState = WINDOWSTATE_STATE_NORMAL;
+    pState->mnState = WindowStateState::Normal;
     pState->mnMask  = WindowStateMask::State;
     // rollup ? gtk 2.2 does not seem to support the shaded state
     if( (m_nState & GDK_WINDOW_STATE_ICONIFIED) )
-        pState->mnState |= WINDOWSTATE_STATE_MINIMIZED;
+        pState->mnState |= WindowStateState::Minimized;
     if( m_nState & GDK_WINDOW_STATE_MAXIMIZED )
     {
-        pState->mnState |= WINDOWSTATE_STATE_MAXIMIZED;
+        pState->mnState |= WindowStateState::Maximized;
         pState->mnX                 = m_aRestorePosSize.Left();
         pState->mnY                 = m_aRestorePosSize.Top();
         pState->mnWidth             = m_aRestorePosSize.GetWidth();
diff --git a/vcl/win/window/salframe.cxx b/vcl/win/window/salframe.cxx
index 3fd2be1e5704..adced19f90ef 100644
--- a/vcl/win/window/salframe.cxx
+++ b/vcl/win/window/salframe.cxx
@@ -138,14 +138,14 @@ static void ImplSaveFrameState( WinSalFrame* pFrame )
         bool bVisible = (GetWindowStyle( pFrame->mhWnd ) & WS_VISIBLE) != 0;
         if ( IsIconic( pFrame->mhWnd ) )
         {
-            pFrame->maState.mnState |= WINDOWSTATE_STATE_MINIMIZED;
+            pFrame->maState.mnState |= WindowStateState::Minimized;
             if ( bVisible )
                 pFrame->mnShowState = SW_SHOWMAXIMIZED;
         }
         else if ( IsZoomed( pFrame->mhWnd ) )
         {
-            pFrame->maState.mnState &= ~WINDOWSTATE_STATE_MINIMIZED;
-            pFrame->maState.mnState |= WINDOWSTATE_STATE_MAXIMIZED;
+            pFrame->maState.mnState &= ~WindowStateState::Minimized;
+            pFrame->maState.mnState |= WindowStateState::Maximized;
             if ( bVisible )
                 pFrame->mnShowState = SW_SHOWMAXIMIZED;
             pFrame->mbRestoreMaximize = TRUE;
@@ -183,7 +183,7 @@ static void ImplSaveFrameState( WinSalFrame* pFrame )
             long nBottomDeco = abs( aRect.bottom - aRect2.bottom );
             long nRightDeco = abs( aRect.right - aRect2.right );
 
-            pFrame->maState.mnState &= ~(WINDOWSTATE_STATE_MINIMIZED | WINDOWSTATE_STATE_MAXIMIZED);
+            pFrame->maState.mnState &= ~(WindowStateState::Minimized | WindowStateState::Maximized);
             // subtract decoration
             pFrame->maState.mnX      = aRect.left+nLeftDeco;
             pFrame->maState.mnY      = aRect.top+nTopDeco;
@@ -1708,14 +1708,14 @@ void WinSalFrame::SetWindowState( const SalFrameState* pState )
         {
             if ( pState->mnMask & WindowStateMask::State )
             {
-                if ( pState->mnState & WINDOWSTATE_STATE_MINIMIZED )
+                if ( pState->mnState & WindowStateState::Minimized )
                     mnShowState = SW_SHOWMINIMIZED;
-                else if ( pState->mnState & WINDOWSTATE_STATE_MAXIMIZED )
+                else if ( pState->mnState & WindowStateState::Maximized )
                 {
                     mnShowState = SW_SHOWMAXIMIZED;
                     bUpdateHiddenFramePos = TRUE;
                 }
-                else if ( pState->mnState & WINDOWSTATE_STATE_NORMAL )
+                else if ( pState->mnState & WindowStateState::Normal )
                     mnShowState = SW_SHOWNORMAL;
             }
         }
@@ -1724,15 +1724,15 @@ void WinSalFrame::SetWindowState( const SalFrameState* pState )
     {
         if ( pState->mnMask & WindowStateMask::State )
         {
-            if ( pState->mnState & WINDOWSTATE_STATE_MINIMIZED )
+            if ( pState->mnState & WindowStateState::Minimized )
             {
-                if ( pState->mnState & WINDOWSTATE_STATE_MAXIMIZED )
+                if ( pState->mnState & WindowStateState::Maximized )
                     aPlacement.flags |= WPF_RESTORETOMAXIMIZED;
                 aPlacement.showCmd = SW_SHOWMINIMIZED;
             }
-            else if ( pState->mnState & WINDOWSTATE_STATE_MAXIMIZED )
+            else if ( pState->mnState & WindowStateState::Maximized )
                 aPlacement.showCmd = SW_SHOWMAXIMIZED;
-            else if ( pState->mnState & WINDOWSTATE_STATE_NORMAL )
+            else if ( pState->mnState & WindowStateState::Normal )
                 aPlacement.showCmd = SW_RESTORE;
         }
     }
@@ -1785,9 +1785,9 @@ bool WinSalFrame::GetWindowState( SalFrameState* pState )
         *pState = maState;
         // #94144# allow Minimize again, should be masked out when read from configuration
         // 91625 - Don't save minimize
-        //if ( !(pState->mnState & WINDOWSTATE_STATE_MAXIMIZED) )
-        if ( !(pState->mnState & (WINDOWSTATE_STATE_MINIMIZED | WINDOWSTATE_STATE_MAXIMIZED)) )
-            pState->mnState |= WINDOWSTATE_STATE_NORMAL;
+        //if ( !(pState->mnState & WindowStateState::Maximized) )
+        if ( !(pState->mnState & (WindowStateState::Minimized | WindowStateState::Maximized)) )
+            pState->mnState |= WindowStateState::Normal;
         return TRUE;
     }