No need for two sets of names for the same frame/window state bits

Bin the SAL_FRAMESTATE_* defines which as the comment said had to be the same
as the WINDOWSTATE_*] in syswin.hxx.

Change-Id: I42fcd91db543821f007038e558872ba8f69e4a78

9 files changed, 113 insertions, 130 deletions

diff --git a/vcl/aqua/source/window/salframe.cxx b/vcl/aqua/source/window/salframe.cxx
index 2d5bb47ba433..a0038f1e43f5 100644
--- a/vcl/aqua/source/window/salframe.cxx
+++ b/vcl/aqua/source/window/salframe.cxx
@@ -593,19 +593,19 @@ void AquaSalFrame::SetWindowState( const SalFrameState* pState )
     NSRect aStateRect = [mpWindow frame];
     aStateRect = [NSWindow contentRectForFrameRect: aStateRect styleMask: mnStyleMask];
     CocoaToVCL( aStateRect );
-    if( pState->mnMask & SAL_FRAMESTATE_MASK_X )
+    if( pState->mnMask & WINDOWSTATE_MASK_X )
         aStateRect.origin.x = float(pState->mnX);
-    if( pState->mnMask & SAL_FRAMESTATE_MASK_Y )
+    if( pState->mnMask & WINDOWSTATE_MASK_Y )
         aStateRect.origin.y = float(pState->mnY);
-    if( pState->mnMask & SAL_FRAMESTATE_MASK_WIDTH )
+    if( pState->mnMask & WINDOWSTATE_MASK_WIDTH )
         aStateRect.size.width = float(pState->mnWidth);
-    if( pState->mnMask & SAL_FRAMESTATE_MASK_HEIGHT )
+    if( pState->mnMask & WINDOWSTATE_MASK_HEIGHT )
         aStateRect.size.height = float(pState->mnHeight);
     VCLToCocoa( aStateRect );
     aStateRect = [NSWindow frameRectForContentRect: aStateRect styleMask: mnStyleMask];
 
     [mpWindow setFrame: aStateRect display: NO];
-    if( pState->mnState == SAL_FRAMESTATE_MINIMIZED )
+    if( pState->mnState == WINDOWSTATE_STATE_MINIMIZED )
         [mpWindow miniaturize: NSApp];
     else if( [mpWindow isMiniaturized] )
         [mpWindow deminiaturize: NSApp];
@@ -615,7 +615,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 == SAL_FRAMESTATE_MAXIMIZED )
+    if( pState->mnState == WINDOWSTATE_STATE_MAXIMIZED )
     {
         if(! [mpWindow isZoomed])
             [mpWindow zoom: NSApp];
@@ -631,13 +631,13 @@ void AquaSalFrame::SetWindowState( const SalFrameState* pState )
     UpdateFrameGeometry();
 
     sal_uInt16 nEvent = 0;
-    if( pState->mnMask & (SAL_FRAMESTATE_MASK_X | SAL_FRAMESTATE_MASK_Y) )
+    if( pState->mnMask & (WINDOWSTATE_MASK_X | WINDOWSTATE_MASK_Y) )
     {
         mbPositioned = true;
         nEvent = SALEVENT_MOVE;
     }
 
-    if( pState->mnMask & (SAL_FRAMESTATE_MASK_WIDTH | SAL_FRAMESTATE_MASK_HEIGHT) )
+    if( pState->mnMask & (WINDOWSTATE_MASK_WIDTH | WINDOWSTATE_MASK_HEIGHT) )
     {
         mbSized = true;
         nEvent = (nEvent == SALEVENT_MOVE) ? SALEVENT_MOVERESIZE : SALEVENT_RESIZE;
@@ -666,11 +666,11 @@ sal_Bool AquaSalFrame::GetWindowState( SalFrameState* pState )
     // #i113170# may not be the main thread if called from UNO API
     SalData::ensureThreadAutoreleasePool();
 
-    pState->mnMask = SAL_FRAMESTATE_MASK_X                 |
-                     SAL_FRAMESTATE_MASK_Y                 |
-                     SAL_FRAMESTATE_MASK_WIDTH             |
-                     SAL_FRAMESTATE_MASK_HEIGHT            |
-                     SAL_FRAMESTATE_MASK_STATE;
+    pState->mnMask = WINDOWSTATE_MASK_X                 |
+                     WINDOWSTATE_MASK_Y                 |
+                     WINDOWSTATE_MASK_WIDTH             |
+                     WINDOWSTATE_MASK_HEIGHT            |
+                     WINDOWSTATE_MASK_STATE;
 
     NSRect aStateRect = [mpWindow frame];
     aStateRect = [NSWindow contentRectForFrameRect: aStateRect styleMask: mnStyleMask];
@@ -681,11 +681,11 @@ sal_Bool AquaSalFrame::GetWindowState( SalFrameState* pState )
     pState->mnHeight    = long(aStateRect.size.height);
 
     if( [mpWindow isMiniaturized] )
-        pState->mnState = SAL_FRAMESTATE_MINIMIZED;
+        pState->mnState = WINDOWSTATE_STATE_MINIMIZED;
     else if( ! [mpWindow isZoomed] )
-        pState->mnState = SAL_FRAMESTATE_NORMAL;
+        pState->mnState = WINDOWSTATE_STATE_NORMAL;
     else
-        pState->mnState = SAL_FRAMESTATE_MAXIMIZED;
+        pState->mnState = WINDOWSTATE_STATE_MAXIMIZED;
 
     return TRUE;
 }
diff --git a/vcl/headless/svpframe.cxx b/vcl/headless/svpframe.cxx
index a94e051873fb..8a234dfb1fdd 100644
--- a/vcl/headless/svpframe.cxx
+++ b/vcl/headless/svpframe.cxx
@@ -18,6 +18,7 @@
  */
 
 #include <string.h>
+#include "vcl/syswin.hxx"
 #include "headless/svpframe.hxx"
 #include "headless/svpinst.hxx"
 #include "headless/svpgdi.hxx"
@@ -309,8 +310,8 @@ SalFrame* SvpSalFrame::GetParent() const
 }
 
 #define _FRAMESTATE_MASK_GEOMETRY \
