vcl/source/window/syswin.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: syswin.cxx,v $
  10  * $Revision: 1.54 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_vcl.hxx"
  33 #include <tools/debug.hxx>
  34
  35 #ifndef _SV_SVSYS_HXX
  36 #include <svsys.h>
  37 #endif
  38 #include <vcl/salframe.hxx>
  39 #include <vcl/svdata.hxx>
  40 #include <vcl/svapp.hxx>
  41 #include <vcl/brdwin.hxx>
  42 #include <vcl/menu.hxx>
  43 #include <vcl/window.h>
  44 #include <vcl/brdwin.hxx>
  45 #include <vcl/sound.hxx>
  46 #include <vcl/svapp.hxx>
  47 #include <vcl/event.hxx>
  48 #include <vcl/syswin.hxx>
  49 #include <vcl/taskpanelist.hxx>
  50 #include <vcl/unowrap.hxx>
  51
  52
  53 using namespace ::com::sun::star::uno;
  54 using namespace ::com::sun::star::lang;
  55
  56 // =======================================================================
  57 class SystemWindow::ImplData
  58 {
  59 public:
  60     ImplData();
  61     ~ImplData();
  62
  63     TaskPaneList*   mpTaskPaneList;
  64     Size            maMaxOutSize;
  65 };
  66
  67 SystemWindow::ImplData::ImplData()
  68 {
  69     mpTaskPaneList = NULL;
  70     maMaxOutSize = Size( SHRT_MAX, SHRT_MAX );
  71 }
  72
  73 SystemWindow::ImplData::~ImplData()
  74 {
  75     if( mpTaskPaneList )
  76         delete mpTaskPaneList;
  77 }
  78
  79 // =======================================================================
  80
  81 SystemWindow::SystemWindow( WindowType nType ) :
  82     Window( nType )
  83 {
  84     mpImplData          = new ImplData;
  85     mpWindowImpl->mbSysWin            = TRUE;
  86     mpWindowImpl->mnActivateMode      = ACTIVATE_MODE_GRABFOCUS;
  87
  88     mpMenuBar           = NULL;
  89     mbPined             = FALSE;
  90     mbRollUp            = FALSE;
  91     mbRollFunc          = FALSE;
  92     mbDockBtn           = FALSE;
  93     mbHideBtn           = FALSE;
  94     mbSysChild          = FALSE;
  95     mnMenuBarMode       = MENUBAR_MODE_NORMAL;
  96     mnIcon              = 0;
  97 }
  98
  99 SystemWindow::~SystemWindow()
 100 {
 101     delete mpImplData;
 102     mpImplData = NULL;
 103 }
 104
 105 // -----------------------------------------------------------------------
 106
 107 long SystemWindow::Notify( NotifyEvent& rNEvt )
 108 {
 109     // capture KeyEvents for menu handling
 110     if ( rNEvt.GetType() == EVENT_KEYINPUT )
 111     {
 112         MenuBar* pMBar = mpMenuBar;
 113         if ( !pMBar && ( GetType() == WINDOW_FLOATINGWINDOW ) )
 114         {
 115             Window* pWin = ImplGetFrameWindow()->ImplGetWindow();
 116             if( pWin && pWin->IsSystemWindow() )
 117                 pMBar = ((SystemWindow*)pWin)->GetMenuBar();
 118         }
 119         if ( pMBar && pMBar->ImplHandleKeyEvent( *rNEvt.GetKeyEvent(), FALSE ) )
 120             return TRUE;
 121     }
 122
 123     return Window::Notify( rNEvt );
 124 }
 125
 126 // -----------------------------------------------------------------------
 127
 128 long SystemWindow::PreNotify( NotifyEvent& rNEvt )
 129 {
 130     // capture KeyEvents for taskpane cycling
 131     if ( rNEvt.GetType() == EVENT_KEYINPUT )
 132     {
 133         if( rNEvt.GetKeyEvent()->GetKeyCode().GetCode() == KEY_F6 &&
 134             rNEvt.GetKeyEvent()->GetKeyCode().IsMod1() &&
 135            !rNEvt.GetKeyEvent()->GetKeyCode().IsShift() )
 136         {
 137             // Ctrl-F6 goes directly to the document
 138             GrabFocusToDocument();
 139             return TRUE;
 140         }
 141         else
 142         {
 143             TaskPaneList *pTList = mpImplData->mpTaskPaneList;
 144             if( !pTList && ( GetType() == WINDOW_FLOATINGWINDOW ) )
 145             {
 146                 Window* pWin = ImplGetFrameWindow()->ImplGetWindow();
 147                 if( pWin && pWin->IsSystemWindow() )
 148                     pTList = ((SystemWindow*)pWin)->mpImplData->mpTaskPaneList;
 149             }
 150             if( !pTList )
 151             {
 152                 // search topmost system window which is the one to handle dialog/toolbar cycling
 153                 SystemWindow *pSysWin = this;
 154                 Window *pWin = this;
 155                 while( pWin )
 156                 {
 157                     pWin = pWin->GetParent();
 158                     if( pWin && pWin->IsSystemWindow() )
 159                         pSysWin = (SystemWindow*) pWin;
 160                 }
 161                 pTList = pSysWin->mpImplData->mpTaskPaneList;
 162             }
 163             if( pTList && pTList->HandleKeyEvent( *rNEvt.GetKeyEvent() ) )
 164                 return TRUE;
 165         }
 166     }
 167     return Window::PreNotify( rNEvt );
 168 }
 169
 170 // -----------------------------------------------------------------------
 171
 172 TaskPaneList* SystemWindow::GetTaskPaneList()
 173 {
 174     if( mpImplData->mpTaskPaneList )
 175         return mpImplData->mpTaskPaneList ;
 176     else
 177     {
 178         mpImplData->mpTaskPaneList = new TaskPaneList();
 179         MenuBar* pMBar = mpMenuBar;
 180         if ( !pMBar && ( GetType() == WINDOW_FLOATINGWINDOW ) )
 181         {
 182             Window* pWin = ImplGetFrameWindow()->ImplGetWindow();
 183             if ( pWin && pWin->IsSystemWindow() )
 184                 pMBar = ((SystemWindow*)pWin)->GetMenuBar();
 185         }
 186         if( pMBar )
 187             mpImplData->mpTaskPaneList->AddWindow( pMBar->ImplGetWindow() );
 188         return mpImplData->mpTaskPaneList;
 189     }
 190 }
 191
 192 // -----------------------------------------------------------------------
 193
 194 BOOL SystemWindow::Close()
 195 {
 196     ImplDelData aDelData;
 197     ImplAddDel( &aDelData );
 198     ImplCallEventListeners( VCLEVENT_WINDOW_CLOSE );
 199     if ( aDelData.IsDelete() )
 200         return FALSE;
 201     ImplRemoveDel( &aDelData );
 202
 203     if ( mpWindowImpl->mxWindowPeer.is() && IsCreatedWithToolkit() )
 204         return FALSE;
 205
 206     // Is Window not closeable, ignore close
 207     Window*     pBorderWin = ImplGetBorderWindow();
 208     WinBits     nStyle;
 209     if ( pBorderWin )
 210         nStyle = pBorderWin->GetStyle();
 211     else
 212         nStyle = GetStyle();
 213     if ( !(nStyle & WB_CLOSEABLE) )
 214     {
 215         Sound::Beep( SOUND_DISABLE, this );
 216         return FALSE;
 217     }
 218
 219     Hide();
 220
 221     return TRUE;
 222 }
 223
 224 // -----------------------------------------------------------------------
 225
 226 void SystemWindow::TitleButtonClick( USHORT )
 227 {
 228 }
 229
 230 // -----------------------------------------------------------------------
 231
 232 void SystemWindow::Pin()
 233 {
 234 }
 235
 236 // -----------------------------------------------------------------------
 237
 238 void SystemWindow::Roll()
 239 {
 240 }
 241
 242 // -----------------------------------------------------------------------
 243
 244 void SystemWindow::Resizing( Size& )
 245 {
 246 }
 247
 248 // -----------------------------------------------------------------------
 249
 250 void SystemWindow::SetZLevel( BYTE nLevel )
 251 {
 252     Window* pWindow = this;
 253     while ( pWindow->mpWindowImpl->mpBorderWindow )
 254         pWindow = pWindow->mpWindowImpl->mpBorderWindow;
 255     if ( pWindow->mpWindowImpl->mbOverlapWin && !pWindow->mpWindowImpl->mbFrame )
 256     {
 257         BYTE nOldLevel = pWindow->mpWindowImpl->mpOverlapData->mnTopLevel;
 258         pWindow->mpWindowImpl->mpOverlapData->mnTopLevel = nLevel;
 259         // Wenn der neue Level groesser als der alte ist, schieben
 260         // wir das Fenster nach hinten
 261         if ( !IsReallyVisible() && (nLevel > nOldLevel) && pWindow->mpWindowImpl->mpNext )
 262         {
 263             // Fenster aus der Liste entfernen
 264             if ( pWindow->mpWindowImpl->mpPrev )
 265                 pWindow->mpWindowImpl->mpPrev->mpWindowImpl->mpNext = pWindow->mpWindowImpl->mpNext;
 266             else
 267                 pWindow->mpWindowImpl->mpOverlapWindow->mpWindowImpl->mpFirstOverlap = pWindow->mpWindowImpl->mpNext;
 268             pWindow->mpWindowImpl->mpNext->mpWindowImpl->mpPrev = pWindow->mpWindowImpl->mpPrev;
 269             pWindow->mpWindowImpl->mpNext = NULL;
 270             // und Fenster wieder in die Liste am Ende eintragen
 271             pWindow->mpWindowImpl->mpPrev = pWindow->mpWindowImpl->mpOverlapWindow->mpWindowImpl->mpLastOverlap;
 272             pWindow->mpWindowImpl->mpOverlapWindow->mpWindowImpl->mpLastOverlap = pWindow;
 273             pWindow->mpWindowImpl->mpPrev->mpWindowImpl->mpNext = pWindow;
 274         }
 275     }
 276 }
 277
 278 // -----------------------------------------------------------------------
 279
 280 void SystemWindow::SetIcon( USHORT nIcon )
 281 {
 282     if ( mnIcon == nIcon )
 283         return;
 284
 285     mnIcon = nIcon;
 286
 287     if ( !mbSysChild )
 288     {
 289         const Window* pWindow = this;
 290         while ( pWindow->mpWindowImpl->mpBorderWindow )
 291             pWindow = pWindow->mpWindowImpl->mpBorderWindow;
 292
 293         if ( pWindow->mpWindowImpl->mbFrame )
 294             pWindow->mpWindowImpl->mpFrame->SetIcon( nIcon );
 295     }
 296 }
 297
 298 // -----------------------------------------------------------------------
 299
 300 BYTE SystemWindow::GetZLevel() const
 301 {
 302     const Window* pWindow = this;
 303     while ( pWindow->mpWindowImpl->mpBorderWindow )
 304         pWindow = pWindow->mpWindowImpl->mpBorderWindow;
 305     if ( pWindow->mpWindowImpl->mpOverlapData )
 306         return pWindow->mpWindowImpl->mpOverlapData->mnTopLevel;
 307     else
 308         return FALSE;
 309 }
 310
 311 // -----------------------------------------------------------------------
 312
 313 void SystemWindow::EnableSaveBackground( BOOL bSave )
 314 {
 315     if( ImplGetSVData()->maWinData.mbNoSaveBackground )
 316         bSave = false;
 317
 318     Window* pWindow = this;
 319     while ( pWindow->mpWindowImpl->mpBorderWindow )
 320         pWindow = pWindow->mpWindowImpl->mpBorderWindow;
 321     if ( pWindow->mpWindowImpl->mbOverlapWin && !pWindow->mpWindowImpl->mbFrame )
 322     {
 323         pWindow->mpWindowImpl->mpOverlapData->mbSaveBack = bSave;
 324         if ( !bSave )
 325             pWindow->ImplDeleteOverlapBackground();
 326     }
 327 }
 328
 329 // -----------------------------------------------------------------------
 330
 331 BOOL SystemWindow::IsSaveBackgroundEnabled() const
 332 {
 333     const Window* pWindow = this;
 334     while ( pWindow->mpWindowImpl->mpBorderWindow )
 335         pWindow = pWindow->mpWindowImpl->mpBorderWindow;
 336     if ( pWindow->mpWindowImpl->mpOverlapData )
 337         return pWindow->mpWindowImpl->mpOverlapData->mbSaveBack;
 338     else
 339         return FALSE;
 340 }
 341
 342 // -----------------------------------------------------------------------
 343
 344 void SystemWindow::ShowTitleButton( USHORT nButton, BOOL bVisible )
 345 {
 346     if ( nButton == TITLE_BUTTON_DOCKING )
 347     {
 348         if ( mbDockBtn != bVisible )
 349         {
 350             mbDockBtn = bVisible;
 351             if ( mpWindowImpl->mpBorderWindow )
 352                 ((ImplBorderWindow*)mpWindowImpl->mpBorderWindow)->SetDockButton( bVisible );
 353         }
 354     }
 355     else if ( nButton == TITLE_BUTTON_HIDE )
 356     {
 357         if ( mbHideBtn != bVisible )
 358         {
 359             mbHideBtn = bVisible;
 360             if ( mpWindowImpl->mpBorderWindow )
 361                 ((ImplBorderWindow*)mpWindowImpl->mpBorderWindow)->SetHideButton( bVisible );
 362         }
 363     }
 364     else if ( nButton == TITLE_BUTTON_MENU )
 365     {
 366         if ( mpWindowImpl->mpBorderWindow )
 367             ((ImplBorderWindow*)mpWindowImpl->mpBorderWindow)->SetMenuButton( bVisible );
 368     }
 369     else
 370         return;
 371 }
 372
 373 // -----------------------------------------------------------------------
 374
 375 BOOL SystemWindow::IsTitleButtonVisible( USHORT nButton ) const
 376 {
 377     if ( nButton == TITLE_BUTTON_DOCKING )
 378         return mbDockBtn;
 379     else /* if ( nButton == TITLE_BUTTON_HIDE ) */
 380         return mbHideBtn;
 381 }
 382
 383 // -----------------------------------------------------------------------
 384
 385 void SystemWindow::SetPin( BOOL bPin )
 386 {
 387     if ( bPin != mbPined )
 388     {
 389         mbPined = bPin;
 390         if ( mpWindowImpl->mpBorderWindow )
 391             ((ImplBorderWindow*)mpWindowImpl->mpBorderWindow)->SetPin( bPin );
 392     }
 393 }
 394
 395 // -----------------------------------------------------------------------
 396
 397 void SystemWindow::RollUp()
 398 {
 399     if ( !mbRollUp )
 400     {
 401         maOrgSize = GetOutputSizePixel();
 402         mbRollFunc = TRUE;
 403         Size aSize = maRollUpOutSize;
 404         if ( !aSize.Width() )
 405             aSize.Width() = GetOutputSizePixel().Width();
 406         mbRollUp = TRUE;
 407         if ( mpWindowImpl->mpBorderWindow )
 408             ((ImplBorderWindow*)mpWindowImpl->mpBorderWindow)->SetRollUp( TRUE, aSize );
 409         else
 410             SetOutputSizePixel( aSize );
 411         mbRollFunc = FALSE;
 412     }
 413 }
 414
 415 // -----------------------------------------------------------------------
 416
 417 void SystemWindow::RollDown()
 418 {
 419     if ( mbRollUp )
 420     {
 421         mbRollUp = FALSE;
 422         if ( mpWindowImpl->mpBorderWindow )
 423             ((ImplBorderWindow*)mpWindowImpl->mpBorderWindow)->SetRollUp( FALSE, maOrgSize );
 424         else
 425             SetOutputSizePixel( maOrgSize );
 426     }
 427 }
 428
 429 // -----------------------------------------------------------------------
 430
 431 void SystemWindow::SetMinOutputSizePixel( const Size& rSize )
 432 {
 433     maMinOutSize = rSize;
 434     if ( mpWindowImpl->mpBorderWindow )
 435     {
 436         ((ImplBorderWindow*)mpWindowImpl->mpBorderWindow)->SetMinOutputSize( rSize.Width(), rSize.Height() );
 437         if ( mpWindowImpl->mpBorderWindow->mpWindowImpl->mbFrame )
 438             mpWindowImpl->mpBorderWindow->mpWindowImpl->mpFrame->SetMinClientSize( rSize.Width(), rSize.Height() );
 439     }
 440     else if ( mpWindowImpl->mbFrame )
 441         mpWindowImpl->mpFrame->SetMinClientSize( rSize.Width(), rSize.Height() );
 442 }
 443
 444 // -----------------------------------------------------------------------
 445
 446 void SystemWindow::SetMaxOutputSizePixel( const Size& rSize )
 447 {
 448     Size aSize( rSize );
 449     if( aSize.Width() > SHRT_MAX || aSize.Width() <= 0 )
 450         aSize.Width() = SHRT_MAX;
 451     if( aSize.Height() > SHRT_MAX || aSize.Height() <= 0 )
 452         aSize.Height() = SHRT_MAX;
 453
 454     mpImplData->maMaxOutSize = aSize;
 455     if ( mpWindowImpl->mpBorderWindow )
 456     {
 457         ((ImplBorderWindow*)mpWindowImpl->mpBorderWindow)->SetMaxOutputSize( aSize.Width(), aSize.Height() );
 458         if ( mpWindowImpl->mpBorderWindow->mpWindowImpl->mbFrame )
 459             mpWindowImpl->mpBorderWindow->mpWindowImpl->mpFrame->SetMaxClientSize( aSize.Width(), aSize.Height() );
 460     }
 461     else if ( mpWindowImpl->mbFrame )
 462         mpWindowImpl->mpFrame->SetMaxClientSize( aSize.Width(), aSize.Height() );
 463 }
 464
 465 const Size& SystemWindow::GetMaxOutputSizePixel() const
 466 {
 467     return mpImplData->maMaxOutSize;
 468 }
 469 // -----------------------------------------------------------------------
 470
 471 Size SystemWindow::GetResizeOutputSizePixel() const
 472 {
 473     Size aSize = GetOutputSizePixel();
 474     if ( aSize.Width() < maMinOutSize.Width() )
 475         aSize.Width() = maMinOutSize.Width();
 476     if ( aSize.Height() < maMinOutSize.Height() )
 477         aSize.Height() = maMinOutSize.Height();
 478     return aSize;
 479 }
 480
 481 // -----------------------------------------------------------------------
 482
 483 static void ImplWindowStateFromStr( WindowStateData& rData, const ByteString& rStr )
 484 {
 485     ULONG       nValidMask  = 0;
 486     xub_StrLen  nIndex      = 0;
 487     ByteString  aTokenStr;
 488
 489     aTokenStr = rStr.GetToken( 0, ',', nIndex );
 490     if ( aTokenStr.Len() )
 491     {
 492         rData.SetX( aTokenStr.ToInt32() );
 493         if( rData.GetX() > -16384 && rData.GetX() < 16384 )
 494             nValidMask |= WINDOWSTATE_MASK_X;
 495         else
 496             rData.SetX( 0 );
 497     }
 498     else
 499         rData.SetX( 0 );
 500     aTokenStr = rStr.GetToken( 0, ',', nIndex );
 501     if ( aTokenStr.Len() )
 502     {
 503         rData.SetY( aTokenStr.ToInt32() );
 504         if( rData.GetY() > -16384 && rData.GetY() < 16384 )
 505             nValidMask |= WINDOWSTATE_MASK_Y;
 506         else
 507             rData.SetY( 0 );
 508     }
 509     else
 510         rData.SetY( 0 );
 511     aTokenStr = rStr.GetToken( 0, ',', nIndex );
 512     if ( aTokenStr.Len() )
 513     {
 514         rData.SetWidth( aTokenStr.ToInt32() );
 515         if( rData.GetWidth() > 0 && rData.GetWidth() < 16384 )
 516             nValidMask |= WINDOWSTATE_MASK_WIDTH;
 517         else
 518             rData.SetWidth( 0 );
 519     }
 520     else
 521         rData.SetWidth( 0 );
 522     aTokenStr = rStr.GetToken( 0, ';', nIndex );
 523     if ( aTokenStr.Len() )
 524     {
 525         rData.SetHeight( aTokenStr.ToInt32() );
 526         if( rData.GetHeight() > 0 && rData.GetHeight() < 16384 )
 527             nValidMask |= WINDOWSTATE_MASK_HEIGHT;
 528         else
 529             rData.SetHeight( 0 );
 530     }
 531     else
 532         rData.SetHeight( 0 );
 533     aTokenStr = rStr.GetToken( 0, ';', nIndex );
 534     if ( aTokenStr.Len() )
 535     {
 536         // #94144# allow Minimize again, should be masked out when read from configuration
 537         // 91625 - ignore Minimize
 538         ULONG nState = (ULONG)aTokenStr.ToInt32();
 539         //nState &= ~(WINDOWSTATE_STATE_MINIMIZED);
 540         rData.SetState( nState );
 541         nValidMask |= WINDOWSTATE_MASK_STATE;
 542     }
 543     else
 544         rData.SetState( 0 );
 545
 546     // read maximized pos/size
 547     aTokenStr = rStr.GetToken( 0, ',', nIndex );
 548     if ( aTokenStr.Len() )
 549     {
 550         rData.SetMaximizedX( aTokenStr.ToInt32() );
 551         if( rData.GetMaximizedX() > -16384 && rData.GetMaximizedX() < 16384 )
 552             nValidMask |= WINDOWSTATE_MASK_MAXIMIZED_X;
 553         else
 554             rData.SetMaximizedX( 0 );
 555     }
 556     else
 557         rData.SetMaximizedX( 0 );
 558     aTokenStr = rStr.GetToken( 0, ',', nIndex );
 559     if ( aTokenStr.Len() )
 560     {
 561         rData.SetMaximizedY( aTokenStr.ToInt32() );
 562         if( rData.GetMaximizedY() > -16384 && rData.GetMaximizedY() < 16384 )
 563             nValidMask |= WINDOWSTATE_MASK_MAXIMIZED_Y;
 564         else
 565             rData.SetMaximizedY( 0 );
 566     }
 567     else
 568         rData.SetMaximizedY( 0 );
 569     aTokenStr = rStr.GetToken( 0, ',', nIndex );
 570     if ( aTokenStr.Len() )
 571     {
 572         rData.SetMaximizedWidth( aTokenStr.ToInt32() );
 573         if( rData.GetMaximizedWidth() > 0 && rData.GetMaximizedWidth() < 16384 )
 574             nValidMask |= WINDOWSTATE_MASK_MAXIMIZED_WIDTH;
 575         else
 576             rData.SetMaximizedWidth( 0 );
 577     }
 578     else
 579         rData.SetMaximizedWidth( 0 );
 580     aTokenStr = rStr.GetToken( 0, ';', nIndex );
 581     if ( aTokenStr.Len() )
 582     {
 583         rData.SetMaximizedHeight( aTokenStr.ToInt32() );
 584         if( rData.GetMaximizedHeight() > 0 && rData.GetMaximizedHeight() < 16384 )
 585             nValidMask |= WINDOWSTATE_MASK_MAXIMIZED_HEIGHT;
 586         else
 587             rData.SetMaximizedHeight( 0 );
 588     }
 589     else
 590         rData.SetMaximizedHeight( 0 );
 591
 592     // mark valid fields
 593     rData.SetMask( nValidMask );
 594 }
 595
 596 // -----------------------------------------------------------------------
 597
 598 static void ImplWindowStateToStr( const WindowStateData& rData, ByteString& rStr )
 599 {
 600     ULONG nValidMask = rData.GetMask();
 601     if ( !nValidMask )
 602         return;
 603
 604     if ( nValidMask & WINDOWSTATE_MASK_X )
 605         rStr.Append( ByteString::CreateFromInt32( rData.GetX() ) );
 606     rStr.Append( ',' );
 607     if ( nValidMask & WINDOWSTATE_MASK_Y )
 608         rStr.Append( ByteString::CreateFromInt32( rData.GetY() ) );
 609     rStr.Append( ',' );
 610     if ( nValidMask & WINDOWSTATE_MASK_WIDTH )
 611         rStr.Append( ByteString::CreateFromInt32( rData.GetWidth() ) );
 612     rStr.Append( ',' );
 613     if ( nValidMask & WINDOWSTATE_MASK_HEIGHT )
 614         rStr.Append( ByteString::CreateFromInt32( rData.GetHeight() ) );
 615     rStr.Append( ';' );
 616     if ( nValidMask & WINDOWSTATE_MASK_STATE )
 617     {
 618         // #94144# allow Minimize again, should be masked out when read from configuration
 619         // 91625 - ignore Minimize
 620         ULONG nState = rData.GetState();
 621         //nState &= ~(WINDOWSTATE_STATE_MINIMIZED);
 622         rStr.Append( ByteString::CreateFromInt32( (long)nState ) );
 623     }
 624     rStr.Append( ';' );
 625     if ( nValidMask & WINDOWSTATE_MASK_MAXIMIZED_X )
 626         rStr.Append( ByteString::CreateFromInt32( rData.GetMaximizedX() ) );
 627     rStr.Append( ',' );
 628     if ( nValidMask & WINDOWSTATE_MASK_MAXIMIZED_Y )
 629         rStr.Append( ByteString::CreateFromInt32( rData.GetMaximizedY() ) );
 630     rStr.Append( ',' );
 631     if ( nValidMask & WINDOWSTATE_MASK_MAXIMIZED_WIDTH )
 632         rStr.Append( ByteString::CreateFromInt32( rData.GetMaximizedWidth() ) );
 633     rStr.Append( ',' );
 634     if ( nValidMask & WINDOWSTATE_MASK_MAXIMIZED_HEIGHT )
 635         rStr.Append( ByteString::CreateFromInt32( rData.GetMaximizedHeight() ) );
 636     rStr.Append( ';' );
 637 }
 638
 639 // -----------------------------------------------------------------------
 640
 641 void SystemWindow::SetWindowStateData( const WindowStateData& rData )
 642 {
 643     ULONG nValidMask = rData.GetMask();
 644     if ( !nValidMask )
 645         return;
 646
 647     if ( mbSysChild )
 648         return;
 649
 650     Window* pWindow = this;
 651     while ( pWindow->mpWindowImpl->mpBorderWindow )
 652         pWindow = pWindow->mpWindowImpl->mpBorderWindow;
 653
 654     if ( pWindow->mpWindowImpl->mbFrame )
 655     {
 656         ULONG           nState      = rData.GetState();
 657         SalFrameState   aState;
 658         aState.mnMask               = rData.GetMask();
 659         aState.mnX                  = rData.GetX();
 660         aState.mnY                  = rData.GetY();
 661         aState.mnWidth              = rData.GetWidth();
 662         aState.mnHeight             = rData.GetHeight();
 663
 664         if( rData.GetMask() & (WINDOWSTATE_MASK_WIDTH|WINDOWSTATE_MASK_HEIGHT) )
 665         {
 666             // #i43799# adjust window state sizes if a minimial output size was set
 667             // otherwise the frame and the client might get different sizes
 668             if( maMinOutSize.Width() > aState.mnWidth )
 669                 aState.mnWidth = maMinOutSize.Width();
 670             if( maMinOutSize.Height() > aState.mnHeight )
 671                 aState.mnHeight = maMinOutSize.Height();
 672         }
 673
 674         aState.mnMaximizedX         = rData.GetMaximizedX();
 675         aState.mnMaximizedY         = rData.GetMaximizedY();
 676         aState.mnMaximizedWidth     = rData.GetMaximizedWidth();
 677         aState.mnMaximizedHeight    = rData.GetMaximizedHeight();
 678         // #94144# allow Minimize again, should be masked out when read from configuration
 679         // 91625 - ignore Minimize
 680         //nState &= ~(WINDOWSTATE_STATE_MINIMIZED);
 681         aState.mnState  = nState & SAL_FRAMESTATE_SYSTEMMASK;
 682
 683         // #96568# avoid having multiple frames at the same screen location
 684         //  do the check only if not maximized
 685         if( !((rData.GetMask() & WINDOWSTATE_MASK_STATE) && (nState & WINDOWSTATE_STATE_MAXIMIZED)) )
 686             if( rData.GetMask() & (WINDOWSTATE_MASK_POS|WINDOWSTATE_MASK_WIDTH|WINDOWSTATE_MASK_HEIGHT) )
 687             {
 688                 Rectangle aDesktop = GetDesktopRectPixel();
 689                 ImplSVData *pSVData = ImplGetSVData();
 690                 Window *pWin = pSVData->maWinData.mpFirstFrame;
 691                 BOOL bWrapped = FALSE;
 692                 while( pWin )
 693                 {
 694                     if( !pWin->ImplIsRealParentPath( this ) &&
 695                         pWin->ImplGetWindow()->IsTopWindow() && pWin->mpWindowImpl->mbReallyVisible )
 696                     {
 697                         SalFrameGeometry g = pWin->mpWindowImpl->mpFrame->GetGeometry();
 698                         if( abs(g.nX-aState.mnX) < 2 && abs(g.nY-aState.mnY) < 5 )
 699                         {
 700                             long displacement = g.nTopDecoration ? g.nTopDecoration : 20;
 701                             if( (unsigned long) (aState.mnX + displacement + aState.mnWidth + g.nRightDecoration) > (unsigned long) aDesktop.nRight ||
 702                                 (unsigned long) (aState.mnY + displacement + aState.mnHeight + g.nBottomDecoration) > (unsigned long) aDesktop.nBottom )
 703                             {
 704                                 // displacing would leave screen
 705                                 aState.mnX = g.nLeftDecoration ? g.nLeftDecoration : 10; // should result in (0,0)
 706                                 aState.mnY = displacement;
 707                                 if( bWrapped ||
 708                                     (unsigned long) (aState.mnX + displacement + aState.mnWidth + g.nRightDecoration) > (unsigned long) aDesktop.nRight ||
 709                                     (unsigned long) (aState.mnY + displacement + aState.mnHeight + g.nBottomDecoration) > (unsigned long) aDesktop.nBottom )
 710                                     break;  // further displacement not possible -> break
 711                                 // avoid endless testing
 712                                 bWrapped = TRUE;
 713                             }
 714                             else
 715                             {
 716                                 // displace
 717                                 aState.mnX += displacement;
 718                                 aState.mnY += displacement;
 719                             }
 720                         pWin = pSVData->maWinData.mpFirstFrame; // check new pos again
 721                         }
 722                     }
 723                     pWin = pWin->mpWindowImpl->mpFrameData->mpNextFrame;
 724                 }
 725             }
 726
 727         mpWindowImpl->mpFrame->SetWindowState( &aState );
 728
 729         // do a synchronous resize for layout reasons
 730         //  but use rData only when the window is not to be maximized (#i38089#)
 731         //  otherwise we have no useful size information
 732         if( (rData.GetMask() & WINDOWSTATE_MASK_STATE) && (nState & WINDOWSTATE_STATE_MAXIMIZED) )
 733         {
 734             // query maximized size from frame
 735             SalFrameGeometry aGeometry = mpWindowImpl->mpFrame->GetGeometry();
 736
 737             // but use it only if it is different from the restore size (rData)
 738             // as currently only on windows the exact size of a maximized window
 739             //  can be computed without actually showing the window
 740             if( aGeometry.nWidth != rData.GetWidth() || aGeometry.nHeight != rData.GetHeight() )
 741                 ImplHandleResize( pWindow, aGeometry.nWidth, aGeometry.nHeight );
 742         }
 743         else
 744             if( rData.GetMask() & (WINDOWSTATE_MASK_WIDTH|WINDOWSTATE_MASK_HEIGHT) )
 745                 ImplHandleResize( pWindow, aState.mnWidth, aState.mnHeight );   // #i43799# use aState and not rData, see above
 746     }
 747     else
 748     {
 749         USHORT nPosSize = 0;
 750         if ( nValidMask & WINDOWSTATE_MASK_X )
 751             nPosSize |= WINDOW_POSSIZE_X;
 752         if ( nValidMask & WINDOWSTATE_MASK_Y )
 753             nPosSize |= WINDOW_POSSIZE_Y;
 754         if ( nValidMask & WINDOWSTATE_MASK_WIDTH )
 755             nPosSize |= WINDOW_POSSIZE_WIDTH;
 756         if ( nValidMask & WINDOWSTATE_MASK_HEIGHT )
 757             nPosSize |= WINDOW_POSSIZE_HEIGHT;
 758
 759         if( IsRollUp() )
 760             RollDown();
 761
 762         long nX                 = rData.GetX();
 763         long nY                 = rData.GetY();
 764         long nWidth             = rData.GetWidth();
 765         long nHeight    = rData.GetHeight();
 766         const SalFrameGeometry& rGeom = pWindow->mpWindowImpl->mpFrame->GetGeometry();
 767         if( nX < 0 )
 768             nX = 0;
 769         if( nX + nWidth > (long) rGeom.nWidth )
 770             nX = rGeom.nWidth - nWidth;
 771         if( nY < 0 )
 772             nY = 0;
 773         if( nY + nHeight > (long) rGeom.nHeight )
 774             nY = rGeom.nHeight - nHeight;
 775         SetPosSizePixel( nX, nY, nWidth, nHeight, nPosSize );
 776         maOrgSize = Size( nWidth, nHeight );
 777
 778         // 91625 - ignore Minimize
 779         if ( nValidMask & WINDOWSTATE_MASK_STATE )
 780         {
 781             ULONG nState = rData.GetState();
 782             if ( nState & WINDOWSTATE_STATE_ROLLUP )
 783                 RollUp();
 784             else
 785                 RollDown();
 786         }
 787     }
 788 }
 789
 790 // -----------------------------------------------------------------------
 791
 792 void SystemWindow::GetWindowStateData( WindowStateData& rData ) const
 793 {
 794     ULONG nValidMask = rData.GetMask();
 795     if ( !nValidMask )
 796         return;
 797
 798     if ( mbSysChild )
 799         return;
 800
 801     const Window* pWindow = this;
 802     while ( pWindow->mpWindowImpl->mpBorderWindow )
 803         pWindow = pWindow->mpWindowImpl->mpBorderWindow;
 804
 805     if ( pWindow->mpWindowImpl->mbFrame )
 806     {
 807         SalFrameState aState;
 808         aState.mnMask = 0xFFFFFFFF;
 809         if ( mpWindowImpl->mpFrame->GetWindowState( &aState ) )
 810         {
 811             if ( nValidMask & WINDOWSTATE_MASK_X )
 812                 rData.SetX( aState.mnX );
 813             if ( nValidMask & WINDOWSTATE_MASK_Y )
 814                 rData.SetY( aState.mnY );
 815             if ( nValidMask & WINDOWSTATE_MASK_WIDTH )
 816                 rData.SetWidth( aState.mnWidth );
 817             if ( nValidMask & WINDOWSTATE_MASK_HEIGHT )
 818                 rData.SetHeight( aState.mnHeight );
 819             if ( aState.mnMask & SAL_FRAMESTATE_MASK_MAXIMIZED_X )
 820             {
 821                 rData.SetMaximizedX( aState.mnMaximizedX );
 822                 nValidMask |= WINDOWSTATE_MASK_MAXIMIZED_X;
 823             }
 824             if ( aState.mnMask & SAL_FRAMESTATE_MASK_MAXIMIZED_Y )
 825             {
 826                 rData.SetMaximizedY( aState.mnMaximizedY );
 827                 nValidMask |= WINDOWSTATE_MASK_MAXIMIZED_Y;
 828             }
 829             if ( aState.mnMask & SAL_FRAMESTATE_MASK_MAXIMIZED_WIDTH )
 830             {
 831                 rData.SetMaximizedWidth( aState.mnMaximizedWidth );
 832                 nValidMask |= WINDOWSTATE_MASK_MAXIMIZED_WIDTH;
 833             }
 834             if ( aState.mnMask & SAL_FRAMESTATE_MASK_MAXIMIZED_HEIGHT )
 835             {
 836                 rData.SetMaximizedHeight( aState.mnMaximizedHeight );
 837                 nValidMask |= WINDOWSTATE_MASK_MAXIMIZED_HEIGHT;
 838             }
 839             if ( nValidMask & WINDOWSTATE_MASK_STATE )
 840             {
 841                 // #94144# allow Minimize again, should be masked out when read from configuration
 842                 // 91625 - ignore Minimize
 843                 if ( !(nValidMask&WINDOWSTATE_MASK_MINIMIZED) )
 844                     aState.mnState &= ~(WINDOWSTATE_STATE_MINIMIZED);
 845                 rData.SetState( aState.mnState );
 846             }
 847             rData.SetMask( nValidMask );
 848         }
 849         else
 850             rData.SetMask( 0 );
 851     }
 852     else
 853     {
 854         Point   aPos = GetPosPixel();
 855         Size    aSize = GetSizePixel();
 856         ULONG   nState = 0;
 857
 858         if ( IsRollUp() )
 859         {
 860             aSize.Height() += maOrgSize.Height();
 861             nState |= WINDOWSTATE_STATE_ROLLUP;
 862         }
 863
 864         if ( nValidMask & WINDOWSTATE_MASK_X )
 865             rData.SetX( aPos.X() );
 866         if ( nValidMask & WINDOWSTATE_MASK_Y )
 867             rData.SetY( aPos.Y() );
 868         if ( nValidMask & WINDOWSTATE_MASK_WIDTH )
 869             rData.SetWidth( aSize.Width() );
 870         if ( nValidMask & WINDOWSTATE_MASK_HEIGHT )
 871             rData.SetHeight( aSize.Height() );
 872         if ( nValidMask & WINDOWSTATE_MASK_STATE )
 873             rData.SetState( nState );
 874     }
 875 }
 876
 877 // -----------------------------------------------------------------------
 878
 879 void SystemWindow::SetWindowState( const ByteString& rStr )
 880 {
 881     if ( !rStr.Len() )
 882         return;
 883
 884     WindowStateData aData;
 885     ImplWindowStateFromStr( aData, rStr );
 886     SetWindowStateData( aData );
 887 }
 888
 889 // -----------------------------------------------------------------------
 890
 891 ByteString SystemWindow::GetWindowState( ULONG nMask ) const
 892 {
 893     WindowStateData aData;
 894     aData.SetMask( nMask );
 895     GetWindowStateData( aData );
 896
 897     ByteString aStr;
 898     ImplWindowStateToStr( aData, aStr );
 899     return aStr;
 900 }
 901
 902 // -----------------------------------------------------------------------
 903
 904 void SystemWindow::SetMenuBar( MenuBar* pMenuBar )
 905 {
 906     if ( mpMenuBar != pMenuBar )
 907     {
 908         MenuBar* pOldMenuBar = mpMenuBar;
 909         Window*  pOldWindow = NULL;
 910         Window*  pNewWindow=NULL;
 911         mpMenuBar = pMenuBar;
 912
 913         if ( mpWindowImpl->mpBorderWindow && (mpWindowImpl->mpBorderWindow->GetType() == WINDOW_BORDERWINDOW) )
 914         {
 915             if ( pOldMenuBar )
 916                 pOldWindow = pOldMenuBar->ImplGetWindow();
 917             else
 918                 pOldWindow = NULL;
 919             if ( pOldWindow )
 920             {
 921                 ImplCallEventListeners( VCLEVENT_WINDOW_MENUBARREMOVED, (void*) pOldMenuBar );
 922                 pOldWindow->SetAccessible( ::com::sun::star::uno::Reference< ::com::sun::star::accessibility::XAccessible >() );
 923             }
 924             if ( pMenuBar )
 925             {
 926                 DBG_ASSERT( !pMenuBar->pWindow, "SystemWindow::SetMenuBar() - MenuBars can only set in one SystemWindow at time" );
 927                 ((ImplBorderWindow*)mpWindowImpl->mpBorderWindow)->SetMenuBarWindow( pNewWindow = MenuBar::ImplCreate( mpWindowImpl->mpBorderWindow, pOldWindow, pMenuBar ) );
 928                 ImplCallEventListeners( VCLEVENT_WINDOW_MENUBARADDED, (void*) pMenuBar );
 929             }
 930             else
 931                 ((ImplBorderWindow*)mpWindowImpl->mpBorderWindow)->SetMenuBarWindow( NULL );
 932             ImplToBottomChild();
 933             if ( pOldMenuBar )
 934             {
 935                 BOOL bDelete = (pMenuBar == 0) ? TRUE : FALSE;
 936                 if( bDelete && pOldWindow )
 937                 {
 938                     if( mpImplData->mpTaskPaneList )
 939                         mpImplData->mpTaskPaneList->RemoveWindow( pOldWindow );
 940                 }
 941                 MenuBar::ImplDestroy( pOldMenuBar, bDelete );
 942                 if( bDelete )
 943                     pOldWindow = NULL;  // will be deleted in MenuBar::ImplDestroy,
 944             }
 945
 946         }
 947         else
 948         {
 949             if( pMenuBar )
 950                 pNewWindow = pMenuBar->ImplGetWindow();
 951             if( pOldMenuBar )
 952                 pOldWindow = pOldMenuBar->ImplGetWindow();
 953         }
 954
 955         // update taskpane list to make menubar accessible
 956         if( mpImplData->mpTaskPaneList )
 957         {
 958             if( pOldWindow )
 959                 mpImplData->mpTaskPaneList->RemoveWindow( pOldWindow );
 960             if( pNewWindow )
 961                 mpImplData->mpTaskPaneList->AddWindow( pNewWindow );
 962         }
 963     }
 964 }
 965
 966 // -----------------------------------------------------------------------
 967
 968 void SystemWindow::SetMenuBarMode( USHORT nMode )
 969 {
 970     if ( mnMenuBarMode != nMode )
 971     {
 972         mnMenuBarMode = nMode;
 973         if ( mpWindowImpl->mpBorderWindow && (mpWindowImpl->mpBorderWindow->GetType() == WINDOW_BORDERWINDOW) )
 974         {
 975             if ( nMode == MENUBAR_MODE_HIDE )
 976                 ((ImplBorderWindow*)mpWindowImpl->mpBorderWindow)->SetMenuBarMode( TRUE );
 977             else
 978                 ((ImplBorderWindow*)mpWindowImpl->mpBorderWindow)->SetMenuBarMode( FALSE );
 979         }
 980     }
 981 }
 982
 983 // -----------------------------------------------------------------------
 984
 985 BOOL SystemWindow::ImplIsInTaskPaneList( Window* pWin )
 986 {
 987     if( mpImplData && mpImplData->mpTaskPaneList )
 988         return mpImplData->mpTaskPaneList->IsInList( pWin );
 989     return FALSE;
 990 }
 991
 992 // -----------------------------------------------------------------------
 993
 994 unsigned int SystemWindow::GetScreenNumber() const
 995 {
 996     return mpWindowImpl->mpFrame->maGeometry.nScreenNumber;
 997 }
 998
 999 // -----------------------------------------------------------------------
1000
1001 void SystemWindow::SetScreenNumber( unsigned int nScreen)
1002 {
1003     mpWindowImpl->mpFrame->SetScreenNumber( nScreen );
1004 }