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