-     (SAL_FRAMESTATE_MASK_X     | SAL_FRAMESTATE_MASK_Y |   \
-      SAL_FRAMESTATE_MASK_WIDTH | SAL_FRAMESTATE_MASK_HEIGHT)
+     (WINDOWSTATE_MASK_X     | WINDOWSTATE_MASK_Y |   \
+      WINDOWSTATE_MASK_WIDTH | WINDOWSTATE_MASK_HEIGHT)
 
 void SvpSalFrame::SetWindowState( const SalFrameState *pState )
 {
@@ -326,13 +327,13 @@ void SvpSalFrame::SetWindowState( const SalFrameState *pState )
         long nHeight = maGeometry.nHeight;
 
         // change requested properties
-        if (pState->mnMask & SAL_FRAMESTATE_MASK_X)
+        if (pState->mnMask & WINDOWSTATE_MASK_X)
             nX = pState->mnX;
-        if (pState->mnMask & SAL_FRAMESTATE_MASK_Y)
+        if (pState->mnMask & WINDOWSTATE_MASK_Y)
             nY = pState->mnY;
-        if (pState->mnMask & SAL_FRAMESTATE_MASK_WIDTH)
+        if (pState->mnMask & WINDOWSTATE_MASK_WIDTH)
             nWidth = pState->mnWidth;
-        if (pState->mnMask & SAL_FRAMESTATE_MASK_HEIGHT)
+        if (pState->mnMask & WINDOWSTATE_MASK_HEIGHT)
             nHeight = pState->mnHeight;
 
         SetPosSize( nX, nY, nWidth, nHeight,
@@ -343,12 +344,12 @@ void SvpSalFrame::SetWindowState( const SalFrameState *pState )
 
 sal_Bool SvpSalFrame::GetWindowState( SalFrameState* pState )
 {
-    pState->mnState = SAL_FRAMESTATE_NORMAL;
+    pState->mnState = WINDOWSTATE_STATE_NORMAL;
     pState->mnX      = maGeometry.nX;
     pState->mnY      = maGeometry.nY;
     pState->mnWidth  = maGeometry.nWidth;
     pState->mnHeight = maGeometry.nHeight;
-    pState->mnMask   = _FRAMESTATE_MASK_GEOMETRY | SAL_FRAMESTATE_MASK_STATE;
+    pState->mnMask   = _FRAMESTATE_MASK_GEOMETRY | WINDOWSTATE_MASK_STATE;
 
     return sal_True;
 }
diff --git a/vcl/inc/salwtype.hxx b/vcl/inc/salwtype.hxx
index b2c54aa90301..69e63412eca4 100644
--- a/vcl/inc/salwtype.hxx
+++ b/vcl/inc/salwtype.hxx
@@ -258,25 +258,6 @@ typedef long (*SALOBJECTPROC)( void* pInst, SalObject* pObject,
 // - SalFrameState -
 // -----------------
 
-// Must be the same as in syswin.hxx
-#define SAL_FRAMESTATE_MASK_X                   ((sal_uLong)0x00000001)
-#define SAL_FRAMESTATE_MASK_Y                   ((sal_uLong)0x00000002)
-#define SAL_FRAMESTATE_MASK_WIDTH               ((sal_uLong)0x00000004)
-#define SAL_FRAMESTATE_MASK_HEIGHT              ((sal_uLong)0x00000008)
-#define SAL_FRAMESTATE_MASK_MAXIMIZED_X         ((sal_uLong)0x00000100)
-#define SAL_FRAMESTATE_MASK_MAXIMIZED_Y         ((sal_uLong)0x00000200)
-#define SAL_FRAMESTATE_MASK_MAXIMIZED_WIDTH     ((sal_uLong)0x00000400)
-#define SAL_FRAMESTATE_MASK_MAXIMIZED_HEIGHT    ((sal_uLong)0x00000800)
-#define SAL_FRAMESTATE_MASK_STATE               ((sal_uLong)0x00000010)
-
-#define SAL_FRAMESTATE_NORMAL               ((sal_uLong)0x00000001)
-#define SAL_FRAMESTATE_MINIMIZED            ((sal_uLong)0x00000002)
-#define SAL_FRAMESTATE_MAXIMIZED            ((sal_uLong)0x00000004)
-#define SAL_FRAMESTATE_ROLLUP               ((sal_uLong)0x00000008)
-#define SAL_FRAMESTATE_MAXIMIZED_HORZ       ((sal_uLong)0x00000010)
-#define SAL_FRAMESTATE_MAXIMIZED_VERT       ((sal_uLong)0x00000020)
-#define SAL_FRAMESTATE_SYSTEMMASK           ((sal_uLong)0x0000FFFF)
-
 struct SalFrameState
 {
     sal_uLong       mnMask;
diff --git a/vcl/inc/vcl/syswin.hxx b/vcl/inc/vcl/syswin.hxx
index ee895477348a..1ec1f8876126 100644
--- a/vcl/inc/vcl/syswin.hxx
+++ b/vcl/inc/vcl/syswin.hxx
@@ -71,6 +71,7 @@ class TaskPaneList;
 #define WINDOWSTATE_STATE_ROLLUP         ((sal_uLong)0x00000008)
 #define WINDOWSTATE_STATE_MAXIMIZED_HORZ ((sal_uLong)0x00000010)
 #define WINDOWSTATE_STATE_MAXIMIZED_VERT ((sal_uLong)0x00000020)
+#define WINDOWSTATE_STATE_SYSTEMMASK     ((sal_uLong)0x0000FFFF)
 
 class VCL_PLUGIN_PUBLIC WindowStateData
 {
diff --git a/vcl/source/window/syswin.cxx b/vcl/source/window/syswin.cxx
index 8451f81bdf91..57f555258ad3 100644
--- a/vcl/source/window/syswin.cxx
+++ b/vcl/source/window/syswin.cxx
@@ -693,7 +693,7 @@ void SystemWindow::SetWindowStateData( const WindowStateData& rData )
         // #94144# allow Minimize again, should be masked out when read from configuration
         // 91625 - ignore Minimize
         //nState &= ~(WINDOWSTATE_STATE_MINIMIZED);
-        aState.mnState  = nState & SAL_FRAMESTATE_SYSTEMMASK;
+        aState.mnState  = nState & WINDOWSTATE_STATE_SYSTEMMASK;
 
         // normalize window positions onto screen
         ImplMoveToScreen( aState.mnX, aState.mnY, aState.mnWidth, aState.mnHeight, pWindow );
@@ -835,22 +835,22 @@ void SystemWindow::GetWindowStateData( WindowStateData& rData ) const
                 rData.SetWidth( aState.mnWidth );
             if ( nValidMask & WINDOWSTATE_MASK_HEIGHT )
                 rData.SetHeight( aState.mnHeight );
-            if ( aState.mnMask & SAL_FRAMESTATE_MASK_MAXIMIZED_X )
+            if ( aState.mnMask & WINDOWSTATE_MASK_MAXIMIZED_X )
             {
                 rData.SetMaximizedX( aState.mnMaximizedX );
                 nValidMask |= WINDOWSTATE_MASK_MAXIMIZED_X;
             }
-            if ( aState.mnMask & SAL_FRAMESTATE_MASK_MAXIMIZED_Y )
+            if ( aState.mnMask & WINDOWSTATE_MASK_MAXIMIZED_Y )
             {
                 rData.SetMaximizedY( aState.mnMaximizedY );
                 nValidMask |= WINDOWSTATE_MASK_MAXIMIZED_Y;
             }
-            if ( aState.mnMask & SAL_FRAMESTATE_MASK_MAXIMIZED_WIDTH )
+            if ( aState.mnMask & WINDOWSTATE_MASK_MAXIMIZED_WIDTH )
             {
                 rData.SetMaximizedWidth( aState.mnMaximizedWidth );
                 nValidMask |= WINDOWSTATE_MASK_MAXIMIZED_WIDTH;
             }
-            if ( aState.mnMask & SAL_FRAMESTATE_MASK_MAXIMIZED_HEIGHT )
+            if ( aState.mnMask & WINDOWSTATE_MASK_MAXIMIZED_HEIGHT )
             {
                 rData.SetMaximizedHeight( aState.mnMaximizedHeight );
                 nValidMask |= WINDOWSTATE_MASK_MAXIMIZED_HEIGHT;
diff --git a/vcl/source/window/wrkwin.cxx b/vcl/source/window/wrkwin.cxx
index 166bb09f4435..3746f2958465 100644
--- a/vcl/source/window/wrkwin.cxx
+++ b/vcl/source/window/wrkwin.cxx
@@ -229,7 +229,7 @@ sal_Bool WorkWindow::IsMinimized() const
     //return mpWindowImpl->mpFrameData->mbMinimized;
     SalFrameState aState;
     mpWindowImpl->mpFrame->GetWindowState(&aState);
-    return (( aState.mnState & SAL_FRAMESTATE_MINIMIZED ) != 0);
+    return (( aState.mnState & WINDOWSTATE_STATE_MINIMIZED ) != 0);
 }
 
 // -----------------------------------------------------------------------
@@ -254,7 +254,7 @@ sal_Bool WorkWindow::SetPluginParent( SystemParentData* pParent )
 void WorkWindow::ImplSetFrameState( sal_uLong aFrameState )
 {
     SalFrameState   aState;
-    aState.mnMask   = SAL_FRAMESTATE_MASK_STATE;
+    aState.mnMask   = WINDOWSTATE_MASK_STATE;
     aState.mnState  = aFrameState;
     mpWindowImpl->mpFrame->SetWindowState( &aState );
 }
@@ -262,12 +262,12 @@ void WorkWindow::ImplSetFrameState( sal_uLong aFrameState )
 
 void WorkWindow::Minimize()
 {
-    ImplSetFrameState( SAL_FRAMESTATE_MINIMIZED );
+    ImplSetFrameState( WINDOWSTATE_STATE_MINIMIZED );
 }
 
 void WorkWindow::Restore()
 {
-    ImplSetFrameState( SAL_FRAMESTATE_NORMAL );
+    ImplSetFrameState( WINDOWSTATE_STATE_NORMAL );
 }
 
 sal_Bool WorkWindow::Close()
@@ -283,7 +283,7 @@ sal_Bool WorkWindow::Close()
 
 void WorkWindow::Maximize( sal_Bool bMaximize )
 {
-    ImplSetFrameState( bMaximize ? SAL_FRAMESTATE_MAXIMIZED : SAL_FRAMESTATE_NORMAL );
+    ImplSetFrameState( bMaximize ? WINDOWSTATE_STATE_MAXIMIZED : WINDOWSTATE_STATE_NORMAL );
 }
 
 sal_Bool WorkWindow::IsMaximized() const
@@ -293,9 +293,9 @@ sal_Bool WorkWindow::IsMaximized() const
     SalFrameState aState;
     if( mpWindowImpl->mpFrame->GetWindowState( &aState ) )
     {
-        if( aState.mnState & (SAL_FRAMESTATE_MAXIMIZED          |
-                              SAL_FRAMESTATE_MAXIMIZED_HORZ     |
-                              SAL_FRAMESTATE_MAXIMIZED_VERT ) )
+        if( aState.mnState & (WINDOWSTATE_STATE_MAXIMIZED          |
+                              WINDOWSTATE_STATE_MAXIMIZED_HORZ     |
+                              WINDOWSTATE_STATE_MAXIMIZED_VERT ) )
             bRet = sal_True;
     }
     return bRet;
diff --git a/vcl/unx/generic/window/salframe.cxx b/vcl/unx/generic/window/salframe.cxx
index 6b284669ed30..5ce10795b464 100644
--- a/vcl/unx/generic/window/salframe.cxx
+++ b/vcl/unx/generic/window/salframe.cxx
@@ -1477,11 +1477,11 @@ void X11SalFrame::SetAlwaysOnTop( sal_Bool bOnTop )
 }
 
 #define _FRAMESTATE_MASK_GEOMETRY \
-     (SAL_FRAMESTATE_MASK_X     | SAL_FRAMESTATE_MASK_Y |   \
-      SAL_FRAMESTATE_MASK_WIDTH | SAL_FRAMESTATE_MASK_HEIGHT)
+     (WINDOWSTATE_MASK_X     | WINDOWSTATE_MASK_Y |   \
+      WINDOWSTATE_MASK_WIDTH | WINDOWSTATE_MASK_HEIGHT)
 #define _FRAMESTATE_MASK_MAXIMIZED_GEOMETRY \
-     (SAL_FRAMESTATE_MASK_MAXIMIZED_X     | SAL_FRAMESTATE_MASK_MAXIMIZED_Y |   \
-      SAL_FRAMESTATE_MASK_MAXIMIZED_WIDTH | SAL_FRAMESTATE_MASK_MAXIMIZED_HEIGHT)
+     (WINDOWSTATE_MASK_MAXIMIZED_X     | WINDOWSTATE_MASK_MAXIMIZED_Y |   \
+      WINDOWSTATE_MASK_MAXIMIZED_WIDTH | WINDOWSTATE_MASK_MAXIMIZED_HEIGHT)
 
 void X11SalFrame::SetWindowState( const SalFrameState *pState )
 {
@@ -1498,8 +1498,8 @@ void X11SalFrame::SetWindowState( const SalFrameState *pState )
          * in state change below maximize window
          */
         if( ! IsChildWindow() &&
-            (pState->mnMask & SAL_FRAMESTATE_MASK_STATE) &&
-            (pState->mnState & SAL_FRAMESTATE_MAXIMIZED) &&
+            (pState->mnMask & WINDOWSTATE_MASK_STATE) &&
+            (pState->mnState & WINDOWSTATE_STATE_MAXIMIZED) &&
             (pState->mnMask & _FRAMESTATE_MASK_GEOMETRY) == _FRAMESTATE_MASK_GEOMETRY &&
             (pState->mnMask & _FRAMESTATE_MASK_MAXIMIZED_GEOMETRY) == _FRAMESTATE_MASK_MAXIMIZED_GEOMETRY
             )
@@ -1537,21 +1537,21 @@ void X11SalFrame::SetWindowState( const SalFrameState *pState )
                 GetPosSize (aPosSize);
 
             // change requested properties
-            if (pState->mnMask & SAL_FRAMESTATE_MASK_X)
+            if (pState->mnMask & WINDOWSTATE_MASK_X)
             {
                 aPosSize.setX (pState->mnX);
             }
-            if (pState->mnMask & SAL_FRAMESTATE_MASK_Y)
+            if (pState->mnMask & WINDOWSTATE_MASK_Y)
             {
                 aPosSize.setY (pState->mnY);
             }
-            if (pState->mnMask & SAL_FRAMESTATE_MASK_WIDTH)
+            if (pState->mnMask & WINDOWSTATE_MASK_WIDTH)
             {
                 long nWidth = pState->mnWidth > 0 ? pState->mnWidth  - 1 : 0;
                 aPosSize.setWidth (nWidth);
                 bDoAdjust = true;
             }
-            if (pState->mnMask & SAL_FRAMESTATE_MASK_HEIGHT)
+            if (pState->mnMask & WINDOWSTATE_MASK_HEIGHT)
             {
                 int nHeight = pState->mnHeight > 0 ? pState->mnHeight - 1 : 0;
                 aPosSize.setHeight (nHeight);
@@ -1597,17 +1597,17 @@ void X11SalFrame::SetWindowState( const SalFrameState *pState )
     }
 
     // request for status change
-    if (pState->mnMask & SAL_FRAMESTATE_MASK_STATE)
+    if (pState->mnMask & WINDOWSTATE_MASK_STATE)
     {
-        if (pState->mnState & SAL_FRAMESTATE_MAXIMIZED)
+        if (pState->mnState & WINDOWSTATE_STATE_MAXIMIZED)
         {
             nShowState_ = SHOWSTATE_NORMAL;
-            if( ! (pState->mnState & (SAL_FRAMESTATE_MAXIMIZED_HORZ|SAL_FRAMESTATE_MAXIMIZED_VERT) ) )
+            if( ! (pState->mnState & (WINDOWSTATE_STATE_MAXIMIZED_HORZ|WINDOWSTATE_STATE_MAXIMIZED_VERT) ) )
                 Maximize();
             else
             {
-                bool bHorz = (pState->mnState & SAL_FRAMESTATE_MAXIMIZED_HORZ) ? true : false;
-                bool bVert = (pState->mnState & SAL_FRAMESTATE_MAXIMIZED_VERT) ? true : false;
+                bool bHorz = (pState->mnState & WINDOWSTATE_STATE_MAXIMIZED_HORZ) ? true : false;
+                bool bVert = (pState->mnState & WINDOWSTATE_STATE_MAXIMIZED_VERT) ? true : false;
                 GetDisplay()->getWMAdaptor()->maximizeFrame( this, bHorz, bVert );
             }
             maRestorePosSize.Left() = pState->mnX;
@@ -1618,18 +1618,18 @@ void X11SalFrame::SetWindowState( const SalFrameState *pState )
         else if( mbMaximizedHorz || mbMaximizedVert )
             GetDisplay()->getWMAdaptor()->maximizeFrame( this, false, false );
 
-        if (pState->mnState & SAL_FRAMESTATE_MINIMIZED)
+        if (pState->mnState & WINDOWSTATE_STATE_MINIMIZED)
         {
             if (nShowState_ == SHOWSTATE_UNKNOWN)
                 nShowState_ = SHOWSTATE_NORMAL;
             Minimize();
         }
-        if (pState->mnState & SAL_FRAMESTATE_NORMAL)
+        if (pState->mnState & WINDOWSTATE_STATE_NORMAL)
         {
             if (nShowState_ != SHOWSTATE_NORMAL)
                 Restore();
         }
-        if (pState->mnState & SAL_FRAMESTATE_ROLLUP)
+        if (pState->mnState & WINDOWSTATE_STATE_ROLLUP)
             GetDisplay()->getWMAdaptor()->shade( this, true );
     }
 }
@@ -1637,9 +1637,9 @@ void X11SalFrame::SetWindowState( const SalFrameState *pState )
 sal_Bool X11SalFrame::GetWindowState( SalFrameState* pState )
 {
     if( SHOWSTATE_MINIMIZED == nShowState_ )
-        pState->mnState = SAL_FRAMESTATE_MINIMIZED;
+        pState->mnState = WINDOWSTATE_STATE_MINIMIZED;
     else
-        pState->mnState = SAL_FRAMESTATE_NORMAL;
+        pState->mnState = WINDOWSTATE_STATE_NORMAL;
 
     Rectangle aPosSize;
     if( maRestorePosSize.IsEmpty() )
@@ -1648,24 +1648,24 @@ sal_Bool X11SalFrame::GetWindowState( SalFrameState* pState )
         aPosSize = maRestorePosSize;
 
     if( mbMaximizedHorz )
-        pState->mnState |= SAL_FRAMESTATE_MAXIMIZED_HORZ;
+        pState->mnState |= WINDOWSTATE_STATE_MAXIMIZED_HORZ;
     if( mbMaximizedVert )
-        pState->mnState |= SAL_FRAMESTATE_MAXIMIZED_VERT;
+        pState->mnState |= WINDOWSTATE_STATE_MAXIMIZED_VERT;
     if( mbShaded )
-        pState->mnState |= SAL_FRAMESTATE_ROLLUP;
+        pState->mnState |= WINDOWSTATE_STATE_ROLLUP;
 
     pState->mnX      = aPosSize.Left();
     pState->mnY      = aPosSize.Top();
     pState->mnWidth  = aPosSize.GetWidth();
     pState->mnHeight = aPosSize.GetHeight();
 
-    pState->mnMask   = _FRAMESTATE_MASK_GEOMETRY | SAL_FRAMESTATE_MASK_STATE;
+    pState->mnMask   = _FRAMESTATE_MASK_GEOMETRY | WINDOWSTATE_MASK_STATE;
 
 
     if (! maRestorePosSize.IsEmpty() )
     {
         GetPosSize( aPosSize );
-        pState->mnState |= SAL_FRAMESTATE_MAXIMIZED;
+        pState->mnState |= WINDOWSTATE_STATE_MAXIMIZED;
         pState->mnMaximizedX      = aPosSize.Left();
         pState->mnMaximizedY      = aPosSize.Top();
         pState->mnMaximizedWidth  = aPosSize.GetWidth();
diff --git a/vcl/unx/gtk/window/gtkframe.cxx b/vcl/unx/gtk/window/gtkframe.cxx
index 9433ae5dd6b3..7a042e9b1388 100644
--- a/vcl/unx/gtk/window/gtkframe.cxx
+++ b/vcl/unx/gtk/window/gtkframe.cxx
@@ -1916,14 +1916,14 @@ void GtkSalFrame::SetWindowState( const SalFrameState* pState )
         return;
 
     const sal_uLong nMaxGeometryMask =
-        SAL_FRAMESTATE_MASK_X | SAL_FRAMESTATE_MASK_Y |
-        SAL_FRAMESTATE_MASK_WIDTH | SAL_FRAMESTATE_MASK_HEIGHT |
-        SAL_FRAMESTATE_MASK_MAXIMIZED_X | SAL_FRAMESTATE_MASK_MAXIMIZED_Y |
-        SAL_FRAMESTATE_MASK_MAXIMIZED_WIDTH | SAL_FRAMESTATE_MASK_MAXIMIZED_HEIGHT;
+        WINDOWSTATE_MASK_X | WINDOWSTATE_MASK_Y |
+        WINDOWSTATE_MASK_WIDTH | WINDOWSTATE_MASK_HEIGHT |
+        WINDOWSTATE_MASK_MAXIMIZED_X | WINDOWSTATE_MASK_MAXIMIZED_Y |
+        WINDOWSTATE_MASK_MAXIMIZED_WIDTH | WINDOWSTATE_MASK_MAXIMIZED_HEIGHT;
 
-    if( (pState->mnMask & SAL_FRAMESTATE_MASK_STATE) &&
+    if( (pState->mnMask & WINDOWSTATE_MASK_STATE) &&
         ! ( m_nState & GDK_WINDOW_STATE_MAXIMIZED ) &&
-        (pState->mnState & SAL_FRAMESTATE_MAXIMIZED) &&
+        (pState->mnState & WINDOWSTATE_STATE_MAXIMIZED) &&
         (pState->mnMask & nMaxGeometryMask) == nMaxGeometryMask )
     {
         resizeWindow( pState->mnWidth, pState->mnHeight );
@@ -1942,29 +1942,29 @@ void GtkSalFrame::SetWindowState( const SalFrameState* pState )
                                        Size( pState->mnWidth, pState->mnHeight ) );
         CallCallback( SALEVENT_RESIZE, NULL );
     }
-    else if( pState->mnMask & (SAL_FRAMESTATE_MASK_X | SAL_FRAMESTATE_MASK_Y |
-                               SAL_FRAMESTATE_MASK_WIDTH | SAL_FRAMESTATE_MASK_HEIGHT ) )
+    else if( pState->mnMask & (WINDOWSTATE_MASK_X | WINDOWSTATE_MASK_Y |
+                               WINDOWSTATE_MASK_WIDTH | WINDOWSTATE_MASK_HEIGHT ) )
     {
         sal_uInt16 nPosSizeFlags = 0;
         long nX         = pState->mnX - (m_pParent ? m_pParent->maGeometry.nX : 0);
         long nY         = pState->mnY - (m_pParent ? m_pParent->maGeometry.nY : 0);
-        if( pState->mnMask & SAL_FRAMESTATE_MASK_X )
+        if( pState->mnMask & WINDOWSTATE_MASK_X )
             nPosSizeFlags |= SAL_FRAME_POSSIZE_X;
         else
             nX = maGeometry.nX - (m_pParent ? m_pParent->maGeometry.nX : 0);
-        if( pState->mnMask & SAL_FRAMESTATE_MASK_Y )
+        if( pState->mnMask & WINDOWSTATE_MASK_Y )
             nPosSizeFlags |= SAL_FRAME_POSSIZE_Y;
         else
             nY = maGeometry.nY - (m_pParent ? m_pParent->maGeometry.nY : 0);
-        if( pState->mnMask & SAL_FRAMESTATE_MASK_WIDTH )
+        if( pState->mnMask & WINDOWSTATE_MASK_WIDTH )
             nPosSizeFlags |= SAL_FRAME_POSSIZE_WIDTH;
-        if( pState->mnMask & SAL_FRAMESTATE_MASK_HEIGHT )
+        if( pState->mnMask & WINDOWSTATE_MASK_HEIGHT )
             nPosSizeFlags |= SAL_FRAME_POSSIZE_HEIGHT;
         SetPosSize( nX, nY, pState->mnWidth, pState->mnHeight, nPosSizeFlags );
     }
-    if( pState->mnMask & SAL_FRAMESTATE_MASK_STATE && ! isChild() )
+    if( pState->mnMask & WINDOWSTATE_MASK_STATE && ! isChild() )
     {
-        if( pState->mnState & SAL_FRAMESTATE_MAXIMIZED )
+        if( pState->mnState & WINDOWSTATE_STATE_MAXIMIZED )
             gtk_window_maximize( GTK_WINDOW(m_pWindow) );
         else
             gtk_window_unmaximize( GTK_WINDOW(m_pWindow) );
@@ -1976,7 +1976,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 & SAL_FRAMESTATE_MINIMIZED)
+        if( (pState->mnState & WINDOWSTATE_STATE_MINIMIZED)
             && ! m_pParent )
             gtk_window_iconify( GTK_WINDOW(m_pWindow) );
         else
@@ -1986,14 +1986,14 @@ void GtkSalFrame::SetWindowState( const SalFrameState* pState )
 
 sal_Bool GtkSalFrame::GetWindowState( SalFrameState* pState )
 {
-    pState->mnState = SAL_FRAMESTATE_NORMAL;
-    pState->mnMask  = SAL_FRAMESTATE_MASK_STATE;
+    pState->mnState = WINDOWSTATE_STATE_NORMAL;
+    pState->mnMask  = WINDOWSTATE_MASK_STATE;
     // rollup ? gtk 2.2 does not seem to support the shaded state
     if( (m_nState & GDK_WINDOW_STATE_ICONIFIED) )
-        pState->mnState |= SAL_FRAMESTATE_MINIMIZED;
+        pState->mnState |= WINDOWSTATE_STATE_MINIMIZED;
     if( m_nState & GDK_WINDOW_STATE_MAXIMIZED )
     {
-        pState->mnState |= SAL_FRAMESTATE_MAXIMIZED;
+        pState->mnState |= WINDOWSTATE_STATE_MAXIMIZED;
         pState->mnX                 = m_aRestorePosSize.Left();
         pState->mnY                 = m_aRestorePosSize.Top();
         pState->mnWidth             = m_aRestorePosSize.GetWidth();
@@ -2002,10 +2002,10 @@ sal_Bool GtkSalFrame::GetWindowState( SalFrameState* pState )
         pState->mnMaximizedY        = maGeometry.nY;
         pState->mnMaximizedWidth    = maGeometry.nWidth;
         pState->mnMaximizedHeight   = maGeometry.nHeight;
-        pState->mnMask  |= SAL_FRAMESTATE_MASK_MAXIMIZED_X          |
-                           SAL_FRAMESTATE_MASK_MAXIMIZED_Y          |
-                           SAL_FRAMESTATE_MASK_MAXIMIZED_WIDTH      |
-                           SAL_FRAMESTATE_MASK_MAXIMIZED_HEIGHT;
+        pState->mnMask  |= WINDOWSTATE_MASK_MAXIMIZED_X          |
+                           WINDOWSTATE_MASK_MAXIMIZED_Y          |
+                           WINDOWSTATE_MASK_MAXIMIZED_WIDTH      |
+                           WINDOWSTATE_MASK_MAXIMIZED_HEIGHT;
     }
     else
     {
@@ -2014,10 +2014,10 @@ sal_Bool GtkSalFrame::GetWindowState( SalFrameState* pState )
         pState->mnWidth     = maGeometry.nWidth;
         pState->mnHeight    = maGeometry.nHeight;
     }
-    pState->mnMask  |= SAL_FRAMESTATE_MASK_X            |
-                       SAL_FRAMESTATE_MASK_Y            |
-                       SAL_FRAMESTATE_MASK_WIDTH        |
-                       SAL_FRAMESTATE_MASK_HEIGHT;
+    pState->mnMask  |= WINDOWSTATE_MASK_X            |
+                       WINDOWSTATE_MASK_Y            |
+                       WINDOWSTATE_MASK_WIDTH        |
+                       WINDOWSTATE_MASK_HEIGHT;
 
     return sal_True;
 }
diff --git a/vcl/win/source/window/salframe.cxx b/vcl/win/source/window/salframe.cxx
index 223c09f8a596..5dd5d75b8b73 100644
--- a/vcl/win/source/window/salframe.cxx
+++ b/vcl/win/source/window/salframe.cxx
@@ -137,14 +137,14 @@ static void ImplSaveFrameState( WinSalFrame* pFrame )
         sal_Bool bVisible = (GetWindowStyle( pFrame->mhWnd ) & WS_VISIBLE) != 0;
         if ( IsIconic( pFrame->mhWnd ) )
         {
-            pFrame->maState.mnState |= SAL_FRAMESTATE_MINIMIZED;
+            pFrame->maState.mnState |= WINDOWSTATE_STATE_MINIMIZED;
             if ( bVisible )
                 pFrame->mnShowState = SW_SHOWMAXIMIZED;
         }
         else if ( IsZoomed( pFrame->mhWnd ) )
         {
-            pFrame->maState.mnState &= ~SAL_FRAMESTATE_MINIMIZED;
-            pFrame->maState.mnState |= SAL_FRAMESTATE_MAXIMIZED;
+            pFrame->maState.mnState &= ~WINDOWSTATE_STATE_MINIMIZED;
+            pFrame->maState.mnState |= WINDOWSTATE_STATE_MAXIMIZED;
             if ( bVisible )
                 pFrame->mnShowState = SW_SHOWMAXIMIZED;
             pFrame->mbRestoreMaximize = TRUE;
@@ -182,7 +182,7 @@ static void ImplSaveFrameState( WinSalFrame* pFrame )
             long nBottomDeco = abs( aRect.bottom - aRect2.bottom );
             long nRightDeco = abs( aRect.right - aRect2.right );
 
-            pFrame->maState.mnState &= ~(SAL_FRAMESTATE_MINIMIZED | SAL_FRAMESTATE_MAXIMIZED);
+            pFrame->maState.mnState &= ~(WINDOWSTATE_STATE_MINIMIZED | WINDOWSTATE_STATE_MAXIMIZED);
             // subtract decoration
             pFrame->maState.mnX      = aRect.left+nLeftDeco;
             pFrame->maState.mnY      = aRect.top+nTopDeco;
@@ -1724,23 +1724,23 @@ void WinSalFrame::SetWindowState( const SalFrameState* pState )
     long nRightDeco = abs( aWinRect.right - aRect2.right );
 
     // adjust window position/size to fit the screen
-    if ( !(pState->mnMask & (SAL_FRAMESTATE_MASK_X | SAL_FRAMESTATE_MASK_Y)) )
+    if ( !(pState->mnMask & (WINDOWSTATE_MASK_X | WINDOWSTATE_MASK_Y)) )
         nPosSize |= SWP_NOMOVE;
-    if ( !(pState->mnMask & (SAL_FRAMESTATE_MASK_WIDTH | SAL_FRAMESTATE_MASK_HEIGHT)) )
+    if ( !(pState->mnMask & (WINDOWSTATE_MASK_WIDTH | WINDOWSTATE_MASK_HEIGHT)) )
         nPosSize |= SWP_NOSIZE;
-    if ( pState->mnMask & SAL_FRAMESTATE_MASK_X )
+    if ( pState->mnMask & WINDOWSTATE_MASK_X )
         nX = (int)pState->mnX - nLeftDeco;
     else
         nX = aWinRect.left;
-    if ( pState->mnMask & SAL_FRAMESTATE_MASK_Y )
+    if ( pState->mnMask & WINDOWSTATE_MASK_Y )
         nY = (int)pState->mnY - nTopDeco;
     else
         nY = aWinRect.top;
-    if ( pState->mnMask & SAL_FRAMESTATE_MASK_WIDTH )
+    if ( pState->mnMask & WINDOWSTATE_MASK_WIDTH )
         nWidth = (int)pState->mnWidth + nLeftDeco + nRightDeco;
     else
         nWidth = aWinRect.right-aWinRect.left;
-    if ( pState->mnMask & SAL_FRAMESTATE_MASK_HEIGHT )
+    if ( pState->mnMask & WINDOWSTATE_MASK_HEIGHT )
         nHeight = (int)pState->mnHeight + nTopDeco + nBottomDeco;
     else
         nHeight = aWinRect.bottom-aWinRect.top;
@@ -1775,33 +1775,33 @@ void WinSalFrame::SetWindowState( const SalFrameState* pState )
 
         if ( mbOverwriteState )
         {
-            if ( pState->mnMask & SAL_FRAMESTATE_MASK_STATE )
+            if ( pState->mnMask & WINDOWSTATE_MASK_STATE )
             {
-                if ( pState->mnState & SAL_FRAMESTATE_MINIMIZED )
+                if ( pState->mnState & WINDOWSTATE_STATE_MINIMIZED )
                     mnShowState = SW_SHOWMINIMIZED;
-                else if ( pState->mnState & SAL_FRAMESTATE_MAXIMIZED )
+                else if ( pState->mnState & WINDOWSTATE_STATE_MAXIMIZED )
                 {
                     mnShowState = SW_SHOWMAXIMIZED;
                     bUpdateHiddenFramePos = TRUE;
                 }
-                else if ( pState->mnState & SAL_FRAMESTATE_NORMAL )
+                else if ( pState->mnState & WINDOWSTATE_STATE_NORMAL )
                     mnShowState = SW_SHOWNORMAL;
             }
         }
     }
     else
     {
-        if ( pState->mnMask & SAL_FRAMESTATE_MASK_STATE )
+        if ( pState->mnMask & WINDOWSTATE_MASK_STATE )
         {
-            if ( pState->mnState & SAL_FRAMESTATE_MINIMIZED )
+            if ( pState->mnState & WINDOWSTATE_STATE_MINIMIZED )
             {
-                if ( pState->mnState & SAL_FRAMESTATE_MAXIMIZED )
+                if ( pState->mnState & WINDOWSTATE_STATE_MAXIMIZED )
                     aPlacement.flags |= WPF_RESTORETOMAXIMIZED;
                 aPlacement.showCmd = SW_SHOWMINIMIZED;
             }
-            else if ( pState->mnState & SAL_FRAMESTATE_MAXIMIZED )
+            else if ( pState->mnState & WINDOWSTATE_STATE_MAXIMIZED )
                 aPlacement.showCmd = SW_SHOWMAXIMIZED;
-            else if ( pState->mnState & SAL_FRAMESTATE_NORMAL )
+            else if ( pState->mnState & WINDOWSTATE_STATE_NORMAL )
                 aPlacement.showCmd = SW_RESTORE;
         }
     }
@@ -1856,9 +1856,9 @@ sal_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 & SAL_FRAMESTATE_MAXIMIZED) )
-        if ( !(pState->mnState & (SAL_FRAMESTATE_MINIMIZED | SAL_FRAMESTATE_MAXIMIZED)) )
-            pState->mnState |= SAL_FRAMESTATE_NORMAL;
+        //if ( !(pState->mnState & WINDOWSTATE_STATE_MAXIMIZED) )
+        if ( !(pState->mnState & (WINDOWSTATE_STATE_MINIMIZED | WINDOWSTATE_STATE_MAXIMIZED)) )
+            pState->mnState |= WINDOWSTATE_STATE_NORMAL;
         return TRUE;
     }