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