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