framework/source/layoutmanager/layoutmanager.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <config_features.h>
  21
  22 #include <services/layoutmanager.hxx>
  23 #include "helpers.hxx"
  24
  25 #include <framework/sfxhelperfunctions.hxx>
  26 #include <uielement/menubarwrapper.hxx>
  27 #include <framework/addonsoptions.hxx>
  28 #include <classes/fwkresid.hxx>
  29 #include <classes/resource.hrc>
  30 #include <toolkit/helper/convert.hxx>
  31 #include <uielement/progressbarwrapper.hxx>
  32 #include <uiconfiguration/globalsettings.hxx>
  33 #include <uiconfiguration/windowstateproperties.hxx>
  34 #include "toolbarlayoutmanager.hxx"
  35
  36 #include <com/sun/star/beans/XPropertySet.hpp>
  37 #include <com/sun/star/beans/PropertyAttribute.hpp>
  38 #include <com/sun/star/frame/ModuleManager.hpp>
  39 #include <com/sun/star/frame/XModel.hpp>
  40 #include <com/sun/star/frame/FrameAction.hpp>
  41 #include <com/sun/star/lang/XMultiComponentFactory.hpp>
  42 #include <com/sun/star/awt/XTopWindow.hpp>
  43 #include <com/sun/star/awt/XSystemDependentMenuPeer.hpp>
  44 #include <com/sun/star/lang/SystemDependent.hpp>
  45 #include <com/sun/star/awt/VclWindowPeerAttribute.hpp>
  46 #include <com/sun/star/awt/PosSize.hpp>
  47 #include <com/sun/star/awt/XDevice.hpp>
  48 #include <com/sun/star/awt/XSystemDependentWindowPeer.hpp>
  49 #include <com/sun/star/ui/theModuleUIConfigurationManagerSupplier.hpp>
  50 #include <com/sun/star/ui/XUIConfigurationManagerSupplier.hpp>
  51 #include <com/sun/star/ui/UIElementType.hpp>
  52 #include <com/sun/star/ui/theWindowStateConfiguration.hpp>
  53 #include <com/sun/star/ui/theUIElementFactoryManager.hpp>
  54 #include <com/sun/star/container/XNameReplace.hpp>
  55 #include <com/sun/star/container/XNameContainer.hpp>
  56 #include <com/sun/star/frame/LayoutManagerEvents.hpp>
  57 #include <com/sun/star/frame/XDispatchProvider.hpp>
  58 #include <com/sun/star/frame/DispatchHelper.hpp>
  59 #include <com/sun/star/lang/DisposedException.hpp>
  60 #include <com/sun/star/util/URLTransformer.hpp>
  61
  62 #include <comphelper/processfactory.hxx>
  63 #include <comphelper/lok.hxx>
  64 #include <svtools/imgdef.hxx>
  65 #include <tools/diagnose_ex.h>
  66 #include <vcl/window.hxx>
  67 #include <vcl/wrkwin.hxx>
  68 #include <vcl/dockingarea.hxx>
  69 #include <vcl/svapp.hxx>
  70 #include <vcl/i18nhelp.hxx>
  71 #include <vcl/wall.hxx>
  72 #include <toolkit/helper/vclunohelper.hxx>
  73 #include <toolkit/awt/vclxwindow.hxx>
  74 #include <toolkit/awt/vclxmenu.hxx>
  75 #include <comphelper/uno3.hxx>
  76 #include <rtl/instance.hxx>
  77 #include <unotools/cmdoptions.hxx>
  78
  79 #include <rtl/ref.hxx>
  80 #include <rtl/strbuf.hxx>
  81
  82 #include <algorithm>
  83 #include <boost/utility.hpp>
  84
  85 //      using namespace
  86 using namespace ::com::sun::star;
  87 using namespace ::com::sun::star::uno;
  88 using namespace ::com::sun::star::beans;
  89 using namespace ::com::sun::star::util;
  90 using namespace ::com::sun::star::lang;
  91 using namespace ::com::sun::star::container;
  92 using namespace ::com::sun::star::ui;
  93 using namespace ::com::sun::star::frame;
  94
  95 static const char STATUS_BAR_ALIAS[] = "private:resource/statusbar/statusbar";
  96 static const char PROGRESS_BAR_ALIAS[] = "private:resource/progressbar/progressbar";
  97
  98 namespace framework
  99 {
 100
 101 IMPLEMENT_FORWARD_XTYPEPROVIDER2( LayoutManager, LayoutManager_Base, LayoutManager_PBase )
 102 IMPLEMENT_FORWARD_XINTERFACE2( LayoutManager, LayoutManager_Base, LayoutManager_PBase )
 103
 104 LayoutManager::LayoutManager( const Reference< XComponentContext >& xContext ) : LayoutManager_Base()
 105         , ::cppu::OBroadcastHelperVar< ::cppu::OMultiTypeInterfaceContainerHelper, ::cppu::OMultiTypeInterfaceContainerHelper::keyType >(m_aMutex)
 106         , LayoutManager_PBase( *(static_cast< ::cppu::OBroadcastHelper* >(this)) )
 107         , m_xContext( xContext )
 108         , m_xURLTransformer( URLTransformer::create(xContext) )
 109         , m_nLockCount( 0 )
 110         , m_bActive( false )
 111         , m_bInplaceMenuSet( false )
 112         , m_bDockingInProgress( false )
 113         , m_bMenuVisible( true )
 114         , m_bComponentAttached( false )
 115         , m_bDoLayout( false )
 116         , m_bVisible( true )
 117         , m_bParentWindowVisible( false )
 118         , m_bMustDoLayout( true )
 119 #if HAVE_FEATURE_DESKTOP
 120         , m_bAutomaticToolbars( true )
 121 #else
 122         , m_bAutomaticToolbars( false )
 123 #endif
 124         , m_bStoreWindowState( false )
 125         , m_bHideCurrentUI( false )
 126         , m_bGlobalSettings( false )
 127         , m_bPreserveContentSize( false )
 128         , m_bMenuBarCloseButton( false )
 129         , m_pInplaceMenuBar( NULL )
 130         , m_xModuleManager( ModuleManager::create( xContext ))
 131         , m_xUIElementFactoryManager( ui::theUIElementFactoryManager::get(xContext) )
 132         , m_xPersistentWindowStateSupplier( ui::theWindowStateConfiguration::get( xContext ) )
 133         , m_pGlobalSettings( 0 )
 134         , m_aListenerContainer( m_aMutex )
 135         , m_pToolbarManager( 0 )
 136         , m_xToolbarManager( 0 )
 137 {
 138     // Initialize statusbar member
 139     const sal_Bool bRefreshVisibility = sal_False;
 140     m_aStatusBarElement.m_aType = "statusbar";
 141     m_aStatusBarElement.m_aName = STATUS_BAR_ALIAS;
 142
 143     if (!comphelper::LibreOfficeKit::isActive())
 144     {
 145         m_pToolbarManager = new ToolbarLayoutManager( xContext, Reference<XUIElementFactory>(m_xUIElementFactoryManager, UNO_QUERY_THROW), this );
 146         m_xToolbarManager = uno::Reference< ui::XUIConfigurationListener >( static_cast< OWeakObject* >( m_pToolbarManager ), uno::UNO_QUERY );
 147     }
 148
 149     Application::AddEventListener( LINK( this, LayoutManager, SettingsChanged ) );
 150
 151     m_aAsyncLayoutTimer.SetTimeout( 50 );
 152     m_aAsyncLayoutTimer.SetTimeoutHdl( LINK( this, LayoutManager, AsyncLayoutHdl ) );
 153
 154     registerProperty( LAYOUTMANAGER_PROPNAME_AUTOMATICTOOLBARS, LAYOUTMANAGER_PROPHANDLE_AUTOMATICTOOLBARS, css::beans::PropertyAttribute::TRANSIENT, &m_bAutomaticToolbars, cppu::UnoType<decltype(m_bAutomaticToolbars)>::get() );
 155     registerProperty( LAYOUTMANAGER_PROPNAME_HIDECURRENTUI, LAYOUTMANAGER_PROPHANDLE_HIDECURRENTUI, beans::PropertyAttribute::TRANSIENT, &m_bHideCurrentUI, cppu::UnoType<decltype(m_bHideCurrentUI)>::get() );
 156     registerProperty( LAYOUTMANAGER_PROPNAME_LOCKCOUNT, LAYOUTMANAGER_PROPHANDLE_LOCKCOUNT, beans::PropertyAttribute::TRANSIENT | beans::PropertyAttribute::READONLY, &m_nLockCount, cppu::UnoType<decltype(m_nLockCount)>::get()  );
 157     registerProperty( LAYOUTMANAGER_PROPNAME_MENUBARCLOSER, LAYOUTMANAGER_PROPHANDLE_MENUBARCLOSER, beans::PropertyAttribute::TRANSIENT, &m_bMenuBarCloseButton, cppu::UnoType<decltype(m_bMenuBarCloseButton)>::get() );
 158     registerPropertyNoMember( LAYOUTMANAGER_PROPNAME_REFRESHVISIBILITY, LAYOUTMANAGER_PROPHANDLE_REFRESHVISIBILITY, beans::PropertyAttribute::TRANSIENT, cppu::UnoType<decltype(bRefreshVisibility)>::get(), &bRefreshVisibility );
 159     registerProperty( LAYOUTMANAGER_PROPNAME_PRESERVE_CONTENT_SIZE, LAYOUTMANAGER_PROPHANDLE_PRESERVE_CONTENT_SIZE, beans::PropertyAttribute::TRANSIENT, &m_bPreserveContentSize, cppu::UnoType<decltype(m_bPreserveContentSize)>::get() );
 160 }
 161
 162 LayoutManager::~LayoutManager()
 163 {
 164     Application::RemoveEventListener( LINK( this, LayoutManager, SettingsChanged ) );
 165     m_aAsyncLayoutTimer.Stop();
 166     setDockingAreaAcceptor(NULL);
 167     delete m_pGlobalSettings;
 168 }
 169
 170 // Internal helper function
 171 void LayoutManager::impl_clearUpMenuBar()
 172 {
 173     implts_lock();
 174
 175     // Clear up VCL menu bar to prepare shutdown
 176     if ( m_xContainerWindow.is() )
 177     {
 178         SolarMutexGuard aGuard;
 179
 180         SystemWindow* pSysWindow = getTopSystemWindow( m_xContainerWindow );
 181         if ( pSysWindow )
 182         {
 183             MenuBar* pSetMenuBar = 0;
 184             if ( m_xInplaceMenuBar.is() )
 185                 pSetMenuBar = static_cast<MenuBar *>(m_pInplaceMenuBar->GetMenuBar());
 186             else
 187             {
 188                 Reference< awt::XMenuBar > xMenuBar;
 189
 190                 Reference< XPropertySet > xPropSet( m_xMenuBar, UNO_QUERY );
 191                 if ( xPropSet.is() )
 192                 {
 193                     try
 194                     {
 195                         xPropSet->getPropertyValue("XMenuBar") >>= xMenuBar;
 196                     }
 197                     catch (const beans::UnknownPropertyException&)
 198                     {
 199                     }
 200                     catch (const lang::WrappedTargetException&)
 201                     {
 202                     }
 203                 }
 204
 205                 VCLXMenu* pAwtMenuBar = VCLXMenu::GetImplementation( xMenuBar );
 206                 if ( pAwtMenuBar )
 207                     pSetMenuBar = static_cast<MenuBar*>(pAwtMenuBar->GetMenu());
 208             }
 209
 210             MenuBar* pTopMenuBar = pSysWindow->GetMenuBar();
 211             if ( pSetMenuBar == pTopMenuBar )
 212                 pSysWindow->SetMenuBar( 0 );
 213         }
 214     }
 215
 216     // reset inplace menubar manager
 217     m_pInplaceMenuBar = 0;
 218     if ( m_xInplaceMenuBar.is() )
 219     {
 220         m_xInplaceMenuBar->dispose();
 221         m_xInplaceMenuBar.clear();
 222     }
 223
 224     Reference< XComponent > xComp( m_xMenuBar, UNO_QUERY );
 225     if ( xComp.is() )
 226         xComp->dispose();
 227     m_xMenuBar.clear();
 228     implts_unlock();
 229 }
 230
 231 void LayoutManager::implts_lock()
 232 {
 233     SolarMutexGuard g;
 234     ++m_nLockCount;
 235 }
 236
 237 bool LayoutManager::implts_unlock()
 238 {
 239     SolarMutexGuard g;
 240     m_nLockCount = std::max( m_nLockCount-1, static_cast<sal_Int32>(0) );
 241     return ( m_nLockCount == 0 );
 242 }
 243
 244 void LayoutManager::implts_reset( bool bAttached )
 245 {
 246     /* SAFE AREA ----------------------------------------------------------------------------------------------- */
 247     SolarMutexClearableGuard aReadLock;
 248     Reference< XFrame > xFrame = m_xFrame;
 249     Reference< awt::XWindow > xContainerWindow( m_xContainerWindow );
 250     Reference< XUIConfiguration > xModuleCfgMgr( m_xModuleCfgMgr, UNO_QUERY );
 251     Reference< XUIConfiguration > xDocCfgMgr( m_xDocCfgMgr, UNO_QUERY );
 252     Reference< XNameAccess > xPersistentWindowState( m_xPersistentWindowState );
 253     Reference< XComponentContext > xContext( m_xContext );
 254     Reference< XNameAccess > xPersistentWindowStateSupplier( m_xPersistentWindowStateSupplier );
 255     ToolbarLayoutManager* pToolbarManager( m_pToolbarManager );
 256     OUString aModuleIdentifier( m_aModuleIdentifier );
 257     bool bAutomaticToolbars( m_bAutomaticToolbars );
 258     aReadLock.clear();
 259     /* SAFE AREA ----------------------------------------------------------------------------------------------- */
 260
 261     implts_lock();
 262
 263     Reference< XModel > xModel;
 264     if ( xFrame.is() )
 265     {
 266         if ( bAttached )
 267         {
 268             OUString aOldModuleIdentifier( aModuleIdentifier );
 269             try
 270             {
 271                 aModuleIdentifier = m_xModuleManager->identify( xFrame );
 272             }
 273             catch( const Exception& ) {}
 274
 275             if ( !aModuleIdentifier.isEmpty() && aOldModuleIdentifier != aModuleIdentifier )
 276             {
 277                 Reference< XModuleUIConfigurationManagerSupplier > xModuleCfgSupplier;
 278                 if ( xContext.is() )
 279                     xModuleCfgSupplier = theModuleUIConfigurationManagerSupplier::get( xContext );
 280
 281                 if ( xModuleCfgMgr.is() )
 282                 {
 283                     try
 284                     {
 285                         // Remove listener to old module ui configuration manager
 286                         xModuleCfgMgr->removeConfigurationListener( Reference< XUIConfigurationListener >( static_cast< OWeakObject* >( this ), UNO_QUERY ));
 287                     }
 288                     catch (const Exception&)
 289                     {
 290                     }
 291                 }
 292
 293                 try
 294                 {
 295                     // Add listener to new module ui configuration manager
 296                     xModuleCfgMgr = Reference< XUIConfiguration >( xModuleCfgSupplier->getUIConfigurationManager( aModuleIdentifier ), UNO_QUERY );
 297                     if ( xModuleCfgMgr.is() )
 298                         xModuleCfgMgr->addConfigurationListener( Reference< XUIConfigurationListener >( static_cast< OWeakObject* >( this ), UNO_QUERY ));
 299                 }
 300                 catch (const Exception&)
 301                 {
 302                 }
 303
 304                 try
 305                 {
 306                     // Retrieve persistent window state reference for our new module
 307                     if ( xPersistentWindowStateSupplier.is() )
 308                         xPersistentWindowStateSupplier->getByName( aModuleIdentifier ) >>= xPersistentWindowState;
 309                 }
 310                 catch (const NoSuchElementException&)
 311                 {
 312                 }
 313                 catch (const WrappedTargetException&)
 314                 {
 315                 }
 316             }
 317
 318             xModel = impl_getModelFromFrame( xFrame );
 319             if ( xModel.is() )
 320             {
 321                 Reference< XUIConfigurationManagerSupplier > xUIConfigurationManagerSupplier( xModel, UNO_QUERY );
 322                 if ( xUIConfigurationManagerSupplier.is() )
 323                 {
 324                     if ( xDocCfgMgr.is() )
 325                     {
 326                         try
 327                         {
 328                             // Remove listener to old ui configuration manager
 329                             xDocCfgMgr->removeConfigurationListener( Reference< XUIConfigurationListener >( static_cast< OWeakObject* >( this ), UNO_QUERY ));
 330                         }
 331                         catch (const Exception&)
 332                         {
 333                         }
 334                     }
 335
 336                     try
 337                     {
 338                         xDocCfgMgr = Reference< XUIConfiguration >( xUIConfigurationManagerSupplier->getUIConfigurationManager(), UNO_QUERY );
 339                         if ( xDocCfgMgr.is() )
 340                             xDocCfgMgr->addConfigurationListener( Reference< XUIConfigurationListener >( static_cast< OWeakObject* >( this ), UNO_QUERY ));
 341                     }
 342                     catch (const Exception&)
 343                     {
 344                     }
 345                 }
 346             }
 347         }
 348         else
 349         {
 350             // Remove configuration listeners before we can release our references
 351             if ( xModuleCfgMgr.is() )
 352             {
 353                 try
 354                 {
 355                     xModuleCfgMgr->removeConfigurationListener(
 356                         Reference< XUIConfigurationListener >( static_cast< OWeakObject* >( this ), UNO_QUERY ));
 357                 }
 358                 catch (const Exception&)
 359                 {
 360                 }
 361             }
 362
 363             if ( xDocCfgMgr.is() )
 364             {
 365                 try
 366                 {
 367                     xDocCfgMgr->removeConfigurationListener(
 368                         Reference< XUIConfigurationListener >( static_cast< OWeakObject* >( this ), UNO_QUERY ));
 369                 }
 370                 catch (const Exception&)
 371                 {
 372                 }
 373             }
 374
 375             // Release references to our configuration managers as we currently don't have
 376             // an attached module.
 377             xModuleCfgMgr.clear();
 378             xDocCfgMgr.clear();
 379             xPersistentWindowState.clear();
 380             aModuleIdentifier.clear();
 381         }
 382
 383         Reference< XUIConfigurationManager > xModCfgMgr( xModuleCfgMgr, UNO_QUERY );
 384         Reference< XUIConfigurationManager > xDokCfgMgr( xDocCfgMgr, UNO_QUERY );
 385
 386         /* SAFE AREA ----------------------------------------------------------------------------------------------- */
 387         SolarMutexClearableGuard aWriteLock;
 388         m_xModel = xModel;
 389         m_aDockingArea = awt::Rectangle();
 390         m_bComponentAttached = bAttached;
 391         m_aModuleIdentifier = aModuleIdentifier;
 392         m_xModuleCfgMgr = xModCfgMgr;
 393         m_xDocCfgMgr = xDokCfgMgr;
 394         m_xPersistentWindowState = xPersistentWindowState;
 395         m_aStatusBarElement.m_bStateRead = false; // reset state to read data again!
 396         aWriteLock.clear();
 397         /* SAFE AREA ----------------------------------------------------------------------------------------------- */
 398
 399         // reset/notify toolbar layout manager
 400         if ( pToolbarManager )
 401         {
 402             if ( bAttached )
 403             {
 404                 pToolbarManager->attach( xFrame, xModCfgMgr, xDokCfgMgr, xPersistentWindowState );
 405                 uno::Reference< awt::XWindowPeer > xParent( xContainerWindow, UNO_QUERY );
 406                 pToolbarManager->setParentWindow( xParent );
 407                 if ( bAutomaticToolbars )
 408                     pToolbarManager->createStaticToolbars();
 409             }
 410             else
 411             {
 412                 pToolbarManager->reset();
 413                 implts_destroyElements();
 414             }
 415         }
 416     }
 417
 418     implts_unlock();
 419 }
 420
 421 bool LayoutManager::implts_isEmbeddedLayoutManager() const
 422 {
 423     SolarMutexClearableGuard aReadLock;
 424     Reference< XFrame > xFrame = m_xFrame;
 425     Reference< awt::XWindow > xContainerWindow( m_xContainerWindow );
 426     aReadLock.clear();
 427
 428     Reference< awt::XWindow > xFrameContainerWindow = xFrame->getContainerWindow();
 429     if ( xFrameContainerWindow == xContainerWindow )
 430         return false;
 431     else
 432         return true;
 433 }
 434
 435 void LayoutManager::implts_destroyElements()
 436 {
 437     SolarMutexResettableGuard aWriteLock;
 438     ToolbarLayoutManager* pToolbarManager = m_pToolbarManager;
 439     aWriteLock.clear();
 440
 441     if ( pToolbarManager )
 442         pToolbarManager->destroyToolbars();
 443
 444     implts_destroyStatusBar();
 445
 446     aWriteLock.reset();
 447     impl_clearUpMenuBar();
 448     aWriteLock.clear();
 449 }
 450
 451 void LayoutManager::implts_toggleFloatingUIElementsVisibility( bool bActive )
 452 {
 453     SolarMutexClearableGuard aReadLock;
 454     ToolbarLayoutManager* pToolbarManager = m_pToolbarManager;
 455     aReadLock.clear();
 456
 457     if ( pToolbarManager )
 458         pToolbarManager->setFloatingToolbarsVisibility( bActive );
 459 }
 460
 461 uno::Reference< ui::XUIElement > LayoutManager::implts_findElement( const OUString& aName )
 462 {
 463     OUString aElementType;
 464     OUString aElementName;
 465
 466     parseResourceURL( aName, aElementType, aElementName );
 467     if ( aElementType.equalsIgnoreAsciiCase("menubar") &&
 468          aElementName.equalsIgnoreAsciiCase("menubar") )
 469         return m_xMenuBar;
 470     else if (( aElementType.equalsIgnoreAsciiCase("statusbar") &&
 471                aElementName.equalsIgnoreAsciiCase("statusbar") ) ||
 472              ( m_aStatusBarElement.m_aName == aName ))
 473         return m_aStatusBarElement.m_xUIElement;
 474     else if ( aElementType.equalsIgnoreAsciiCase("progressbar") &&
 475               aElementName.equalsIgnoreAsciiCase("progressbar") )
 476         return m_aProgressBarElement.m_xUIElement;
 477
 478     return uno::Reference< ui::XUIElement >();
 479 }
 480
 481 bool LayoutManager::implts_readWindowStateData( const OUString& aName, UIElement& rElementData )
 482 {
 483     return readWindowStateData( aName, rElementData, m_xPersistentWindowState,
 484             m_pGlobalSettings, m_bGlobalSettings, m_xContext );
 485 }
 486
 487 bool LayoutManager::readWindowStateData( const OUString& aName, UIElement& rElementData,
 488         const Reference< XNameAccess > &rPersistentWindowState,
 489         GlobalSettings* &rGlobalSettings, bool &bInGlobalSettings,
 490         const Reference< XComponentContext > &rComponentContext )
 491 {
 492     bool bGetSettingsState( false );
 493
 494     SolarMutexResettableGuard aWriteLock;
 495     Reference< XNameAccess > xPersistentWindowState( rPersistentWindowState );
 496     aWriteLock.clear();
 497
 498     if ( xPersistentWindowState.is() )
 499     {
 500         aWriteLock.reset();
 501         bool bGlobalSettings( bInGlobalSettings );
 502         GlobalSettings* pGlobalSettings( 0 );
 503         if ( rGlobalSettings == 0 )
 504         {
 505             rGlobalSettings = new GlobalSettings( rComponentContext );
 506             bGetSettingsState = true;
 507         }
 508         pGlobalSettings = rGlobalSettings;
 509         aWriteLock.clear();
 510
 511         try
 512         {
 513             Sequence< PropertyValue > aWindowState;
 514             if ( xPersistentWindowState->hasByName( aName ) && (xPersistentWindowState->getByName( aName ) >>= aWindowState) )
 515             {
 516                 bool bValue( false );
 517                 for ( sal_Int32 n = 0; n < aWindowState.getLength(); n++ )
 518                 {
 519                     if ( aWindowState[n].Name == WINDOWSTATE_PROPERTY_DOCKED )
 520                     {
 521                         if ( aWindowState[n].Value >>= bValue )
 522                             rElementData.m_bFloating = !bValue;
 523                     }
 524                     else if ( aWindowState[n].Name == WINDOWSTATE_PROPERTY_VISIBLE )
 525                     {
 526                         if ( aWindowState[n].Value >>= bValue )
 527                             rElementData.m_bVisible = bValue;
 528                     }
 529                     else if ( aWindowState[n].Name == WINDOWSTATE_PROPERTY_DOCKINGAREA )
 530                     {
 531                         ui::DockingArea eDockingArea;
 532                         if ( aWindowState[n].Value >>= eDockingArea )
 533                             rElementData.m_aDockedData.m_nDockedArea = sal_Int16( eDockingArea );
 534                     }
 535                     else if ( aWindowState[n].Name == WINDOWSTATE_PROPERTY_DOCKPOS )
 536                     {
 537                         awt::Point aPoint;
 538                         if (aWindowState[n].Value >>= aPoint)
 539                         {
 540                             //tdf#90256 repair these broken Docking positions
 541                             if (aPoint.X < 0)
 542                                 aPoint.X = SAL_MAX_INT32;
 543                             if (aPoint.Y < 0)
 544                                 aPoint.Y = SAL_MAX_INT32;
 545                             rElementData.m_aDockedData.m_aPos = aPoint;
 546                         }
 547                     }
 548                     else if ( aWindowState[n].Name == WINDOWSTATE_PROPERTY_POS )
 549                     {
 550                         awt::Point aPoint;
 551                         if ( aWindowState[n].Value >>= aPoint )
 552                             rElementData.m_aFloatingData.m_aPos = aPoint;
 553                     }
 554                     else if ( aWindowState[n].Name == WINDOWSTATE_PROPERTY_SIZE )
 555                     {
 556                         awt::Size aSize;
 557                         if ( aWindowState[n].Value >>= aSize )
 558                             rElementData.m_aFloatingData.m_aSize = aSize;
 559                     }
 560                     else if ( aWindowState[n].Name == WINDOWSTATE_PROPERTY_UINAME )
 561                         aWindowState[n].Value >>= rElementData.m_aUIName;
 562                     else if ( aWindowState[n].Name == WINDOWSTATE_PROPERTY_STYLE )
 563                     {
 564                         sal_Int32 nStyle = 0;
 565                         if ( aWindowState[n].Value >>= nStyle )
 566                             rElementData.m_nStyle = static_cast<ButtonType>( nStyle );
 567                     }
 568                     else if ( aWindowState[n].Name == WINDOWSTATE_PROPERTY_LOCKED )
 569                     {
 570                         if ( aWindowState[n].Value >>= bValue )
 571                             rElementData.m_aDockedData.m_bLocked = bValue;
 572                     }
 573                     else if ( aWindowState[n].Name == WINDOWSTATE_PROPERTY_CONTEXT )
 574                     {
 575                         if ( aWindowState[n].Value >>= bValue )
 576                             rElementData.m_bContextSensitive = bValue;
 577                     }
 578                     else if ( aWindowState[n].Name == WINDOWSTATE_PROPERTY_NOCLOSE )
 579                     {
 580                         if ( aWindowState[n].Value >>= bValue )
 581                             rElementData.m_bNoClose = bValue;
 582                     }
 583                     else if ( aWindowState[n].Name == WINDOWSTATE_PROPERTY_CONTEXTACTIVE )
 584                     {
 585                         if ( aWindowState[n].Value >>= bValue )
 586                             rElementData.m_bContextActive = bValue;
 587                     }
 588                     else if ( aWindowState[n].Name == WINDOWSTATE_PROPERTY_SOFTCLOSE )
 589                     {
 590                         if ( aWindowState[n].Value >>= bValue )
 591                             rElementData.m_bSoftClose = bValue;
 592                     }
 593                 }
 594             }
 595
 596             // oversteer values with global settings
 597             if ( pGlobalSettings && ( bGetSettingsState || bGlobalSettings ))
 598             {
 599                 if ( pGlobalSettings->HasStatesInfo( GlobalSettings::UIELEMENT_TYPE_TOOLBAR ))
 600                 {
 601                     SolarMutexClearableGuard aWriteLock2;
 602                     bInGlobalSettings = true;
 603                     aWriteLock2.clear();
 604
 605                     uno::Any aValue;
 606                     if ( pGlobalSettings->GetStateInfo( GlobalSettings::UIELEMENT_TYPE_TOOLBAR,
 607                                                         GlobalSettings::STATEINFO_LOCKED,
 608                                                         aValue ))
 609                         aValue >>= rElementData.m_aDockedData.m_bLocked;
 610                     if ( pGlobalSettings->GetStateInfo( GlobalSettings::UIELEMENT_TYPE_TOOLBAR,
 611                                                         GlobalSettings::STATEINFO_DOCKED,
 612                                                         aValue ))
 613                     {
 614                         bool bValue;
 615                         if ( aValue >>= bValue )
 616                             rElementData.m_bFloating = !bValue;
 617                     }
 618                 }
 619             }
 620
 621             return true;
 622         }
 623         catch (const NoSuchElementException&)
 624         {
 625         }
 626     }
 627
 628     return false;
 629 }
 630
 631 void LayoutManager::implts_writeWindowStateData( const OUString& aName, const UIElement& rElementData )
 632 {
 633     SolarMutexResettableGuard aWriteLock;
 634     Reference< XNameAccess > xPersistentWindowState( m_xPersistentWindowState );
 635
 636     // set flag to determine that we triggered the notification
 637     m_bStoreWindowState = true;
 638     aWriteLock.clear();
 639
 640     bool bPersistent( false );
 641     Reference< XPropertySet > xPropSet( rElementData.m_xUIElement, UNO_QUERY );
 642     if ( xPropSet.is() )
 643     {
 644         try
 645         {
 646             // Check persistent flag of the user interface element
 647             xPropSet->getPropertyValue("Persistent") >>= bPersistent;
 648         }
 649         catch (const beans::UnknownPropertyException&)
 650         {
 651             // Non-configurable elements should at least store their dimension/position
 652             bPersistent = true;
 653         }
 654         catch (const lang::WrappedTargetException&)
 655         {
 656         }
 657     }
 658
 659     if ( bPersistent && xPersistentWindowState.is() )
 660     {
 661         try
 662         {
 663             Sequence< PropertyValue > aWindowState( 8 );
 664
 665             aWindowState[0].Name  = WINDOWSTATE_PROPERTY_DOCKED;
 666             aWindowState[0].Value = makeAny( !rElementData.m_bFloating );
 667             aWindowState[1].Name  = WINDOWSTATE_PROPERTY_VISIBLE;
 668             aWindowState[1].Value = makeAny( rElementData.m_bVisible );
 669
 670             aWindowState[2].Name  = WINDOWSTATE_PROPERTY_DOCKINGAREA;
 671             aWindowState[2].Value = makeAny( static_cast< DockingArea >( rElementData.m_aDockedData.m_nDockedArea ) );
 672
 673             aWindowState[3].Name = WINDOWSTATE_PROPERTY_DOCKPOS;
 674             aWindowState[3].Value <<= rElementData.m_aDockedData.m_aPos;
 675
 676             aWindowState[4].Name = WINDOWSTATE_PROPERTY_POS;
 677             aWindowState[4].Value <<= rElementData.m_aFloatingData.m_aPos;
 678
 679             aWindowState[5].Name  = WINDOWSTATE_PROPERTY_SIZE;
 680             aWindowState[5].Value <<= rElementData.m_aFloatingData.m_aSize;
 681             aWindowState[6].Name  = WINDOWSTATE_PROPERTY_UINAME;
 682             aWindowState[6].Value = makeAny( rElementData.m_aUIName );
 683             aWindowState[7].Name  = WINDOWSTATE_PROPERTY_LOCKED;
 684             aWindowState[7].Value = makeAny( rElementData.m_aDockedData.m_bLocked );
 685
 686             if ( xPersistentWindowState->hasByName( aName ))
 687             {
 688                 Reference< XNameReplace > xReplace( xPersistentWindowState, uno::UNO_QUERY );
 689                 xReplace->replaceByName( aName, makeAny( aWindowState ));
 690             }
 691             else
 692             {
 693                 Reference< XNameContainer > xInsert( xPersistentWindowState, uno::UNO_QUERY );
 694                 xInsert->insertByName( aName, makeAny( aWindowState ));
 695             }
 696         }
 697         catch (const Exception&)
 698         {
 699         }
 700     }
 701
 702     // Reset flag
 703     aWriteLock.reset();
 704     m_bStoreWindowState = false;
 705     aWriteLock.clear();
 706 }
 707
 708 ::Size LayoutManager::implts_getContainerWindowOutputSize()
 709 {
 710     ::Size  aContainerWinSize;
 711     vcl::Window* pContainerWindow( 0 );
 712
 713     // Retrieve output size from container Window
 714     SolarMutexGuard aGuard;
 715     pContainerWindow  = VCLUnoHelper::GetWindow( m_xContainerWindow );
 716     if ( pContainerWindow )
 717         aContainerWinSize = pContainerWindow->GetOutputSizePixel();
 718
 719     return aContainerWinSize;
 720 }
 721
 722 Reference< XUIElement > LayoutManager::implts_createElement( const OUString& aName )
 723 {
 724     Reference< ui::XUIElement > xUIElement;
 725
 726     SolarMutexGuard g;
 727     Sequence< PropertyValue > aPropSeq( 2 );
 728     aPropSeq[0].Name = "Frame";
 729     aPropSeq[0].Value <<= m_xFrame;
 730     aPropSeq[1].Name = "Persistent";
 731     aPropSeq[1].Value <<= sal_True;
 732
 733     try
 734     {
 735         xUIElement = m_xUIElementFactoryManager->createUIElement( aName, aPropSeq );
 736     }
 737     catch (const NoSuchElementException&)
 738     {
 739     }
 740     catch (const IllegalArgumentException&)
 741     {
 742     }
 743
 744     return xUIElement;
 745 }
 746
 747 void LayoutManager::implts_setVisibleState( bool bShow )
 748 {
 749     SolarMutexClearableGuard aWriteLock;
 750     m_aStatusBarElement.m_bMasterHide = !bShow;
 751     aWriteLock.clear();
 752
 753     implts_updateUIElementsVisibleState( bShow );
 754 }
 755
 756 void LayoutManager::implts_updateUIElementsVisibleState( bool bSetVisible )
 757 {
 758     // notify listeners
 759     uno::Any a;
 760     if ( bSetVisible )
 761         implts_notifyListeners( frame::LayoutManagerEvents::VISIBLE, a );
 762     else
 763         implts_notifyListeners( frame::LayoutManagerEvents::INVISIBLE, a );
 764
 765     SolarMutexResettableGuard aWriteLock;
 766     Reference< XUIElement >   xMenuBar( m_xMenuBar, UNO_QUERY );
 767     Reference< awt::XWindow > xContainerWindow( m_xContainerWindow );
 768     Reference< XComponent >   xInplaceMenuBar( m_xInplaceMenuBar );
 769     MenuBarManager*           pInplaceMenuBar( m_pInplaceMenuBar );
 770     aWriteLock.clear();
 771
 772     if (( xMenuBar.is() || xInplaceMenuBar.is() ) && xContainerWindow.is() )
 773     {
 774         SolarMutexGuard aGuard;
 775
 776         MenuBar* pMenuBar( 0 );
 777         if ( xInplaceMenuBar.is() )
 778             pMenuBar = static_cast<MenuBar *>(pInplaceMenuBar->GetMenuBar());
 779         else
 780         {
 781             MenuBarWrapper* pMenuBarWrapper = (static_cast< MenuBarWrapper* >(xMenuBar.get()) );
 782             pMenuBar = static_cast<MenuBar *>(pMenuBarWrapper->GetMenuBarManager()->GetMenuBar());
 783         }
 784
 785         SystemWindow* pSysWindow = getTopSystemWindow( xContainerWindow );
 786         if ( pSysWindow )
 787         {
 788             if ( bSetVisible )
 789                 pSysWindow->SetMenuBar(pMenuBar, m_xFrame);
 790             else
 791                 pSysWindow->SetMenuBar( 0 );
 792         }
 793     }
 794
 795     bool bMustDoLayout;
 796     // Hide/show the statusbar according to bSetVisible
 797     if ( bSetVisible )
 798         bMustDoLayout = !implts_showStatusBar();
 799     else
 800         bMustDoLayout = !implts_hideStatusBar();
 801
 802     aWriteLock.reset();
 803     ToolbarLayoutManager* pToolbarManager( m_pToolbarManager );
 804     aWriteLock.clear();
 805
 806     if ( pToolbarManager )
 807     {
 808         pToolbarManager->setVisible( bSetVisible );
 809         bMustDoLayout = pToolbarManager->isLayoutDirty();
 810     }
 811
 812     if ( bMustDoLayout )
 813         implts_doLayout_notify( false );
 814 }
 815
 816 void LayoutManager::implts_setCurrentUIVisibility( bool bShow )
 817 {
 818     SolarMutexClearableGuard aWriteLock;
 819     if ( !bShow && m_aStatusBarElement.m_bVisible && m_aStatusBarElement.m_xUIElement.is() )
 820         m_aStatusBarElement.m_bMasterHide = true;
 821     else if ( bShow && m_aStatusBarElement.m_bVisible )
 822         m_aStatusBarElement.m_bMasterHide = false;
 823     aWriteLock.clear();
 824
 825     implts_updateUIElementsVisibleState( bShow );
 826 }
 827
 828 void LayoutManager::implts_destroyStatusBar()
 829 {
 830     Reference< XComponent > xCompStatusBar;
 831
 832     SolarMutexClearableGuard aWriteLock;
 833     m_aStatusBarElement.m_aName.clear();
 834     xCompStatusBar = Reference< XComponent >( m_aStatusBarElement.m_xUIElement, UNO_QUERY );
 835     m_aStatusBarElement.m_xUIElement.clear();
 836     aWriteLock.clear();
 837
 838     if ( xCompStatusBar.is() )
 839         xCompStatusBar->dispose();
 840
 841     implts_destroyProgressBar();
 842 }
 843
 844 void LayoutManager::implts_createStatusBar( const OUString& aStatusBarName )
 845 {
 846     SolarMutexClearableGuard aWriteLock;
 847     if ( !m_aStatusBarElement.m_xUIElement.is() )
 848     {
 849         implts_readStatusBarState( aStatusBarName );
 850         m_aStatusBarElement.m_aName      = aStatusBarName;
 851         m_aStatusBarElement.m_xUIElement = implts_createElement( aStatusBarName );
 852     }
 853     aWriteLock.clear();
 854
 855     implts_createProgressBar();
 856 }
 857
 858 void LayoutManager::implts_readStatusBarState( const OUString& rStatusBarName )
 859 {
 860     SolarMutexGuard g;
 861     if ( !m_aStatusBarElement.m_bStateRead )
 862     {
 863         // Read persistent data for status bar if not yet read!
 864         if ( implts_readWindowStateData( rStatusBarName, m_aStatusBarElement ))
 865             m_aStatusBarElement.m_bStateRead = true;
 866     }
 867 }
 868
 869 void LayoutManager::implts_createProgressBar()
 870 {
 871     Reference< XUIElement > xStatusBar;
 872     Reference< XUIElement > xProgressBar;
 873     Reference< XUIElement > xProgressBarBackup;
 874     Reference< awt::XWindow > xContainerWindow;
 875
 876     SolarMutexResettableGuard aWriteLock;
 877     xStatusBar = Reference< XUIElement >( m_aStatusBarElement.m_xUIElement, UNO_QUERY );
 878     xProgressBar = Reference< XUIElement >( m_aProgressBarElement.m_xUIElement, UNO_QUERY );
 879     xProgressBarBackup = m_xProgressBarBackup;
 880     m_xProgressBarBackup.clear();
 881     xContainerWindow = m_xContainerWindow;
 882     aWriteLock.clear();
 883
 884     bool                bRecycled = xProgressBarBackup.is();
 885     ProgressBarWrapper* pWrapper  = 0;
 886     if ( bRecycled )
 887         pWrapper = static_cast<ProgressBarWrapper*>(xProgressBarBackup.get());
 888     else if ( xProgressBar.is() )
 889         pWrapper = static_cast<ProgressBarWrapper*>(xProgressBar.get());
 890     else
 891         pWrapper = new ProgressBarWrapper();
 892
 893     if ( xStatusBar.is() )
 894     {
 895         Reference< awt::XWindow > xWindow( xStatusBar->getRealInterface(), UNO_QUERY );
 896         pWrapper->setStatusBar( xWindow );
 897     }
 898     else
 899     {
 900         Reference< awt::XWindow > xStatusBarWindow = pWrapper->getStatusBar();
 901
 902         SolarMutexGuard aGuard;
 903         vcl::Window* pStatusBarWnd = VCLUnoHelper::GetWindow( xStatusBarWindow );
 904         if ( !pStatusBarWnd )
 905         {
 906             vcl::Window* pWindow = VCLUnoHelper::GetWindow( xContainerWindow );
 907             if ( pWindow )
 908             {
 909                 VclPtrInstance<StatusBar> pStatusBar( pWindow, WinBits( WB_LEFT | WB_3DLOOK ) );
 910                 Reference< awt::XWindow > xStatusBarWindow2( VCLUnoHelper::GetInterface( pStatusBar ));
 911                 pWrapper->setStatusBar( xStatusBarWindow2, true );
 912             }
 913         }
 914     }
 915
 916     /* SAFE AREA ----------------------------------------------------------------------------------------------- */
 917     aWriteLock.reset();
 918     m_aProgressBarElement.m_xUIElement = Reference< XUIElement >(
 919         static_cast< cppu::OWeakObject* >( pWrapper ), UNO_QUERY );
 920     aWriteLock.clear();
 921     /* SAFE AREA ----------------------------------------------------------------------------------------------- */
 922
 923     if ( bRecycled )
 924         implts_showProgressBar();
 925 }
 926
 927 void LayoutManager::implts_backupProgressBarWrapper()
 928 {
 929     SolarMutexGuard g;
 930
 931     if (m_xProgressBarBackup.is())
 932         return;
 933
 934     // safe a backup copy of the current progress!
 935     // This copy will be used automatically inside createProgressBar() which is called
 936     // implictly from implts_doLayout() .-)
 937     m_xProgressBarBackup = m_aProgressBarElement.m_xUIElement;
 938
 939     // remove the relation between this old progress bar and our old status bar.
 940     // Otherwhise we work on disposed items ...
 941     // The internal used ProgressBarWrapper can handle a NULL reference.
 942     if ( m_xProgressBarBackup.is() )
 943     {
 944         ProgressBarWrapper* pWrapper = static_cast<ProgressBarWrapper*>(m_xProgressBarBackup.get());
 945         if ( pWrapper )
 946             pWrapper->setStatusBar( Reference< awt::XWindow >(), false );
 947     }
 948
 949     // prevent us from dispose() the m_aProgressBarElement.m_xUIElement inside implts_reset()
 950     m_aProgressBarElement.m_xUIElement.clear();
 951 }
 952
 953 void LayoutManager::implts_destroyProgressBar()
 954 {
 955     // dont remove the progressbar in general
 956     // We must reuse it if a new status bar is created later.
 957     // Of course there exists one backup only.
 958     // And further this backup will be released inside our dtor.
 959     implts_backupProgressBarWrapper();
 960 }
 961
 962 void LayoutManager::implts_setStatusBarPosSize( const ::Point& rPos, const ::Size& rSize )
 963 {
 964     Reference< XUIElement > xStatusBar;
 965     Reference< XUIElement > xProgressBar;
 966     Reference< awt::XWindow > xContainerWindow;
 967
 968     /* SAFE AREA ----------------------------------------------------------------------------------------------- */
 969     SolarMutexClearableGuard aReadLock;
 970     xStatusBar = Reference< XUIElement >( m_aStatusBarElement.m_xUIElement, UNO_QUERY );
 971     xProgressBar = Reference< XUIElement >( m_aProgressBarElement.m_xUIElement, UNO_QUERY );
 972     xContainerWindow = m_xContainerWindow;
 973
 974     Reference< awt::XWindow > xWindow;
 975     if ( xStatusBar.is() )
 976         xWindow = Reference< awt::XWindow >( xStatusBar->getRealInterface(), UNO_QUERY );
 977     else if ( xProgressBar.is() )
 978     {
 979         ProgressBarWrapper* pWrapper = static_cast<ProgressBarWrapper*>(xProgressBar.get());
 980         if ( pWrapper )
 981             xWindow = pWrapper->getStatusBar();
 982     }
 983     aReadLock.clear();
 984     /* SAFE AREA ----------------------------------------------------------------------------------------------- */
 985
 986     if ( xWindow.is() )
 987     {
 988         SolarMutexGuard aGuard;
 989         vcl::Window* pParentWindow = VCLUnoHelper::GetWindow( xContainerWindow );
 990         vcl::Window* pWindow = VCLUnoHelper::GetWindow( xWindow );
 991         if ( pParentWindow && ( pWindow && pWindow->GetType() == WINDOW_STATUSBAR ))
 992         {
 993             vcl::Window* pOldParentWindow = pWindow->GetParent();
 994             if ( pParentWindow != pOldParentWindow )
 995                 pWindow->SetParent( pParentWindow );
 996             static_cast<StatusBar *>(pWindow)->SetPosSizePixel( rPos, rSize );
 997         }
 998     }
 999 }
1000
1001 bool LayoutManager::implts_showProgressBar()
1002 {
1003     Reference< XUIElement > xStatusBar;
1004     Reference< XUIElement > xProgressBar;
1005     Reference< awt::XWindow > xWindow;
1006
1007     /* SAFE AREA ----------------------------------------------------------------------------------------------- */
1008     SolarMutexClearableGuard aWriteLock;
1009     xStatusBar = Reference< XUIElement >( m_aStatusBarElement.m_xUIElement, UNO_QUERY );
1010     xProgressBar = Reference< XUIElement >( m_aProgressBarElement.m_xUIElement, UNO_QUERY );
1011     bool bVisible( m_bVisible );
1012
1013     m_aProgressBarElement.m_bVisible = true;
1014     if ( bVisible )
1015     {
1016         if ( xStatusBar.is() && !m_aStatusBarElement.m_bMasterHide )
1017         {
1018             xWindow = Reference< awt::XWindow >( xStatusBar->getRealInterface(), UNO_QUERY );
1019         }
1020         else if ( xProgressBar.is() )
1021         {
1022             ProgressBarWrapper* pWrapper = static_cast<ProgressBarWrapper*>(xProgressBar.get());
1023             if ( pWrapper )
1024                 xWindow = pWrapper->getStatusBar();
1025         }
1026     }
1027     aWriteLock.clear();
1028     /* SAFE AREA ----------------------------------------------------------------------------------------------- */
1029
1030     SolarMutexGuard aGuard;
1031     vcl::Window* pWindow = VCLUnoHelper::GetWindow( xWindow );
1032     if ( pWindow )
1033     {
1034         if ( !pWindow->IsVisible() )
1035         {
1036             implts_setOffset( pWindow->GetSizePixel().Height() );
1037             pWindow->Show();
1038             implts_doLayout_notify( false );
1039         }
1040         return true;
1041     }
1042
1043     return false;
1044 }
1045
1046 bool LayoutManager::implts_hideProgressBar()
1047 {
1048     Reference< XUIElement > xProgressBar;
1049     Reference< awt::XWindow > xWindow;
1050     bool bHideStatusBar( false );
1051
1052     SolarMutexGuard g;
1053     xProgressBar = Reference< XUIElement >( m_aProgressBarElement.m_xUIElement, UNO_QUERY );
1054
1055     bool bInternalStatusBar( false );
1056     if ( xProgressBar.is() )
1057     {
1058         Reference< awt::XWindow > xStatusBar;
1059         ProgressBarWrapper* pWrapper = static_cast<ProgressBarWrapper*>(xProgressBar.get());
1060         if ( pWrapper )
1061             xWindow = pWrapper->getStatusBar();
1062         Reference< ui::XUIElement > xStatusBarElement = m_aStatusBarElement.m_xUIElement;
1063         if ( xStatusBarElement.is() )
1064             xStatusBar = Reference< awt::XWindow >( xStatusBarElement->getRealInterface(), UNO_QUERY );
1065         bInternalStatusBar = xStatusBar != xWindow;
1066     }
1067     m_aProgressBarElement.m_bVisible = false;
1068     implts_readStatusBarState( STATUS_BAR_ALIAS );
1069     bHideStatusBar = !m_aStatusBarElement.m_bVisible;
1070
1071     vcl::Window* pWindow = VCLUnoHelper::GetWindow( xWindow );
1072     if ( pWindow && pWindow->IsVisible() && ( bHideStatusBar || bInternalStatusBar ))
1073     {
1074         implts_setOffset( 0 );
1075         pWindow->Hide();
1076         implts_doLayout_notify( false );
1077         return true;
1078     }
1079
1080     return false;
1081 }
1082
1083 bool LayoutManager::implts_showStatusBar( bool bStoreState )
1084 {
1085     SolarMutexClearableGuard aWriteLock;
1086     Reference< ui::XUIElement > xStatusBar = m_aStatusBarElement.m_xUIElement;
1087     if ( bStoreState )
1088         m_aStatusBarElement.m_bVisible = true;
1089     aWriteLock.clear();
1090
1091     if ( xStatusBar.is() )
1092     {
1093         Reference< awt::XWindow > xWindow( xStatusBar->getRealInterface(), UNO_QUERY );
1094
1095         SolarMutexGuard aGuard;
1096         vcl::Window* pWindow = VCLUnoHelper::GetWindow( xWindow );
1097         if ( pWindow && !pWindow->IsVisible() )
1098         {
1099             implts_setOffset( pWindow->GetSizePixel().Height() );
1100             pWindow->Show();
1101             implts_doLayout_notify( false );
1102             return true;
1103         }
1104     }
1105
1106     return false;
1107 }
1108
1109 bool LayoutManager::implts_hideStatusBar( bool bStoreState )
1110 {
1111     SolarMutexClearableGuard aWriteLock;
1112     Reference< ui::XUIElement > xStatusBar = m_aStatusBarElement.m_xUIElement;
1113     if ( bStoreState )
1114         m_aStatusBarElement.m_bVisible = false;
1115     aWriteLock.clear();
1116
1117     if ( xStatusBar.is() )
1118     {
1119         Reference< awt::XWindow > xWindow( xStatusBar->getRealInterface(), UNO_QUERY );
1120
1121         SolarMutexGuard aGuard;
1122         vcl::Window* pWindow = VCLUnoHelper::GetWindow( xWindow );
1123         if ( pWindow && pWindow->IsVisible() )
1124         {
1125             implts_setOffset( 0 );
1126             pWindow->Hide();
1127             implts_doLayout_notify( false );
1128             return true;
1129         }
1130     }
1131
1132     return false;
1133 }
1134
1135 void LayoutManager::implts_setOffset( const sal_Int32 nBottomOffset )
1136 {
1137     ::Rectangle aOffsetRect;
1138     setZeroRectangle( aOffsetRect );
1139     aOffsetRect.setHeight( nBottomOffset );
1140
1141     if ( m_pToolbarManager )
1142         m_pToolbarManager->setDockingAreaOffsets( aOffsetRect );
1143 }
1144
1145 void LayoutManager::implts_setInplaceMenuBar( const Reference< XIndexAccess >& xMergedMenuBar )
1146 throw (uno::RuntimeException)
1147 {
1148     /* SAFE AREA ----------------------------------------------------------------------------------------------- */
1149     SolarMutexClearableGuard aWriteLock;
1150
1151     if ( !m_bInplaceMenuSet )
1152     {
1153         SolarMutexGuard aGuard;
1154
1155         // Reset old inplace menubar!
1156         m_pInplaceMenuBar = 0;
1157         if ( m_xInplaceMenuBar.is() )
1158             m_xInplaceMenuBar->dispose();
1159         m_xInplaceMenuBar.clear();
1160         m_bInplaceMenuSet = false;
1161
1162         if ( m_xFrame.is() && m_xContainerWindow.is() )
1163         {
1164             OUString aModuleIdentifier;
1165             Reference< XDispatchProvider > xDispatchProvider;
1166
1167             MenuBar* pMenuBar = new MenuBar;
1168             m_pInplaceMenuBar = new MenuBarManager( m_xContext, m_xFrame, m_xURLTransformer, xDispatchProvider, aModuleIdentifier, pMenuBar, true, true );
1169             m_pInplaceMenuBar->SetItemContainer( xMergedMenuBar );
1170
1171             SystemWindow* pSysWindow = getTopSystemWindow( m_xContainerWindow );
1172             if ( pSysWindow )
1173                 pSysWindow->SetMenuBar(pMenuBar, m_xFrame);
1174
1175             m_bInplaceMenuSet = true;
1176             m_xInplaceMenuBar = Reference< XComponent >( (OWeakObject *)m_pInplaceMenuBar, UNO_QUERY );
1177         }
1178
1179         aWriteLock.clear();
1180         /* SAFE AREA ----------------------------------------------------------------------------------------------- */
1181
1182         implts_updateMenuBarClose();
1183     }
1184 }
1185
1186 void LayoutManager::implts_resetInplaceMenuBar()
1187 throw (uno::RuntimeException)
1188 {
1189     SolarMutexGuard g;
1190     m_bInplaceMenuSet = false;
1191
1192     if ( m_xContainerWindow.is() )
1193     {
1194         SolarMutexGuard aGuard;
1195         MenuBarWrapper* pMenuBarWrapper = (static_cast< MenuBarWrapper* >(m_xMenuBar.get()) );
1196         SystemWindow* pSysWindow = getTopSystemWindow( m_xContainerWindow );
1197         if ( pSysWindow )
1198         {
1199             if ( pMenuBarWrapper )
1200                 pSysWindow->SetMenuBar(static_cast<MenuBar *>(pMenuBarWrapper->GetMenuBarManager()->GetMenuBar()), m_xFrame);
1201             else
1202                 pSysWindow->SetMenuBar(0);
1203         }
1204     }
1205
1206     // Remove inplace menu bar
1207     m_pInplaceMenuBar = 0;
1208     if ( m_xInplaceMenuBar.is() )
1209         m_xInplaceMenuBar->dispose();
1210     m_xInplaceMenuBar.clear();
1211 }
1212
1213 void SAL_CALL LayoutManager::attachFrame( const Reference< XFrame >& xFrame )
1214 throw (uno::RuntimeException, std::exception)
1215 {
1216     SolarMutexGuard g;
1217     m_xFrame = xFrame;
1218 }
1219
1220 void SAL_CALL LayoutManager::reset()
1221 throw (RuntimeException, std::exception)
1222 {
1223     implts_reset( true );
1224 }
1225
1226 // XMenuBarMergingAcceptor
1227
1228 sal_Bool SAL_CALL LayoutManager::setMergedMenuBar(
1229     const Reference< XIndexAccess >& xMergedMenuBar )
1230 throw (uno::RuntimeException, std::exception)
1231 {
1232     implts_setInplaceMenuBar( xMergedMenuBar );
1233
1234     uno::Any a;
1235     implts_notifyListeners( frame::LayoutManagerEvents::MERGEDMENUBAR, a );
1236     return sal_True;
1237 }
1238
1239 void SAL_CALL LayoutManager::removeMergedMenuBar()
1240 throw (uno::RuntimeException, std::exception)
1241 {
1242     implts_resetInplaceMenuBar();
1243 }
1244
1245 awt::Rectangle SAL_CALL LayoutManager::getCurrentDockingArea()
1246 throw ( RuntimeException, std::exception )
1247 {
1248     SolarMutexGuard g;
1249     return m_aDockingArea;
1250 }
1251
1252 Reference< XDockingAreaAcceptor > SAL_CALL LayoutManager::getDockingAreaAcceptor()
1253 throw (uno::RuntimeException, std::exception)
1254 {
1255     SolarMutexGuard g;
1256     return m_xDockingAreaAcceptor;
1257 }
1258
1259 void SAL_CALL LayoutManager::setDockingAreaAcceptor( const Reference< ui::XDockingAreaAcceptor >& xDockingAreaAcceptor )
1260 throw ( RuntimeException, std::exception )
1261 {
1262     /* SAFE AREA ----------------------------------------------------------------------------------------------- */
1263     SolarMutexClearableGuard aWriteLock;
1264
1265     if (( m_xDockingAreaAcceptor == xDockingAreaAcceptor ) || !m_xFrame.is() )
1266         return;
1267
1268     // IMPORTANT: Be sure to stop layout timer if don't have a docking area acceptor!
1269     if ( !xDockingAreaAcceptor.is() )
1270         m_aAsyncLayoutTimer.Stop();
1271
1272     bool bAutomaticToolbars( m_bAutomaticToolbars );
1273     std::vector< Reference< awt::XWindow > > oldDockingAreaWindows;
1274
1275     ToolbarLayoutManager* pToolbarManager = m_pToolbarManager;
1276
1277     if ( !xDockingAreaAcceptor.is() )
1278         m_aAsyncLayoutTimer.Stop();
1279
1280     // Remove listener from old docking area acceptor
1281     if ( m_xDockingAreaAcceptor.is() )
1282     {
1283         Reference< awt::XWindow > xWindow( m_xDockingAreaAcceptor->getContainerWindow() );
1284         if ( xWindow.is() && ( m_xFrame->getContainerWindow() != m_xContainerWindow || !xDockingAreaAcceptor.is() ) )
1285             xWindow->removeWindowListener( Reference< awt::XWindowListener >( static_cast< OWeakObject * >( this ), UNO_QUERY ));
1286
1287         m_aDockingArea = awt::Rectangle();
1288         if ( pToolbarManager )
1289             pToolbarManager->resetDockingArea();
1290
1291         vcl::Window* pContainerWindow = VCLUnoHelper::GetWindow( xWindow );
1292         if ( pContainerWindow )
1293             pContainerWindow->RemoveChildEventListener( LINK( this, LayoutManager, WindowEventListener ) );
1294     }
1295
1296     Reference< ui::XDockingAreaAcceptor > xOldDockingAreaAcceptor( m_xDockingAreaAcceptor );
1297     m_xDockingAreaAcceptor = xDockingAreaAcceptor;
1298     if ( m_xDockingAreaAcceptor.is() )
1299     {
1300         m_aDockingArea     = awt::Rectangle();
1301         m_xContainerWindow = m_xDockingAreaAcceptor->getContainerWindow();
1302         m_xContainerTopWindow.set( m_xContainerWindow, UNO_QUERY );
1303         m_xContainerWindow->addWindowListener( Reference< awt::XWindowListener >( static_cast< OWeakObject* >( this ), UNO_QUERY ));
1304
1305         // we always must keep a connection to the window of our frame for resize events
1306         if ( m_xContainerWindow != m_xFrame->getContainerWindow() )
1307             m_xFrame->getContainerWindow()->addWindowListener( Reference< awt::XWindowListener >( static_cast< OWeakObject* >( this ), UNO_QUERY ));
1308
1309         // #i37884# set initial visibility state - in the plugin case the container window is already shown
1310         // and we get no notification anymore
1311         {
1312             SolarMutexGuard aGuard;
1313             vcl::Window* pContainerWindow = VCLUnoHelper::GetWindow( m_xContainerWindow );
1314             if( pContainerWindow )
1315                 m_bParentWindowVisible = pContainerWindow->IsVisible();
1316         }
1317
1318         uno::Reference< awt::XWindowPeer > xParent( m_xContainerWindow, UNO_QUERY );
1319     }
1320
1321     aWriteLock.clear();
1322     /* SAFE AREA ----------------------------------------------------------------------------------------------- */
1323
1324     if ( xDockingAreaAcceptor.is() )
1325     {
1326         SolarMutexGuard aGuard;
1327
1328         // Add layout manager as listener to get notifications about toolbar button activties
1329         vcl::Window* pContainerWindow = VCLUnoHelper::GetWindow( m_xContainerWindow );
1330         if ( pContainerWindow )
1331             pContainerWindow->AddChildEventListener( LINK( this, LayoutManager, WindowEventListener ) );
1332
1333         // We have now a new container window, reparent all child windows!
1334         implts_reparentChildWindows();
1335     }
1336     else
1337         implts_destroyElements(); // remove all elements
1338
1339     if ( !oldDockingAreaWindows.empty() )
1340     {
1341         // Reset docking area size for our old docking area acceptor
1342         awt::Rectangle aEmptyRect;
1343         xOldDockingAreaAcceptor->setDockingAreaSpace( aEmptyRect );
1344     }
1345
1346     if ( pToolbarManager && xDockingAreaAcceptor.is() )
1347     {
1348         if ( bAutomaticToolbars )
1349         {
1350             lock();
1351             pToolbarManager->createStaticToolbars();
1352             unlock();
1353         }
1354         implts_doLayout( true, false );
1355     }
1356 }
1357
1358 void LayoutManager::implts_reparentChildWindows()
1359 {
1360     SolarMutexResettableGuard aWriteLock;
1361     UIElement aStatusBarElement = m_aStatusBarElement;
1362     uno::Reference< awt::XWindow > xContainerWindow  = m_xContainerWindow;
1363     aWriteLock.clear();
1364
1365     uno::Reference< awt::XWindow > xStatusBarWindow;
1366     if ( aStatusBarElement.m_xUIElement.is() )
1367     {
1368         try
1369         {
1370             xStatusBarWindow = Reference< awt::XWindow >( aStatusBarElement.m_xUIElement->getRealInterface(), UNO_QUERY );
1371         }
1372         catch (const RuntimeException&)
1373         {
1374             throw;
1375         }
1376         catch (const Exception&)
1377         {
1378         }
1379     }
1380
1381     if ( xStatusBarWindow.is() )
1382     {
1383         SolarMutexGuard aGuard;
1384         vcl::Window* pContainerWindow = VCLUnoHelper::GetWindow( xContainerWindow );
1385         vcl::Window* pWindow          = VCLUnoHelper::GetWindow( xStatusBarWindow );
1386         if ( pWindow && pContainerWindow )
1387             pWindow->SetParent( pContainerWindow );
1388     }
1389
1390     implts_resetMenuBar();
1391
1392     aWriteLock.reset();
1393     ToolbarLayoutManager* pToolbarManager = m_pToolbarManager;
1394     if ( pToolbarManager )
1395         pToolbarManager->setParentWindow( uno::Reference< awt::XWindowPeer >( xContainerWindow, uno::UNO_QUERY ));
1396     aWriteLock.clear();
1397 }
1398
1399 uno::Reference< ui::XUIElement > LayoutManager::implts_createDockingWindow( const OUString& aElementName )
1400 {
1401     Reference< XUIElement > xUIElement = implts_createElement( aElementName );
1402     return xUIElement;
1403 }
1404
1405 IMPL_LINK( LayoutManager, WindowEventListener, VclSimpleEvent*, pEvent )
1406 {
1407     long nResult( 1 );
1408
1409     if ( pEvent && pEvent->ISA( VclWindowEvent ))
1410     {
1411         vcl::Window* pWindow = static_cast< VclWindowEvent* >(pEvent)->GetWindow();
1412         if ( pWindow && pWindow->GetType() == WINDOW_TOOLBOX )
1413         {
1414             SolarMutexClearableGuard aReadLock;
1415             ToolbarLayoutManager* pToolbarManager( m_pToolbarManager );
1416             aReadLock.clear();
1417
1418             if ( pToolbarManager )
1419                 nResult = pToolbarManager->childWindowEvent( pEvent );
1420         }
1421     }
1422
1423     return nResult;
1424 }
1425
1426 void SAL_CALL LayoutManager::createElement( const OUString& aName )
1427 throw (RuntimeException, std::exception)
1428 {
1429     SAL_INFO( "fwk", "framework (cd100003) ::LayoutManager::createElement" );
1430
1431     SolarMutexClearableGuard aReadLock;
1432     Reference< XFrame > xFrame = m_xFrame;
1433     Reference< XURLTransformer > xURLTransformer = m_xURLTransformer;
1434     bool    bInPlaceMenu = m_bInplaceMenuSet;
1435     aReadLock.clear();
1436
1437     if ( !xFrame.is() )
1438         return;
1439
1440     /* SAFE AREA ----------------------------------------------------------------------------------------------- */
1441     SolarMutexClearableGuard aWriteLock;
1442
1443     bool bMustBeLayouted( false );
1444     bool bNotify( false );
1445
1446     bool bPreviewFrame;
1447     if (m_pToolbarManager)
1448         // Assumes that we created the ToolbarLayoutManager with our frame, if
1449         // not then we're somewhat fouled up ...
1450         bPreviewFrame = m_pToolbarManager->isPreviewFrame();
1451     else
1452     {
1453         Reference< XModel >  xModel( impl_getModelFromFrame( xFrame ) );
1454         bPreviewFrame = implts_isPreviewModel( xModel );
1455     }
1456
1457     if ( m_xContainerWindow.is() && !bPreviewFrame ) // no UI elements on preview frames
1458     {
1459         OUString aElementType;
1460         OUString aElementName;
1461
1462         parseResourceURL( aName, aElementType, aElementName );
1463
1464         if ( aElementType.equalsIgnoreAsciiCase( UIRESOURCETYPE_TOOLBAR ) && m_pToolbarManager != NULL )
1465         {
1466             bNotify         = m_pToolbarManager->createToolbar( aName );
1467             bMustBeLayouted = m_pToolbarManager->isLayoutDirty();
1468         }
1469         else if ( aElementType.equalsIgnoreAsciiCase("menubar") &&
1470                   aElementName.equalsIgnoreAsciiCase("menubar") )
1471         {
1472             // #i38743# don't create a menubar if frame isn't top
1473             if ( !bInPlaceMenu && !m_xMenuBar.is() && implts_isFrameOrWindowTop( xFrame ))
1474                 {
1475                 m_xMenuBar = implts_createElement( aName );
1476                 if ( m_xMenuBar.is() )
1477                 {
1478                     SolarMutexGuard aGuard;
1479
1480                     SystemWindow* pSysWindow = getTopSystemWindow( m_xContainerWindow );
1481                     if ( pSysWindow )
1482                     {
1483                         Reference< awt::XMenuBar > xMenuBar;
1484
1485                         Reference< XPropertySet > xPropSet( m_xMenuBar, UNO_QUERY );
1486                         if ( xPropSet.is() )
1487                         {
1488                             try
1489                             {
1490                                 xPropSet->getPropertyValue("XMenuBar") >>= xMenuBar;
1491                             }
1492                             catch (const beans::UnknownPropertyException&)
1493                             {
1494                             }
1495                             catch (const lang::WrappedTargetException&)
1496                             {
1497                             }
1498                         }
1499
1500                         if ( xMenuBar.is() )
1501                         {
1502                             VCLXMenu* pAwtMenuBar = VCLXMenu::GetImplementation( xMenuBar );
1503                             if ( pAwtMenuBar )
1504                             {
1505                                 MenuBar* pMenuBar = static_cast<MenuBar*>(pAwtMenuBar->GetMenu());
1506                                 if ( pMenuBar )
1507                                 {
1508                                     pSysWindow->SetMenuBar(pMenuBar, m_xFrame);
1509                                     pMenuBar->SetDisplayable( m_bMenuVisible );
1510                                     if ( m_bMenuVisible )
1511                                         bNotify = true;
1512                                     implts_updateMenuBarClose();
1513                                 }
1514                             }
1515                         }
1516                     }
1517                 }
1518             }
1519             aWriteLock.clear();
1520         }
1521         else if ( aElementType.equalsIgnoreAsciiCase("statusbar") &&
1522                   ( implts_isFrameOrWindowTop(xFrame) || implts_isEmbeddedLayoutManager() ))
1523         {
1524             implts_createStatusBar( aName );
1525             bNotify = true;
1526         }
1527         else if ( aElementType.equalsIgnoreAsciiCase("progressbar") &&
1528                   aElementName.equalsIgnoreAsciiCase("progressbar") &&
1529                   implts_isFrameOrWindowTop(xFrame) )
1530         {
1531             implts_createProgressBar();
1532             bNotify = true;
1533         }
1534         else if ( aElementType.equalsIgnoreAsciiCase("dockingwindow"))
1535         {
1536             // Add layout manager as listener for docking and other window events
1537             uno::Reference< uno::XInterface > xThis( static_cast< OWeakObject* >(this), uno::UNO_QUERY );
1538             uno::Reference< ui::XUIElement > xUIElement( implts_createDockingWindow( aName ));
1539
1540             if ( xUIElement.is() )
1541             {
1542                 impl_addWindowListeners( xThis, xUIElement );
1543             }
1544
1545             // The docking window is created by a factory method located in the sfx2 library.
1546 //            CreateDockingWindow( xFrame, aElementName );
1547         }
1548     }
1549
1550     if ( bMustBeLayouted )
1551         implts_doLayout_notify( true );
1552
1553     if ( bNotify )
1554     {
1555         // UI element is invisible - provide information to listeners
1556         implts_notifyListeners( frame::LayoutManagerEvents::UIELEMENT_VISIBLE, uno::makeAny( aName ) );
1557     }
1558 }
1559
1560 void SAL_CALL LayoutManager::destroyElement( const OUString& aName )
1561 throw (RuntimeException, std::exception)
1562 {
1563     SAL_INFO( "fwk", "framework (cd100003) ::LayoutManager::destroyElement" );
1564
1565     /* SAFE AREA ----------------------------------------------------------------------------------------------- */
1566     SolarMutexClearableGuard aWriteLock;
1567
1568     bool            bMustBeLayouted( false );
1569     bool            bNotify( false );
1570     OUString aElementType;
1571     OUString aElementName;
1572
1573     Reference< XComponent > xComponent;
1574     parseResourceURL( aName, aElementType, aElementName );
1575
1576     if ( aElementType.equalsIgnoreAsciiCase("menubar") &&
1577          aElementName.equalsIgnoreAsciiCase("menubar") )
1578     {
1579         if ( !m_bInplaceMenuSet )
1580         {
1581             impl_clearUpMenuBar();
1582             m_xMenuBar.clear();
1583             bNotify = true;
1584         }
1585     }
1586     else if (( aElementType.equalsIgnoreAsciiCase("statusbar") &&
1587                aElementName.equalsIgnoreAsciiCase("statusbar") ) ||
1588              ( m_aStatusBarElement.m_aName == aName ))
1589     {
1590         aWriteLock.clear();
1591         implts_destroyStatusBar();
1592         bMustBeLayouted = true;
1593         bNotify         = true;
1594     }
1595     else if ( aElementType.equalsIgnoreAsciiCase("progressbar") &&
1596               aElementName.equalsIgnoreAsciiCase("progressbar") )
1597     {
1598         aWriteLock.clear();
1599         implts_createProgressBar();
1600         bMustBeLayouted = true;
1601         bNotify = true;
1602     }
1603     else if ( aElementType.equalsIgnoreAsciiCase( UIRESOURCETYPE_TOOLBAR ) && m_pToolbarManager != NULL )
1604     {
1605         aWriteLock.clear();
1606         bNotify         = m_pToolbarManager->destroyToolbar( aName );
1607         bMustBeLayouted = m_pToolbarManager->isLayoutDirty();
1608     }
1609     else if ( aElementType.equalsIgnoreAsciiCase("dockingwindow"))
1610     {
1611         uno::Reference< frame::XFrame > xFrame( m_xFrame );
1612         uno::Reference< XComponentContext > xContext( m_xContext );
1613         aWriteLock.clear();
1614
1615         impl_setDockingWindowVisibility( xContext, xFrame, aElementName, false );
1616         bMustBeLayouted = false;
1617         bNotify         = false;
1618     }
1619     aWriteLock.clear();
1620     /* SAFE AREA ----------------------------------------------------------------------------------------------- */
1621
1622     if ( bMustBeLayouted )
1623         doLayout();
1624
1625     if ( bNotify )
1626         implts_notifyListeners( frame::LayoutManagerEvents::UIELEMENT_INVISIBLE, uno::makeAny( aName ) );
1627 }
1628
1629 sal_Bool SAL_CALL LayoutManager::requestElement( const OUString& rResourceURL )
1630 throw (uno::RuntimeException, std::exception)
1631 {
1632     bool            bResult( false );
1633     bool            bNotify( false );
1634     OUString aElementType;
1635     OUString aElementName;
1636
1637     parseResourceURL( rResourceURL, aElementType, aElementName );
1638
1639     SolarMutexClearableGuard aWriteLock;
1640
1641     OString aResName = OUStringToOString( aElementName, RTL_TEXTENCODING_ASCII_US );
1642     SAL_INFO( "fwk", "framework (cd100003) Element " << aResName.getStr() << " requested." );
1643
1644     if (( aElementType.equalsIgnoreAsciiCase("statusbar") &&
1645           aElementName.equalsIgnoreAsciiCase("statusbar") ) ||
1646         ( m_aStatusBarElement.m_aName == rResourceURL ))
1647     {
1648         implts_readStatusBarState( rResourceURL );
1649         if ( m_aStatusBarElement.m_bVisible && !m_aStatusBarElement.m_bMasterHide )
1650         {
1651             aWriteLock.clear();
1652             createElement( rResourceURL );
1653
1654             // There are some situation where we are not able to create an element.
1655             // Therefore we have to check the reference before further action.
1656             // See #i70019#
1657             uno::Reference< ui::XUIElement > xUIElement( m_aStatusBarElement.m_xUIElement );
1658             if ( xUIElement.is() )
1659             {
1660                 // we need VCL here to pass special flags to Show()
1661                 SolarMutexGuard aGuard;
1662                 Reference< awt::XWindow > xWindow( xUIElement->getRealInterface(), UNO_QUERY );
1663                 vcl::Window* pWindow = VCLUnoHelper::GetWindow( xWindow );
1664                 if ( pWindow )
1665                 {
1666                     pWindow->Show( true, SHOW_NOFOCUSCHANGE | SHOW_NOACTIVATE );
1667                     bResult   = true;
1668                     bNotify   = true;
1669                 }
1670             }
1671         }
1672     }
1673     else if ( aElementType.equalsIgnoreAsciiCase("progressbar") &&
1674               aElementName.equalsIgnoreAsciiCase("progressbar") )
1675     {
1676         aWriteLock.clear();
1677         implts_showProgressBar();
1678         bResult   = true;
1679         bNotify   = true;
1680     }
1681     else if ( aElementType.equalsIgnoreAsciiCase( UIRESOURCETYPE_TOOLBAR ) && m_bVisible )
1682     {
1683         bool bComponentAttached( !m_aModuleIdentifier.isEmpty() );
1684         ToolbarLayoutManager* pToolbarManager = m_pToolbarManager;
1685         aWriteLock.clear();
1686
1687         if ( pToolbarManager && bComponentAttached )
1688         {
1689                 bNotify   = pToolbarManager->requestToolbar( rResourceURL );
1690             }
1691     }
1692     else if ( aElementType.equalsIgnoreAsciiCase("dockingwindow"))
1693     {
1694         uno::Reference< frame::XFrame > xFrame( m_xFrame );
1695         aWriteLock.clear();
1696
1697         CreateDockingWindow( xFrame, aElementName );
1698     }
1699
1700     if ( bNotify )
1701         implts_notifyListeners( frame::LayoutManagerEvents::UIELEMENT_VISIBLE, uno::makeAny( rResourceURL ) );
1702
1703     return bResult;
1704 }
1705
1706 Reference< XUIElement > SAL_CALL LayoutManager::getElement( const OUString& aName )
1707 throw (RuntimeException, std::exception)
1708 {
1709     Reference< XUIElement > xUIElement = implts_findElement( aName );
1710     if ( !xUIElement.is() )
1711     {
1712         SolarMutexClearableGuard aReadLock;
1713         ToolbarLayoutManager*             pToolbarManager( m_pToolbarManager );
1714         aReadLock.clear();
1715
1716         if ( pToolbarManager )
1717             xUIElement = pToolbarManager->getToolbar( aName );
1718     }
1719
1720     return xUIElement;
1721 }
1722
1723 Sequence< Reference< ui::XUIElement > > SAL_CALL LayoutManager::getElements()
1724 throw (uno::RuntimeException, std::exception)
1725 {
1726     SolarMutexClearableGuard aReadLock;
1727     uno::Reference< ui::XUIElement >  xMenuBar( m_xMenuBar );
1728     uno::Reference< ui::XUIElement >  xStatusBar( m_aStatusBarElement.m_xUIElement );
1729     ToolbarLayoutManager*             pToolbarManager( m_pToolbarManager );
1730     aReadLock.clear();
1731
1732     Sequence< Reference< ui::XUIElement > > aSeq;
1733     if ( pToolbarManager )
1734         aSeq = pToolbarManager->getToolbars();
1735
1736     sal_Int32 nSize = aSeq.getLength();
1737     sal_Int32 nMenuBarIndex(-1);
1738     sal_Int32 nStatusBarIndex(-1);
1739     if ( xMenuBar.is() )
1740     {
1741         nMenuBarIndex = nSize;
1742         ++nSize;
1743     }
1744     if ( xStatusBar.is() )
1745     {
1746         nStatusBarIndex = nSize;
1747         ++nSize;
1748     }
1749
1750     aSeq.realloc(nSize);
1751     if ( nMenuBarIndex >= 0 )
1752         aSeq[nMenuBarIndex] = xMenuBar;
1753     if ( nStatusBarIndex >= 0 )
1754         aSeq[nStatusBarIndex] = xStatusBar;
1755
1756     return aSeq;
1757 }
1758
1759 sal_Bool SAL_CALL LayoutManager::showElement( const OUString& aName )
1760 throw (RuntimeException, std::exception)
1761 {
1762     SAL_INFO( "fwk", "framework (cd100003) ::LayoutManager::showElement" );
1763
1764     bool            bResult( false );
1765     bool            bNotify( false );
1766     bool            bMustLayout( false );
1767     OUString aElementType;
1768     OUString aElementName;
1769
1770     parseResourceURL( aName, aElementType, aElementName );
1771
1772     OString aResName = OUStringToOString( aElementName, RTL_TEXTENCODING_ASCII_US );
1773     SAL_INFO( "fwk", "framework (cd100003) Element " << aResName.getStr() );
1774
1775     if ( aElementType.equalsIgnoreAsciiCase("menubar") &&
1776          aElementName.equalsIgnoreAsciiCase("menubar") )
1777     {
1778         SolarMutexClearableGuard aWriteLock;
1779         m_bMenuVisible = true;
1780         aWriteLock.clear();
1781
1782         bResult = implts_resetMenuBar();
1783         bNotify = bResult;
1784     }
1785     else if (( aElementType.equalsIgnoreAsciiCase("statusbar") &&
1786                aElementName.equalsIgnoreAsciiCase("statusbar") ) ||
1787              ( m_aStatusBarElement.m_aName == aName ))
1788     {
1789         SolarMutexClearableGuard aWriteLock;
1790         if ( m_aStatusBarElement.m_xUIElement.is() && !m_aStatusBarElement.m_bMasterHide &&
1791              implts_showStatusBar( true ))
1792         {
1793             aWriteLock.clear();
1794
1795             implts_writeWindowStateData( STATUS_BAR_ALIAS, m_aStatusBarElement );
1796             bMustLayout = true;
1797             bResult     = true;
1798             bNotify     = true;
1799         }
1800     }
1801     else if ( aElementType.equalsIgnoreAsciiCase("progressbar") &&
1802               aElementName.equalsIgnoreAsciiCase("progressbar") )
1803     {
1804         bNotify = bResult = implts_showProgressBar();
1805     }
1806     else if ( aElementType.equalsIgnoreAsciiCase( UIRESOURCETYPE_TOOLBAR ))
1807     {
1808         SolarMutexClearableGuard aReadLock;
1809         ToolbarLayoutManager* pToolbarManager = m_pToolbarManager;
1810         aReadLock.clear();
1811
1812         if ( pToolbarManager )
1813         {
1814             bNotify     = pToolbarManager->showToolbar( aName );
1815             bMustLayout = pToolbarManager->isLayoutDirty();
1816         }
1817     }
1818     else if ( aElementType.equalsIgnoreAsciiCase("dockingwindow"))
1819     {
1820         SolarMutexClearableGuard aReadGuard;
1821         uno::Reference< frame::XFrame > xFrame( m_xFrame );
1822         uno::Reference< XComponentContext > xContext( m_xContext );
1823         aReadGuard.clear();
1824
1825         impl_setDockingWindowVisibility( xContext, xFrame, aElementName, true );
1826     }
1827     else if ( aElementType.equalsIgnoreAsciiCase("toolpanel"))
1828     {
1829         SolarMutexClearableGuard aReadGuard;
1830         uno::Reference< frame::XFrame > xFrame( m_xFrame );
1831         aReadGuard.clear();
1832         ActivateToolPanel( m_xFrame, aName );
1833     }
1834
1835     if ( bMustLayout )
1836         doLayout();
1837
1838     if ( bNotify )
1839         implts_notifyListeners( frame::LayoutManagerEvents::UIELEMENT_VISIBLE, uno::makeAny( aName ) );
1840
1841     return bResult;
1842 }
1843
1844 sal_Bool SAL_CALL LayoutManager::hideElement( const OUString& aName )
1845 throw (RuntimeException, std::exception)
1846 {
1847     SAL_INFO( "fwk", "framework (cd100003) ::LayoutManager::hideElement" );
1848
1849     bool            bNotify( false );
1850     bool            bMustLayout( false );
1851     OUString aElementType;
1852     OUString aElementName;
1853
1854     parseResourceURL( aName, aElementType, aElementName );
1855     OString aResName = OUStringToOString( aElementName, RTL_TEXTENCODING_ASCII_US );
1856     SAL_INFO( "fwk", "framework (cd100003) Element " << aResName.getStr() );
1857
1858     if ( aElementType.equalsIgnoreAsciiCase("menubar") &&
1859          aElementName.equalsIgnoreAsciiCase("menubar") )
1860     {
1861         SolarMutexGuard g;
1862
1863         if ( m_xContainerWindow.is() )
1864         {
1865             m_bMenuVisible = false;
1866
1867             SolarMutexGuard aGuard;
1868             SystemWindow* pSysWindow = getTopSystemWindow( m_xContainerWindow );
1869             if ( pSysWindow )
1870             {
1871                 MenuBar* pMenuBar = pSysWindow->GetMenuBar();
1872                 if ( pMenuBar )
1873                 {
1874                     pMenuBar->SetDisplayable( false );
1875                     bNotify = true;
1876                 }
1877             }
1878         }
1879     }
1880     else if (( aElementType.equalsIgnoreAsciiCase("statusbar") &&
1881                aElementName.equalsIgnoreAsciiCase("statusbar") ) ||
1882              ( m_aStatusBarElement.m_aName == aName ))
1883     {
1884         SolarMutexGuard g;
1885         if ( m_aStatusBarElement.m_xUIElement.is() && !m_aStatusBarElement.m_bMasterHide &&
1886              implts_hideStatusBar( true ))
1887         {
1888             implts_writeWindowStateData( STATUS_BAR_ALIAS, m_aStatusBarElement );
1889             bMustLayout = true;
1890             bNotify     = true;
1891         }
1892     }
1893     else if ( aElementType.equalsIgnoreAsciiCase("progressbar") &&
1894               aElementName.equalsIgnoreAsciiCase("progressbar") )
1895     {
1896         bNotify = implts_hideProgressBar();
1897     }
1898     else if ( aElementType.equalsIgnoreAsciiCase( UIRESOURCETYPE_TOOLBAR ))
1899     {
1900         SolarMutexClearableGuard aReadLock;
1901         ToolbarLayoutManager* pToolbarManager = m_pToolbarManager;
1902         aReadLock.clear();
1903
1904         if ( pToolbarManager )
1905         {
1906             bNotify     = pToolbarManager->hideToolbar( aName );
1907             bMustLayout = pToolbarManager->isLayoutDirty();
1908         }
1909     }
1910     else if ( aElementType.equalsIgnoreAsciiCase("dockingwindow"))
1911     {
1912         SolarMutexClearableGuard aReadGuard;
1913         uno::Reference< frame::XFrame > xFrame( m_xFrame );
1914         uno::Reference< XComponentContext > xContext( m_xContext );
1915         aReadGuard.clear();
1916
1917         impl_setDockingWindowVisibility( xContext, xFrame, aElementName, false );
1918     }
1919
1920     if ( bMustLayout )
1921         doLayout();
1922
1923     if ( bNotify )
1924         implts_notifyListeners( frame::LayoutManagerEvents::UIELEMENT_INVISIBLE, uno::makeAny( aName ) );
1925
1926     return sal_False;
1927 }
1928
1929 sal_Bool SAL_CALL LayoutManager::dockWindow( const OUString& aName, DockingArea DockingArea, const awt::Point& Pos )
1930 throw (RuntimeException, std::exception)
1931 {
1932     OUString aElementType;
1933     OUString aElementName;
1934
1935     parseResourceURL( aName, aElementType, aElementName );
1936     if ( aElementType.equalsIgnoreAsciiCase( UIRESOURCETYPE_TOOLBAR ))
1937     {
1938         SolarMutexClearableGuard aReadLock;
1939         ToolbarLayoutManager*             pToolbarManager = m_pToolbarManager;
1940         aReadLock.clear();
1941
1942         if ( pToolbarManager )
1943         {
1944             pToolbarManager->dockToolbar( aName, DockingArea, Pos );
1945             if ( pToolbarManager->isLayoutDirty() )
1946                 doLayout();
1947         }
1948     }
1949     return sal_False;
1950 }
1951
1952 sal_Bool SAL_CALL LayoutManager::dockAllWindows( ::sal_Int16 /*nElementType*/ ) throw (uno::RuntimeException, std::exception)
1953 {
1954     SolarMutexClearableGuard aReadLock;
1955     bool bResult( false );
1956     ToolbarLayoutManager*             pToolbarManager = m_pToolbarManager;
1957     aReadLock.clear();
1958
1959     if ( pToolbarManager )
1960     {
1961         bResult = pToolbarManager->dockAllToolbars();
1962         if ( pToolbarManager->isLayoutDirty() )
1963             doLayout();
1964     }
1965     return bResult;
1966 }
1967
1968 sal_Bool SAL_CALL LayoutManager::floatWindow( const OUString& aName )
1969 throw (RuntimeException, std::exception)
1970 {
1971     bool bResult( false );
1972     if ( getElementTypeFromResourceURL( aName ).equalsIgnoreAsciiCase( UIRESOURCETYPE_TOOLBAR ))
1973     {
1974         SolarMutexClearableGuard aReadLock;
1975         ToolbarLayoutManager*             pToolbarManager = m_pToolbarManager;
1976         aReadLock.clear();
1977
1978         if ( pToolbarManager )
1979         {
1980             bResult = pToolbarManager->floatToolbar( aName );
1981             if ( pToolbarManager->isLayoutDirty() )
1982                 doLayout();
1983         }
1984     }
1985     return bResult;
1986 }
1987
1988 sal_Bool SAL_CALL LayoutManager::lockWindow( const OUString& aName )
1989 throw (uno::RuntimeException, std::exception)
1990 {
1991     bool bResult( false );
1992     if ( getElementTypeFromResourceURL( aName ).equalsIgnoreAsciiCase( UIRESOURCETYPE_TOOLBAR ))
1993     {
1994         SolarMutexClearableGuard aReadLock;
1995         ToolbarLayoutManager*             pToolbarManager = m_pToolbarManager;
1996         aReadLock.clear();
1997
1998         if ( pToolbarManager )
1999         {
2000             bResult = pToolbarManager->lockToolbar( aName );
2001             if ( pToolbarManager->isLayoutDirty() )
2002                 doLayout();
2003         }
2004     }
2005     return bResult;
2006 }
2007
2008 sal_Bool SAL_CALL LayoutManager::unlockWindow( const OUString& aName )
2009 throw (uno::RuntimeException, std::exception)
2010 {
2011     bool bResult( false );
2012     if ( getElementTypeFromResourceURL( aName ).equalsIgnoreAsciiCase( UIRESOURCETYPE_TOOLBAR ))
2013     {
2014         SolarMutexClearableGuard aReadLock;
2015         ToolbarLayoutManager*             pToolbarManager = m_pToolbarManager;
2016         aReadLock.clear();
2017
2018         if ( pToolbarManager )
2019         {
2020             bResult = pToolbarManager->unlockToolbar( aName );
2021             if ( pToolbarManager->isLayoutDirty() )
2022                 doLayout();
2023         }
2024     }
2025     return bResult;
2026 }
2027
2028 void SAL_CALL LayoutManager::setElementSize( const OUString& aName, const awt::Size& aSize )
2029 throw (RuntimeException, std::exception)
2030 {
2031     if ( getElementTypeFromResourceURL( aName ).equalsIgnoreAsciiCase( UIRESOURCETYPE_TOOLBAR ))
2032     {
2033         SolarMutexClearableGuard aReadLock;
2034         ToolbarLayoutManager*             pToolbarManager = m_pToolbarManager;
2035         aReadLock.clear();
2036
2037         if ( pToolbarManager )
2038         {
2039             pToolbarManager->setToolbarSize( aName, aSize );
2040             if ( pToolbarManager->isLayoutDirty() )
2041                 doLayout();
2042         }
2043     }
2044 }
2045
2046 void SAL_CALL LayoutManager::setElementPos( const OUString& aName, const awt::Point& aPos )
2047 throw (RuntimeException, std::exception)
2048 {
2049     if ( getElementTypeFromResourceURL( aName ).equalsIgnoreAsciiCase( UIRESOURCETYPE_TOOLBAR ))
2050     {
2051         SolarMutexClearableGuard aReadLock;
2052         ToolbarLayoutManager* pToolbarManager( m_pToolbarManager );
2053         aReadLock.clear();
2054
2055         if ( pToolbarManager )
2056         {
2057             pToolbarManager->setToolbarPos( aName, aPos );
2058             if ( pToolbarManager->isLayoutDirty() )
2059                 doLayout();
2060         }
2061     }
2062 }
2063
2064 void SAL_CALL LayoutManager::setElementPosSize( const OUString& aName, const awt::Point& aPos, const awt::Size& aSize )
2065 throw (RuntimeException, std::exception)
2066 {
2067     if ( getElementTypeFromResourceURL( aName ).equalsIgnoreAsciiCase( UIRESOURCETYPE_TOOLBAR ))
2068     {
2069         SolarMutexClearableGuard aReadLock;
2070         ToolbarLayoutManager* pToolbarManager( m_pToolbarManager );
2071         aReadLock.clear();
2072
2073         if ( pToolbarManager )
2074         {
2075             pToolbarManager->setToolbarPosSize( aName, aPos, aSize );
2076             if ( pToolbarManager->isLayoutDirty() )
2077                 doLayout();
2078         }
2079     }
2080 }
2081
2082 sal_Bool SAL_CALL LayoutManager::isElementVisible( const OUString& aName )
2083 throw (RuntimeException, std::exception)
2084 {
2085     OUString aElementType;
2086     OUString aElementName;
2087
2088     parseResourceURL( aName, aElementType, aElementName );
2089     if ( aElementType.equalsIgnoreAsciiCase("menubar") &&
2090          aElementName.equalsIgnoreAsciiCase("menubar") )
2091     {
2092         SolarMutexResettableGuard aReadLock;
2093         if ( m_xContainerWindow.is() )
2094         {
2095             aReadLock.clear();
2096
2097             SolarMutexGuard aGuard;
2098             SystemWindow* pSysWindow = getTopSystemWindow( m_xContainerWindow );
2099             if ( pSysWindow )
2100             {
2101                 MenuBar* pMenuBar = pSysWindow->GetMenuBar();
2102                 if ( pMenuBar && pMenuBar->IsDisplayable() )
2103                     return sal_True;
2104             }
2105             else
2106             {
2107                 aReadLock.reset();
2108                 return m_bMenuVisible;
2109             }
2110         }
2111     }
2112     else if (( aElementType.equalsIgnoreAsciiCase("statusbar") &&
2113                aElementName.equalsIgnoreAsciiCase("statusbar") ) ||
2114              ( m_aStatusBarElement.m_aName == aName ))
2115     {
2116         if ( m_aStatusBarElement.m_xUIElement.is() )
2117         {
2118             Reference< awt::XWindow > xWindow( m_aStatusBarElement.m_xUIElement->getRealInterface(), UNO_QUERY );
2119             if ( xWindow.is() )
2120             {
2121                 SolarMutexGuard g;
2122                 vcl::Window* pWindow = VCLUnoHelper::GetWindow( xWindow );
2123                 if ( pWindow && pWindow->IsVisible() )
2124                     return sal_True;
2125                 else
2126                     return sal_False;
2127             }
2128         }
2129     }
2130     else if ( aElementType.equalsIgnoreAsciiCase("progressbar") &&
2131               aElementName.equalsIgnoreAsciiCase("progressbar") )
2132     {
2133         if ( m_aProgressBarElement.m_xUIElement.is() )
2134             return m_aProgressBarElement.m_bVisible;
2135     }
2136     else if ( aElementType.equalsIgnoreAsciiCase( UIRESOURCETYPE_TOOLBAR ))
2137     {
2138         SolarMutexClearableGuard aReadLock;
2139         ToolbarLayoutManager* pToolbarManager = m_pToolbarManager;
2140         aReadLock.clear();
2141
2142         if ( pToolbarManager )
2143             return pToolbarManager->isToolbarVisible( aName );
2144     }
2145     else if ( aElementType.equalsIgnoreAsciiCase("dockingwindow"))
2146     {
2147         SolarMutexClearableGuard aReadGuard;
2148         uno::Reference< frame::XFrame > xFrame( m_xFrame );
2149         aReadGuard.clear();
2150
2151         return IsDockingWindowVisible( xFrame, aElementName );
2152     }
2153
2154     return sal_False;
2155 }
2156
2157 sal_Bool SAL_CALL LayoutManager::isElementFloating( const OUString& aName )
2158 throw (RuntimeException, std::exception)
2159 {
2160     if ( getElementTypeFromResourceURL( aName ).equalsIgnoreAsciiCase( UIRESOURCETYPE_TOOLBAR ))
2161     {
2162         SolarMutexClearableGuard aReadLock;
2163         ToolbarLayoutManager* pToolbarManager = m_pToolbarManager;
2164         aReadLock.clear();
2165
2166         if ( pToolbarManager )
2167             return pToolbarManager->isToolbarFloating( aName );
2168     }
2169
2170     return sal_False;
2171 }
2172
2173 sal_Bool SAL_CALL LayoutManager::isElementDocked( const OUString& aName )
2174 throw (RuntimeException, std::exception)
2175 {
2176     if ( getElementTypeFromResourceURL( aName ).equalsIgnoreAsciiCase( UIRESOURCETYPE_TOOLBAR ))
2177     {
2178         SolarMutexClearableGuard aReadLock;
2179         ToolbarLayoutManager* pToolbarManager = m_pToolbarManager;
2180         aReadLock.clear();
2181
2182         if ( pToolbarManager )
2183             return pToolbarManager->isToolbarDocked( aName );
2184     }
2185
2186     return sal_False;
2187 }
2188
2189 sal_Bool SAL_CALL LayoutManager::isElementLocked( const OUString& aName )
2190 throw (uno::RuntimeException, std::exception)
2191 {
2192     if ( getElementTypeFromResourceURL( aName ).equalsIgnoreAsciiCase( UIRESOURCETYPE_TOOLBAR ))
2193     {
2194         SolarMutexClearableGuard aReadLock;
2195         ToolbarLayoutManager* pToolbarManager = m_pToolbarManager;
2196         aReadLock.clear();
2197
2198         if ( pToolbarManager )
2199             return pToolbarManager->isToolbarLocked( aName );
2200     }
2201
2202     return sal_False;
2203 }
2204
2205 awt::Size SAL_CALL LayoutManager::getElementSize( const OUString& aName )
2206 throw (RuntimeException, std::exception)
2207 {
2208     if ( getElementTypeFromResourceURL( aName ).equalsIgnoreAsciiCase( UIRESOURCETYPE_TOOLBAR ))
2209     {
2210         SolarMutexClearableGuard aReadLock;
2211         ToolbarLayoutManager* pToolbarManager = m_pToolbarManager;
2212         aReadLock.clear();
2213
2214         if ( pToolbarManager )
2215             return pToolbarManager->getToolbarSize( aName );
2216     }
2217
2218     return awt::Size();
2219 }
2220
2221 awt::Point SAL_CALL LayoutManager::getElementPos( const OUString& aName )
2222 throw (RuntimeException, std::exception)
2223 {
2224     if ( getElementTypeFromResourceURL( aName ).equalsIgnoreAsciiCase( UIRESOURCETYPE_TOOLBAR ))
2225     {
2226         SolarMutexClearableGuard aReadLock;
2227         ToolbarLayoutManager* pToolbarManager = m_pToolbarManager;
2228         aReadLock.clear();
2229
2230         if ( pToolbarManager )
2231             return pToolbarManager->getToolbarPos( aName );
2232     }
2233
2234     return awt::Point();
2235 }
2236
2237 void SAL_CALL LayoutManager::lock()
2238 throw (RuntimeException, std::exception)
2239 {
2240     implts_lock();
2241
2242     SolarMutexClearableGuard aReadLock;
2243     sal_Int32 nLockCount( m_nLockCount );
2244     aReadLock.clear();
2245
2246     SAL_INFO( "fwk", "framework (cd100003) ::LayoutManager::lock lockCount=" << nLockCount );
2247 #ifdef DBG_UTIL
2248     OStringBuffer aStr("LayoutManager::lock ");
2249     aStr.append(reinterpret_cast<sal_Int64>(this));
2250     aStr.append(" - ");
2251     aStr.append(nLockCount);
2252     SAL_INFO( "fwk", "" << aStr.getStr());
2253 #endif
2254
2255     Any a( nLockCount );
2256     implts_notifyListeners( frame::LayoutManagerEvents::LOCK, a );
2257 }
2258
2259 void SAL_CALL LayoutManager::unlock()
2260 throw (RuntimeException, std::exception)
2261 {
2262     bool bDoLayout( implts_unlock() );
2263
2264     SolarMutexClearableGuard aReadLock;
2265     sal_Int32 nLockCount( m_nLockCount );
2266     aReadLock.clear();
2267
2268     SAL_INFO( "fwk", "framework (cd100003) ::LayoutManager::unlock lockCount=" << nLockCount );
2269 #ifdef DBG_UTIL
2270     OStringBuffer aStr("LayoutManager::unlock ");
2271     aStr.append(reinterpret_cast<sal_Int64>(this));
2272     aStr.append(" - ");
2273     aStr.append(nLockCount);
2274     SAL_INFO( "fwk", "" << aStr.getStr());
2275 #endif
2276     // conform to documentation: unlock with lock count == 0 means force a layout
2277
2278     SolarMutexClearableGuard aWriteLock;
2279         if ( bDoLayout )
2280                 m_aAsyncLayoutTimer.Stop();
2281         aWriteLock.clear();
2282
2283     Any a( nLockCount );
2284     implts_notifyListeners( frame::LayoutManagerEvents::UNLOCK, a );
2285
2286     if ( bDoLayout )
2287         implts_doLayout_notify( true );
2288 }
2289
2290 void SAL_CALL LayoutManager::doLayout()
2291 throw (RuntimeException, std::exception)
2292 {
2293     implts_doLayout_notify( true );
2294 }
2295
2296 //  ILayoutNotifications
2297
2298 void LayoutManager::requestLayout( Hint eHint )
2299 {
2300     if ( eHint == HINT_TOOLBARSPACE_HAS_CHANGED )
2301         doLayout();
2302 }
2303
2304 void LayoutManager::implts_doLayout_notify( bool bOuterResize )
2305 {
2306     bool bLayouted = implts_doLayout( false, bOuterResize );
2307     if ( bLayouted )
2308         implts_notifyListeners( frame::LayoutManagerEvents::LAYOUT, Any() );
2309 }
2310
2311 bool LayoutManager::implts_doLayout( bool bForceRequestBorderSpace, bool bOuterResize )
2312 {
2313     SAL_INFO( "fwk", "framework (cd100003) ::LayoutManager::implts_doLayout" );
2314
2315     /* SAFE AREA ----------------------------------------------------------------------------------------------- */
2316     SolarMutexClearableGuard aReadLock;
2317
2318     if ( !m_xFrame.is() || !m_bParentWindowVisible )
2319         return false;
2320
2321     bool bPreserveContentSize( m_bPreserveContentSize );
2322     bool bMustDoLayout( m_bMustDoLayout );
2323     bool bNoLock = ( m_nLockCount == 0 );
2324     awt::Rectangle aCurrBorderSpace( m_aDockingArea );
2325     Reference< awt::XWindow > xContainerWindow( m_xContainerWindow );
2326     Reference< awt::XTopWindow2 > xContainerTopWindow( m_xContainerTopWindow );
2327     Reference< awt::XWindow > xComponentWindow( m_xFrame->getComponentWindow() );
2328     Reference< XDockingAreaAcceptor > xDockingAreaAcceptor( m_xDockingAreaAcceptor );
2329     aReadLock.clear();
2330     /* SAFE AREA ----------------------------------------------------------------------------------------------- */
2331
2332     bool bLayouted( false );
2333
2334     if ( bNoLock && xDockingAreaAcceptor.is() && xContainerWindow.is() && xComponentWindow.is() )
2335     {
2336         bLayouted = true;
2337
2338         SolarMutexResettableGuard aWriteGuard;
2339         m_bDoLayout = true;
2340         aWriteGuard.clear();
2341
2342         awt::Rectangle aDockSpace( implts_calcDockingAreaSizes() );
2343         awt::Rectangle aBorderSpace( aDockSpace );
2344         bool       bGotRequestedBorderSpace( true );
2345
2346         // We have to add the height of a possible status bar
2347         aBorderSpace.Height += implts_getStatusBarSize().Height();
2348
2349         if ( !equalRectangles( aBorderSpace, aCurrBorderSpace ) || bForceRequestBorderSpace || bMustDoLayout )
2350         {
2351             // we always resize the content window (instead of the complete container window) if we're not set up
2352             // to (attempt to) preserve the content window's size
2353             if ( bOuterResize && !bPreserveContentSize )
2354                 bOuterResize = false;
2355
2356             // maximized windows can resized their content window only, not their container window
2357             if ( bOuterResize && xContainerTopWindow.is() && xContainerTopWindow->getIsMaximized() )
2358                 bOuterResize = false;
2359
2360             // if the component window does not have a size (yet), then we can't use it to calc the container
2361             // window size
2362             awt::Rectangle aComponentRect = xComponentWindow->getPosSize();
2363             if ( bOuterResize && ( aComponentRect.Width == 0 ) && ( aComponentRect.Height == 0 ) )
2364                 bOuterResize = false;
2365
2366             bGotRequestedBorderSpace = false;
2367             if ( bOuterResize )
2368             {
2369                 Reference< awt::XDevice > xDevice( xContainerWindow, uno::UNO_QUERY );
2370                 awt::DeviceInfo aContainerInfo  = xDevice->getInfo();
2371
2372                 awt::Size aRequestedSize( aComponentRect.Width + aContainerInfo.LeftInset + aContainerInfo.RightInset + aBorderSpace.X + aBorderSpace.Width,
2373                                           aComponentRect.Height + aContainerInfo.TopInset  + aContainerInfo.BottomInset + aBorderSpace.Y + aBorderSpace.Height );
2374                 awt::Point aComponentPos( aBorderSpace.X, aBorderSpace.Y );
2375
2376                 bGotRequestedBorderSpace = implts_resizeContainerWindow( aRequestedSize, aComponentPos );
2377             }
2378
2379             // if we did not do an container window resize, or it failed, then use the DockingAcceptor as usual
2380             if ( !bGotRequestedBorderSpace )
2381                 bGotRequestedBorderSpace = xDockingAreaAcceptor->requestDockingAreaSpace( aBorderSpace );
2382
2383             if ( bGotRequestedBorderSpace )
2384             {
2385                 aWriteGuard.reset();
2386                 m_aDockingArea = aBorderSpace;
2387                 m_bMustDoLayout = false;
2388                 aWriteGuard.clear();
2389             }
2390         }
2391
2392         if ( bGotRequestedBorderSpace )
2393         {
2394             ::Size      aContainerSize;
2395             ::Size      aStatusBarSize;
2396
2397             // Interim solution to let the layout method within the
2398             // toolbar layout manager.
2399             implts_setOffset( implts_getStatusBarSize().Height() );
2400             if ( m_pToolbarManager )
2401                 m_pToolbarManager->setDockingArea( aDockSpace );
2402
2403             // Subtract status bar size from our container output size. Docking area windows
2404             // don't contain the status bar!
2405             aStatusBarSize = implts_getStatusBarSize();
2406             aContainerSize = implts_getContainerWindowOutputSize();
2407             aContainerSize.Height() -= aStatusBarSize.Height();
2408
2409             if ( m_pToolbarManager )
2410                 m_pToolbarManager->doLayout(aContainerSize);
2411
2412             // Position the status bar
2413             if ( aStatusBarSize.Height() > 0 )
2414             {
2415                 implts_setStatusBarPosSize( ::Point( 0, std::max(( aContainerSize.Height() ), long( 0 ))),
2416                                             ::Size( aContainerSize.Width(),aStatusBarSize.Height() ));
2417             }
2418
2419             xDockingAreaAcceptor->setDockingAreaSpace( aBorderSpace );
2420
2421             aWriteGuard.reset();
2422             m_bDoLayout = false;
2423             aWriteGuard.clear();
2424         }
2425     }
2426
2427     return bLayouted;
2428 }
2429
2430 bool LayoutManager::implts_resizeContainerWindow( const awt::Size& rContainerSize,
2431                                                       const awt::Point& rComponentPos )
2432 {
2433     SolarMutexClearableGuard aReadLock;
2434     Reference< awt::XWindow >               xContainerWindow    = m_xContainerWindow;
2435     Reference< awt::XTopWindow2 >           xContainerTopWindow = m_xContainerTopWindow;
2436     Reference< awt::XWindow >               xComponentWindow    = m_xFrame->getComponentWindow();
2437     aReadLock.clear();
2438
2439     // calculate the maximum size we have for the container window
2440     sal_Int32 nDisplay = xContainerTopWindow->getDisplay();
2441     Rectangle aWorkArea = Application::GetScreenPosSizePixel( nDisplay );
2442
2443     if (( aWorkArea.GetWidth() > 0 ) && ( aWorkArea.GetHeight() > 0 ))
2444     {
2445         if (( rContainerSize.Width > aWorkArea.GetWidth() ) || ( rContainerSize.Height > aWorkArea.GetHeight() ))
2446             return false;
2447         // Strictly, this is not correct. If we have a multi-screen display (css.awt.DisplayAccess.MultiDisplay == true),
2448         // the "effective work area" would be much larger than the work area of a single display, since we could in theory
2449         // position the container window across multiple screens.
2450         // However, this should suffice as a heuristics here ... (nobody really wants to check whether the different screens are
2451         // stacked horizontally or vertically, whether their work areas can really be combined, or are separated by non-work-areas,
2452         // and the like ... right?)
2453     }
2454
2455     // resize our container window
2456     xContainerWindow->setPosSize( 0, 0, rContainerSize.Width, rContainerSize.Height, awt::PosSize::SIZE );
2457     // position the component window
2458     xComponentWindow->setPosSize( rComponentPos.X, rComponentPos.Y, 0, 0, awt::PosSize::POS );
2459     return true;
2460 }
2461
2462 void SAL_CALL LayoutManager::setVisible( sal_Bool bVisible )
2463 throw (uno::RuntimeException, std::exception)
2464 {
2465     SolarMutexClearableGuard aWriteLock;
2466     bool bWasVisible( m_bVisible );
2467     m_bVisible = bVisible;
2468     aWriteLock.clear();
2469
2470     if ( bWasVisible != bool(bVisible) )
2471         implts_setVisibleState( bVisible );
2472 }
2473
2474 sal_Bool SAL_CALL LayoutManager::isVisible()
2475 throw (uno::RuntimeException, std::exception)
2476 {
2477     SolarMutexGuard g;
2478     return m_bVisible;
2479 }
2480
2481 ::Size LayoutManager::implts_getStatusBarSize()
2482 {
2483     SolarMutexClearableGuard aReadLock;
2484     bool bStatusBarVisible( isElementVisible( STATUS_BAR_ALIAS ));
2485     bool bProgressBarVisible( isElementVisible( PROGRESS_BAR_ALIAS ));
2486     bool bVisible( m_bVisible );
2487     Reference< XUIElement > xStatusBar( m_aStatusBarElement.m_xUIElement );
2488     Reference< XUIElement > xProgressBar( m_aProgressBarElement.m_xUIElement );
2489
2490     Reference< awt::XWindow > xWindow;
2491     if ( bStatusBarVisible && bVisible && xStatusBar.is() )
2492         xWindow = Reference< awt::XWindow >( xStatusBar->getRealInterface(), UNO_QUERY );
2493     else if ( xProgressBar.is() && !xStatusBar.is() && bProgressBarVisible )
2494     {
2495         ProgressBarWrapper* pWrapper = static_cast<ProgressBarWrapper*>(xProgressBar.get());
2496         if ( pWrapper )
2497             xWindow = pWrapper->getStatusBar();
2498     }
2499     aReadLock.clear();
2500
2501     if ( xWindow.is() )
2502     {
2503         awt::Rectangle aPosSize = xWindow->getPosSize();
2504         return ::Size( aPosSize.Width, aPosSize.Height );
2505     }
2506     else
2507         return ::Size();
2508 }
2509
2510 awt::Rectangle LayoutManager::implts_calcDockingAreaSizes()
2511 {
2512     SolarMutexClearableGuard aReadLock;
2513     Reference< awt::XWindow > xContainerWindow( m_xContainerWindow );
2514     Reference< XDockingAreaAcceptor > xDockingAreaAcceptor( m_xDockingAreaAcceptor );
2515     aReadLock.clear();
2516
2517     awt::Rectangle aBorderSpace;
2518     if ( m_pToolbarManager && xDockingAreaAcceptor.is() && xContainerWindow.is() )
2519         aBorderSpace = m_pToolbarManager->getDockingArea();
2520
2521     return aBorderSpace;
2522 }
2523
2524 void LayoutManager::implts_setDockingAreaWindowSizes( const awt::Rectangle& /*rBorderSpace*/ )
2525 {
2526     SolarMutexClearableGuard aReadLock;
2527     Reference< awt::XWindow > xContainerWindow( m_xContainerWindow );
2528     aReadLock.clear();
2529
2530     uno::Reference< awt::XDevice > xDevice( xContainerWindow, uno::UNO_QUERY );
2531     // Convert relativ size to output size.
2532     awt::Rectangle  aRectangle           = xContainerWindow->getPosSize();
2533     awt::DeviceInfo aInfo                = xDevice->getInfo();
2534     awt::Size       aContainerClientSize = awt::Size( aRectangle.Width - aInfo.LeftInset - aInfo.RightInset,
2535                                                       aRectangle.Height - aInfo.TopInset  - aInfo.BottomInset );
2536     ::Size          aStatusBarSize       = implts_getStatusBarSize();
2537
2538     // Position the status bar
2539     if ( aStatusBarSize.Height() > 0 )
2540     {
2541         implts_setStatusBarPosSize( ::Point( 0, std::max(( aContainerClientSize.Height - aStatusBarSize.Height() ), long( 0 ))),
2542                                     ::Size( aContainerClientSize.Width, aStatusBarSize.Height() ));
2543     }
2544 }
2545
2546 void LayoutManager::implts_updateMenuBarClose()
2547 {
2548     SolarMutexClearableGuard aWriteLock;
2549     bool                      bShowCloseButton( m_bMenuBarCloseButton );
2550     Reference< awt::XWindow > xContainerWindow( m_xContainerWindow );
2551     aWriteLock.clear();
2552
2553     if ( xContainerWindow.is() )
2554     {
2555         SolarMutexGuard aGuard;
2556
2557         SystemWindow* pSysWindow = getTopSystemWindow( xContainerWindow );
2558         if ( pSysWindow )
2559         {
2560             MenuBar* pMenuBar = pSysWindow->GetMenuBar();
2561             if ( pMenuBar )
2562             {
2563                 // TODO remove link on sal_False ?!
2564                 pMenuBar->ShowCloseButton(bShowCloseButton);
2565                 pMenuBar->SetCloseButtonClickHdl(LINK(this, LayoutManager, MenuBarClose));
2566             }
2567         }
2568     }
2569 }
2570
2571 bool LayoutManager::implts_resetMenuBar()
2572 {
2573     /* SAFE AREA ----------------------------------------------------------------------------------------------- */
2574     SolarMutexClearableGuard aWriteLock;
2575     bool bMenuVisible( m_bMenuVisible );
2576     Reference< awt::XWindow > xContainerWindow( m_xContainerWindow );
2577
2578     MenuBar* pSetMenuBar = 0;
2579     if ( m_xInplaceMenuBar.is() )
2580         pSetMenuBar = static_cast<MenuBar *>(m_pInplaceMenuBar->GetMenuBar());
2581     else
2582     {
2583         MenuBarWrapper* pMenuBarWrapper = static_cast< MenuBarWrapper* >( m_xMenuBar.get() );
2584         if ( pMenuBarWrapper )
2585             pSetMenuBar = static_cast<MenuBar*>(pMenuBarWrapper->GetMenuBarManager()->GetMenuBar());
2586     }
2587     aWriteLock.clear();
2588     /* SAFE AREA ----------------------------------------------------------------------------------------------- */
2589
2590     SolarMutexGuard aGuard;
2591     SystemWindow* pSysWindow = getTopSystemWindow( xContainerWindow );
2592     if ( pSysWindow && bMenuVisible && pSetMenuBar )
2593     {
2594         pSysWindow->SetMenuBar(pSetMenuBar, m_xFrame);
2595         pSetMenuBar->SetDisplayable( true );
2596         return true;
2597     }
2598
2599     return false;
2600 }
2601
2602 IMPL_LINK_NOARG(LayoutManager, MenuBarClose)
2603 {
2604     SolarMutexClearableGuard aReadLock;
2605     uno::Reference< frame::XDispatchProvider >   xProvider(m_xFrame, uno::UNO_QUERY);
2606     uno::Reference< XComponentContext > xContext( m_xContext );
2607     aReadLock.clear();
2608
2609     if ( !xProvider.is())
2610         return 0;
2611
2612     uno::Reference< frame::XDispatchHelper > xDispatcher = frame::DispatchHelper::create( xContext );
2613
2614     xDispatcher->executeDispatch(
2615         xProvider,
2616         OUString(".uno:CloseWin"),
2617         OUString("_self"),
2618         0,
2619         uno::Sequence< beans::PropertyValue >());
2620
2621     return 0;
2622 }
2623
2624 IMPL_STATIC_LINK_NOARG(LayoutManager, SettingsChanged)
2625 {
2626     return 1;
2627 }
2628
2629 //  XLayoutManagerEventBroadcaster
2630
2631 void SAL_CALL LayoutManager::addLayoutManagerEventListener( const uno::Reference< frame::XLayoutManagerListener >& xListener )
2632 throw (uno::RuntimeException, std::exception)
2633 {
2634     m_aListenerContainer.addInterface( cppu::UnoType<frame::XLayoutManagerListener>::get(), xListener );
2635 }
2636
2637 void SAL_CALL LayoutManager::removeLayoutManagerEventListener( const uno::Reference< frame::XLayoutManagerListener >& xListener )
2638 throw (uno::RuntimeException, std::exception)
2639 {
2640     m_aListenerContainer.removeInterface( cppu::UnoType<frame::XLayoutManagerListener>::get(), xListener );
2641 }
2642
2643 void LayoutManager::implts_notifyListeners(short nEvent, const uno::Any& rInfoParam)
2644 {
2645     lang::EventObject                  aSource( static_cast< ::cppu::OWeakObject*>(this) );
2646     ::cppu::OInterfaceContainerHelper* pContainer = m_aListenerContainer.getContainer( cppu::UnoType<frame::XLayoutManagerListener>::get());
2647     if (pContainer!=NULL)
2648     {
2649         ::cppu::OInterfaceIteratorHelper pIterator(*pContainer);
2650         while (pIterator.hasMoreElements())
2651         {
2652             try
2653             {
2654                 static_cast<frame::XLayoutManagerListener*>(pIterator.next())->layoutEvent(aSource, nEvent, rInfoParam);
2655             }
2656             catch( const uno::RuntimeException& )
2657             {
2658                 pIterator.remove();
2659             }
2660         }
2661     }
2662 }
2663
2664 //      XWindowListener
2665
2666 void SAL_CALL LayoutManager::windowResized( const awt::WindowEvent& aEvent )
2667 throw( uno::RuntimeException, std::exception )
2668 {
2669     SolarMutexGuard g;
2670     Reference< awt::XWindow >         xContainerWindow( m_xContainerWindow );
2671
2672     Reference< XInterface > xIfac( xContainerWindow, UNO_QUERY );
2673     if ( xIfac == aEvent.Source && m_bVisible )
2674     {
2675         // We have to call our resize handler at least once synchronously, as some
2676         // application modules need this. So we have to check if this is the first
2677         // call after the async layout time expired.
2678         m_bMustDoLayout = true;
2679         if ( !m_aAsyncLayoutTimer.IsActive() )
2680         {
2681             const Link<Timer *, void>& aLink = m_aAsyncLayoutTimer.GetTimeoutHdl();
2682             if ( aLink.IsSet() )
2683                 aLink.Call( &m_aAsyncLayoutTimer );
2684         }
2685         if ( m_nLockCount == 0 )
2686             m_aAsyncLayoutTimer.Start();
2687     }
2688     else if ( m_xFrame.is() && aEvent.Source == m_xFrame->getContainerWindow() )
2689     {
2690         // the container window of my DockingAreaAcceptor is not the same as of my frame
2691         // I still have to resize my frames' window as nobody else will do it
2692         Reference< awt::XWindow > xComponentWindow( m_xFrame->getComponentWindow() );
2693         if( xComponentWindow.is() )
2694         {
2695             uno::Reference< awt::XDevice > xDevice( m_xFrame->getContainerWindow(), uno::UNO_QUERY );
2696
2697             // Convert relativ size to output size.
2698             awt::Rectangle  aRectangle = m_xFrame->getContainerWindow()->getPosSize();
2699             awt::DeviceInfo aInfo      = xDevice->getInfo();
2700             awt::Size       aSize(  aRectangle.Width  - aInfo.LeftInset - aInfo.RightInset  ,
2701                                     aRectangle.Height - aInfo.TopInset  - aInfo.BottomInset );
2702
2703             // Resize our component window.
2704             xComponentWindow->setPosSize( 0, 0, aSize.Width, aSize.Height, awt::PosSize::POSSIZE );
2705         }
2706     }
2707 }
2708
2709 void SAL_CALL LayoutManager::windowMoved( const awt::WindowEvent& ) throw( uno::RuntimeException, std::exception )
2710 {
2711 }
2712
2713 void SAL_CALL LayoutManager::windowShown( const lang::EventObject& aEvent ) throw( uno::RuntimeException, std::exception )
2714 {
2715     SolarMutexClearableGuard aReadLock;
2716     Reference< awt::XWindow >  xContainerWindow( m_xContainerWindow );
2717     bool                       bParentWindowVisible( m_bParentWindowVisible );
2718     aReadLock.clear();
2719
2720     Reference< XInterface > xIfac( xContainerWindow, UNO_QUERY );
2721     if ( xIfac == aEvent.Source )
2722     {
2723         SolarMutexClearableGuard aWriteLock;
2724         m_bParentWindowVisible = true;
2725         bool bSetVisible = ( m_bParentWindowVisible != bParentWindowVisible );
2726         aWriteLock.clear();
2727
2728         if ( bSetVisible )
2729             implts_updateUIElementsVisibleState( true );
2730     }
2731 }
2732
2733 void SAL_CALL LayoutManager::windowHidden( const lang::EventObject& aEvent ) throw( uno::RuntimeException, std::exception )
2734 {
2735     SolarMutexClearableGuard aReadLock;
2736     Reference< awt::XWindow > xContainerWindow( m_xContainerWindow );
2737     bool                      bParentWindowVisible( m_bParentWindowVisible );
2738     aReadLock.clear();
2739
2740     Reference< XInterface > xIfac( xContainerWindow, UNO_QUERY );
2741     if ( xIfac == aEvent.Source )
2742     {
2743         SolarMutexClearableGuard aWriteLock;
2744         m_bParentWindowVisible = false;
2745         bool bSetInvisible = ( m_bParentWindowVisible != bParentWindowVisible );
2746         aWriteLock.clear();
2747
2748         if ( bSetInvisible )
2749             implts_updateUIElementsVisibleState( false );
2750     }
2751 }
2752
2753 IMPL_LINK_NOARG_TYPED(LayoutManager, AsyncLayoutHdl, Timer *, void)
2754 {
2755     SolarMutexClearableGuard aReadLock;
2756     m_aAsyncLayoutTimer.Stop();
2757
2758     if( !m_xContainerWindow.is() )
2759         return;
2760
2761     awt::Rectangle aDockingArea( m_aDockingArea );
2762     ::Size         aStatusBarSize( implts_getStatusBarSize() );
2763
2764     // Subtract status bar height
2765     aDockingArea.Height -= aStatusBarSize.Height();
2766     aReadLock.clear();
2767
2768     implts_setDockingAreaWindowSizes( aDockingArea );
2769     implts_doLayout( true, false );
2770 }
2771
2772 //      XFrameActionListener
2773
2774 void SAL_CALL LayoutManager::frameAction( const FrameActionEvent& aEvent )
2775 throw ( RuntimeException, std::exception )
2776 {
2777     if (( aEvent.Action == FrameAction_COMPONENT_ATTACHED ) || ( aEvent.Action == FrameAction_COMPONENT_REATTACHED ))
2778     {
2779         SAL_INFO( "fwk", "framework (cd100003) ::LayoutManager::frameAction (COMPONENT_ATTACHED|REATTACHED)" );
2780
2781         SolarMutexClearableGuard aWriteLock;
2782         m_bComponentAttached = true;
2783         m_bMustDoLayout = true;
2784         aWriteLock.clear();
2785
2786         implts_reset( true );
2787         implts_doLayout( true, false );
2788         implts_doLayout( true, true );
2789     }
2790     else if (( aEvent.Action == FrameAction_FRAME_UI_ACTIVATED ) || ( aEvent.Action == FrameAction_FRAME_UI_DEACTIVATING ))
2791     {
2792         SAL_INFO( "fwk", "framework (cd100003) ::LayoutManager::frameAction (FRAME_UI_ACTIVATED|DEACTIVATING)" );
2793
2794         SolarMutexClearableGuard aWriteLock;
2795         m_bActive = ( aEvent.Action == FrameAction_FRAME_UI_ACTIVATED );
2796         aWriteLock.clear();
2797
2798         implts_toggleFloatingUIElementsVisibility( aEvent.Action == FrameAction_FRAME_UI_ACTIVATED );
2799     }
2800     else if ( aEvent.Action == FrameAction_COMPONENT_DETACHING )
2801     {
2802         SAL_INFO( "fwk", "framework (cd100003) ::LayoutManager::frameAction (COMPONENT_DETACHING)" );
2803
2804         SolarMutexClearableGuard aWriteLock;
2805         m_bComponentAttached = false;
2806         aWriteLock.clear();
2807
2808         implts_reset( false );
2809     }
2810 }
2811
2812 void SAL_CALL LayoutManager::disposing( const lang::EventObject& rEvent )
2813 throw( RuntimeException, std::exception )
2814 {
2815     bool bDisposeAndClear( false );
2816
2817     /* SAFE AREA ----------------------------------------------------------------------------------------------- */
2818     SolarMutexClearableGuard aWriteLock;
2819
2820     if ( rEvent.Source == Reference< XInterface >( m_xFrame, UNO_QUERY ))
2821     {
2822         // Our frame gets disposed, release all our references that depends on a working frame reference.
2823         Application::RemoveEventListener( LINK( this, LayoutManager, SettingsChanged ) );
2824
2825         setDockingAreaAcceptor( Reference< ui::XDockingAreaAcceptor >() );
2826
2827         // destroy all elements, it's possible that dettaching is NOT called!
2828         implts_destroyElements();
2829         impl_clearUpMenuBar();
2830         m_xMenuBar.clear();
2831         if ( m_xInplaceMenuBar.is() )
2832         {
2833             m_pInplaceMenuBar = 0;
2834             m_xInplaceMenuBar->dispose();
2835         }
2836         m_xInplaceMenuBar.clear();
2837         m_xContainerWindow.clear();
2838         m_xContainerTopWindow.clear();
2839
2840         // forward disposing call to toolbar manager
2841         if ( m_pToolbarManager != NULL )
2842             m_pToolbarManager->disposing(rEvent);
2843
2844         if ( m_xModuleCfgMgr.is() )
2845         {
2846             try
2847             {
2848                 Reference< XUIConfiguration > xModuleCfgMgr( m_xModuleCfgMgr, UNO_QUERY );
2849                 xModuleCfgMgr->removeConfigurationListener(
2850                     Reference< XUIConfigurationListener >( static_cast< OWeakObject* >( this ), UNO_QUERY ));
2851             }
2852             catch (const Exception&)
2853             {
2854             }
2855         }
2856
2857         if ( m_xDocCfgMgr.is() )
2858         {
2859             try
2860             {
2861                 Reference< XUIConfiguration > xDocCfgMgr( m_xDocCfgMgr, UNO_QUERY );
2862                 xDocCfgMgr->removeConfigurationListener(
2863                     Reference< XUIConfigurationListener >( static_cast< OWeakObject* >( this ), UNO_QUERY ));
2864             }
2865             catch (const Exception&)
2866             {
2867             }
2868         }
2869
2870         m_xDocCfgMgr.clear();
2871         m_xModuleCfgMgr.clear();
2872         m_xFrame.clear();
2873         delete m_pGlobalSettings;
2874         m_pGlobalSettings = 0;
2875
2876         bDisposeAndClear = true;
2877     }
2878     else if ( rEvent.Source == Reference< XInterface >( m_xContainerWindow, UNO_QUERY ))
2879     {
2880         // Our container window gets disposed. Remove all user interface elements.
2881         ToolbarLayoutManager* pToolbarManager = m_pToolbarManager;
2882         if ( pToolbarManager )
2883         {
2884             uno::Reference< awt::XWindowPeer > aEmptyWindowPeer;
2885             pToolbarManager->setParentWindow( aEmptyWindowPeer );
2886         }
2887         impl_clearUpMenuBar();
2888         m_xMenuBar.clear();
2889         if ( m_xInplaceMenuBar.is() )
2890         {
2891             m_pInplaceMenuBar = 0;
2892             m_xInplaceMenuBar->dispose();
2893         }
2894         m_xInplaceMenuBar.clear();
2895         m_xContainerWindow.clear();
2896         m_xContainerTopWindow.clear();
2897     }
2898     else if ( rEvent.Source == Reference< XInterface >( m_xDocCfgMgr, UNO_QUERY ))
2899         m_xDocCfgMgr.clear();
2900     else if ( rEvent.Source == Reference< XInterface >( m_xModuleCfgMgr , UNO_QUERY ))
2901         m_xModuleCfgMgr.clear();
2902
2903     aWriteLock.clear();
2904     /* SAFE AREA ----------------------------------------------------------------------------------------------- */
2905
2906     // Send disposing to our listener when we have lost our frame.
2907     if ( bDisposeAndClear )
2908     {
2909         // Send message to all listener and forget her references.
2910         uno::Reference< frame::XLayoutManager > xThis( static_cast< ::cppu::OWeakObject* >(this), uno::UNO_QUERY );
2911         lang::EventObject aEvent( xThis );
2912         m_aListenerContainer.disposeAndClear( aEvent );
2913     }
2914 }
2915
2916 void SAL_CALL LayoutManager::elementInserted( const ui::ConfigurationEvent& Event ) throw (uno::RuntimeException, std::exception)
2917 {
2918     SolarMutexClearableGuard aReadLock;
2919     Reference< XFrame > xFrame( m_xFrame );
2920     Reference< ui::XUIConfigurationListener > xUICfgListener( m_xToolbarManager );
2921     ToolbarLayoutManager* pToolbarManager = m_pToolbarManager;
2922     aReadLock.clear();
2923
2924     if ( xFrame.is() )
2925     {
2926         OUString aElementType;
2927         OUString aElementName;
2928         bool            bRefreshLayout(false);
2929
2930         parseResourceURL( Event.ResourceURL, aElementType, aElementName );
2931         if ( aElementType.equalsIgnoreAsciiCase( UIRESOURCETYPE_TOOLBAR ))
2932         {
2933             if ( xUICfgListener.is() )
2934             {
2935                 xUICfgListener->elementInserted( Event );
2936                 bRefreshLayout = pToolbarManager->isLayoutDirty();
2937             }
2938         }
2939         else if ( aElementType.equalsIgnoreAsciiCase( UIRESOURCETYPE_MENUBAR ))
2940         {
2941             Reference< XUIElement >         xUIElement = implts_findElement( Event.ResourceURL );
2942             Reference< XUIElementSettings > xElementSettings( xUIElement, UNO_QUERY );
2943             if ( xElementSettings.is() )
2944             {
2945                 OUString aConfigSourcePropName( "ConfigurationSource" );
2946                 uno::Reference< XPropertySet > xPropSet( xElementSettings, uno::UNO_QUERY );
2947                 if ( xPropSet.is() )
2948                 {
2949                     if ( Event.Source == uno::Reference< uno::XInterface >( m_xDocCfgMgr, uno::UNO_QUERY ))
2950                         xPropSet->setPropertyValue( aConfigSourcePropName, makeAny( m_xDocCfgMgr ));
2951                 }
2952                 xElementSettings->updateSettings();
2953             }
2954         }
2955
2956         if ( bRefreshLayout )
2957             doLayout();
2958     }
2959 }
2960
2961 void SAL_CALL LayoutManager::elementRemoved( const ui::ConfigurationEvent& Event ) throw (uno::RuntimeException, std::exception)
2962 {
2963     SolarMutexClearableGuard aReadLock;
2964     Reference< frame::XFrame >                xFrame( m_xFrame );
2965     Reference< ui::XUIConfigurationListener > xToolbarManager( m_xToolbarManager );
2966     Reference< awt::XWindow >                 xContainerWindow( m_xContainerWindow );
2967     Reference< ui::XUIElement >               xMenuBar( m_xMenuBar );
2968     Reference< ui::XUIConfigurationManager >  xModuleCfgMgr( m_xModuleCfgMgr );
2969     Reference< ui::XUIConfigurationManager >  xDocCfgMgr( m_xDocCfgMgr );
2970     ToolbarLayoutManager*                     pToolbarManager = m_pToolbarManager;
2971     aReadLock.clear();
2972
2973     if ( xFrame.is() )
2974     {
2975        OUString aElementType;
2976        OUString aElementName;
2977        bool            bRefreshLayout(false);
2978
2979        parseResourceURL( Event.ResourceURL, aElementType, aElementName );
2980         if ( aElementType.equalsIgnoreAsciiCase( UIRESOURCETYPE_TOOLBAR ))
2981         {
2982             if ( xToolbarManager.is() )
2983             {
2984                 xToolbarManager->elementRemoved( Event );
2985                 bRefreshLayout = pToolbarManager->isLayoutDirty();
2986             }
2987         }
2988         else
2989         {
2990             Reference< XUIElement > xUIElement = implts_findElement( Event.ResourceURL );
2991             Reference< XUIElementSettings > xElementSettings( xUIElement, UNO_QUERY );
2992             if ( xElementSettings.is() )
2993             {
2994                 bool                      bNoSettings( false );
2995                 OUString           aConfigSourcePropName( "ConfigurationSource" );
2996                 Reference< XInterface >   xElementCfgMgr;
2997                 Reference< XPropertySet > xPropSet( xElementSettings, UNO_QUERY );
2998
2999                 if ( xPropSet.is() )
3000                     xPropSet->getPropertyValue( aConfigSourcePropName ) >>= xElementCfgMgr;
3001
3002                 if ( !xElementCfgMgr.is() )
3003                     return;
3004
3005                 // Check if the same UI configuration manager has changed => check further
3006                 if ( Event.Source == xElementCfgMgr )
3007                 {
3008                     // Same UI configuration manager where our element has its settings
3009                     if ( Event.Source == Reference< XInterface >( xDocCfgMgr, UNO_QUERY ))
3010                     {
3011                         // document settings removed
3012                         if ( xModuleCfgMgr->hasSettings( Event.ResourceURL ))
3013                         {
3014                             xPropSet->setPropertyValue( aConfigSourcePropName, makeAny( m_xModuleCfgMgr ));
3015                             xElementSettings->updateSettings();
3016                             return;
3017                         }
3018                     }
3019
3020                     bNoSettings = true;
3021                 }
3022
3023                 // No settings anymore, element must be destroyed
3024                     if ( xContainerWindow.is() && bNoSettings )
3025                 {
3026                     if ( aElementType.equalsIgnoreAsciiCase("menubar") &&
3027                          aElementName.equalsIgnoreAsciiCase("menubar") )
3028                     {
3029                         SystemWindow* pSysWindow = getTopSystemWindow( xContainerWindow );
3030                         if ( pSysWindow && !m_bInplaceMenuSet )
3031                             pSysWindow->SetMenuBar( 0 );
3032
3033                         Reference< XComponent > xComp( xMenuBar, UNO_QUERY );
3034                         if ( xComp.is() )
3035                             xComp->dispose();
3036
3037                         SolarMutexGuard g;
3038                         m_xMenuBar.clear();
3039                     }
3040                 }
3041             }
3042         }
3043
3044         if ( bRefreshLayout )
3045             doLayout();
3046     }
3047 }
3048
3049 void SAL_CALL LayoutManager::elementReplaced( const ui::ConfigurationEvent& Event ) throw (uno::RuntimeException, std::exception)
3050 {
3051     SolarMutexClearableGuard aReadLock;
3052     Reference< XFrame >                       xFrame( m_xFrame );
3053     Reference< ui::XUIConfigurationListener > xToolbarManager( m_xToolbarManager );
3054     ToolbarLayoutManager*                     pToolbarManager = m_pToolbarManager;
3055     aReadLock.clear();
3056
3057     if ( xFrame.is() )
3058     {
3059         OUString aElementType;
3060         OUString aElementName;
3061         bool            bRefreshLayout(false);
3062
3063         parseResourceURL( Event.ResourceURL, aElementType, aElementName );
3064         if ( aElementType.equalsIgnoreAsciiCase( UIRESOURCETYPE_TOOLBAR ))
3065         {
3066             if ( xToolbarManager.is() )
3067             {
3068                 xToolbarManager->elementReplaced( Event );
3069                 bRefreshLayout = pToolbarManager->isLayoutDirty();
3070             }
3071         }
3072         else
3073         {
3074             Reference< XUIElement >         xUIElement = implts_findElement( Event.ResourceURL );
3075             Reference< XUIElementSettings > xElementSettings( xUIElement, UNO_QUERY );
3076             if ( xElementSettings.is() )
3077             {
3078                 OUString           aConfigSourcePropName( "ConfigurationSource" );
3079                 Reference< XInterface >   xElementCfgMgr;
3080                 Reference< XPropertySet > xPropSet( xElementSettings, UNO_QUERY );
3081
3082                 if ( xPropSet.is() )
3083                     xPropSet->getPropertyValue( aConfigSourcePropName ) >>= xElementCfgMgr;
3084
3085                 if ( !xElementCfgMgr.is() )
3086                     return;
3087
3088                 // Check if the same UI configuration manager has changed => update settings
3089                 if ( Event.Source == xElementCfgMgr )
3090                     xElementSettings->updateSettings();
3091             }
3092         }
3093
3094         if ( bRefreshLayout )
3095             doLayout();
3096     }
3097 }
3098
3099 //      OPropertySetHelper
3100
3101 sal_Bool SAL_CALL LayoutManager::convertFastPropertyValue( Any&       aConvertedValue,
3102                                                            Any&       aOldValue,
3103                                                            sal_Int32  nHandle,
3104                                                            const Any& aValue ) throw( lang::IllegalArgumentException )
3105 {
3106     return LayoutManager_PBase::convertFastPropertyValue( aConvertedValue, aOldValue, nHandle, aValue );
3107 }
3108
3109 void SAL_CALL LayoutManager::setFastPropertyValue_NoBroadcast( sal_Int32       nHandle,
3110                                                                const uno::Any& aValue  ) throw( uno::Exception, std::exception )
3111 {
3112     if ( nHandle != LAYOUTMANAGER_PROPHANDLE_REFRESHVISIBILITY )
3113         LayoutManager_PBase::setFastPropertyValue_NoBroadcast( nHandle, aValue );
3114
3115     switch( nHandle )
3116     {
3117         case LAYOUTMANAGER_PROPHANDLE_MENUBARCLOSER:
3118             implts_updateMenuBarClose();
3119             break;
3120
3121         case LAYOUTMANAGER_PROPHANDLE_REFRESHVISIBILITY:
3122         {
3123             bool bValue(false);
3124             if (( aValue >>= bValue ) && bValue )
3125             {
3126                 SolarMutexClearableGuard aReadLock;
3127                 ToolbarLayoutManager* pToolbarManager = m_pToolbarManager;
3128                 bool bAutomaticToolbars( m_bAutomaticToolbars );
3129                 aReadLock.clear();
3130
3131                 if ( pToolbarManager )
3132                     pToolbarManager->refreshToolbarsVisibility( bAutomaticToolbars );
3133             }
3134             break;
3135         }
3136
3137         case LAYOUTMANAGER_PROPHANDLE_HIDECURRENTUI:
3138             implts_setCurrentUIVisibility( !m_bHideCurrentUI );
3139             break;
3140         default: break;
3141     }
3142 }
3143
3144 void SAL_CALL LayoutManager::getFastPropertyValue( uno::Any& aValue, sal_Int32 nHandle ) const
3145 {
3146     LayoutManager_PBase::getFastPropertyValue( aValue, nHandle );
3147 }
3148
3149 namespace detail
3150 {
3151     class InfoHelperBuilder : private ::boost::noncopyable
3152     {
3153     private:
3154         ::cppu::OPropertyArrayHelper *m_pInfoHelper;
3155     public:
3156         InfoHelperBuilder(const LayoutManager &rManager)
3157         {
3158             uno::Sequence< beans::Property > aProperties;
3159             rManager.describeProperties(aProperties);
3160             m_pInfoHelper = new ::cppu::OPropertyArrayHelper(aProperties, sal_True);
3161         }
3162         ~InfoHelperBuilder()
3163         {
3164             delete m_pInfoHelper;
3165         }
3166
3167         ::cppu::OPropertyArrayHelper& getHelper() { return *m_pInfoHelper; }
3168     };
3169 }
3170 namespace
3171 {
3172     struct theInfoHelper :
3173         public rtl::StaticWithArg< detail::InfoHelperBuilder, LayoutManager,
3174         theInfoHelper >
3175     {
3176     };
3177 }
3178
3179 ::cppu::IPropertyArrayHelper& SAL_CALL LayoutManager::getInfoHelper()
3180 {
3181     return theInfoHelper::get(*this).getHelper();
3182 }
3183
3184 uno::Reference< beans::XPropertySetInfo > SAL_CALL LayoutManager::getPropertySetInfo() throw (uno::RuntimeException, std::exception)
3185 {
3186     static uno::Reference< beans::XPropertySetInfo >* pInfo = NULL;
3187
3188     if( pInfo == NULL )
3189     {
3190         osl::MutexGuard aGuard( osl::Mutex::getGlobalMutex() );
3191
3192         if( pInfo == NULL )
3193         {
3194             static uno::Reference< beans::XPropertySetInfo > xInfo( createPropertySetInfo( getInfoHelper() ) );
3195             pInfo = &xInfo;
3196         }
3197     }
3198
3199     return (*pInfo);
3200 }
3201
3202 } // namespace framework
3203
3204 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface * SAL_CALL
3205 com_sun_star_comp_framework_LayoutManager_get_implementation(
3206     css::uno::XComponentContext *context,
3207     css::uno::Sequence<css::uno::Any> const &)
3208 {
3209     return cppu::acquire(new framework::LayoutManager(context));
3210 }
3211
3212 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */