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