?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
update dev300-m58
[ooovba.git] / framework / source / layoutmanager / layoutmanager.cxx
blob3ea3d2759d6f243e7117164f5c74eac5eda735f3
1 /*************************************************************************
2 *
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * Copyright 2008 by Sun Microsystems, Inc.
6 *
7 * OpenOffice.org - a multi-platform office productivity suite
8 *
9 * $RCSfile: layoutmanager.cxx,v $
10 * $Revision: 1.72 $
11 *
12 * This file is part of OpenOffice.org.
13 *
14 * OpenOffice.org is free software: you can redistribute it and/or modify
15 * it under the terms of the GNU Lesser General Public License version 3
16 * only, as published by the Free Software Foundation.
17 *
18 * OpenOffice.org is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 * GNU Lesser General Public License version 3 for more details
22 * (a copy is included in the LICENSE file that accompanied this code).
23 *
24 * You should have received a copy of the GNU Lesser General Public License
25 * version 3 along with OpenOffice.org. If not, see
26 * <http://www.openoffice.org/license.html>
27 * for a copy of the LGPLv3 License.
28 *
29 ************************************************************************/
30
31 // MARKER(update_precomp.py): autogen include statement, do not remove
32 #include "precompiled_framework.hxx"
33
34 //_________________________________________________________________________________________________________________
35 // my own includes
36 //_________________________________________________________________________________________________________________
37
38 // #include <math.h>
39
40 #ifndef _FRAMEWORK_SERVICES_LAYOUTMANAGER_HXX_
41 #include <services/layoutmanager.hxx>
42 #endif
43 #include <threadhelp/resetableguard.hxx>
44 #include <services.h>
45
46 #include <classes/sfxhelperfunctions.hxx>
47 #include <uielement/menubarwrapper.hxx>
48 #include <classes/addonsoptions.hxx>
49 #include <uiconfiguration/windowstateconfiguration.hxx>
50 #include <classes/fwkresid.hxx>
51
52 #ifndef __FRAMEWORK_CLASSES_RESOURCE_HRC_
53 #include <classes/resource.hrc>
54 #endif
55 #include <toolkit/helper/convert.hxx>
56 #include <uielement/progressbarwrapper.hxx>
57 #include <uiconfiguration/globalsettings.hxx>
58
59 //_________________________________________________________________________________________________________________
60 // interface includes
61 //_________________________________________________________________________________________________________________
62 #include <com/sun/star/beans/XPropertySet.hpp>
63 #include <com/sun/star/beans/PropertyAttribute.hpp>
64 #include <com/sun/star/frame/XModel.hpp>
65 #include <com/sun/star/frame/FrameAction.hpp>
66 #include <com/sun/star/frame/XUIControllerRegistration.hpp>
67 #include <com/sun/star/lang/XMultiComponentFactory.hpp>
68 #include <com/sun/star/awt/XTopWindow.hpp>
69 #include <com/sun/star/awt/XSystemDependentMenuPeer.hpp>
70 #ifndef _COM_SUN_STAR_LANG_XYSTEMDEPENDENT_HPP_
71 #include <com/sun/star/lang/SystemDependent.hpp>
72 #endif
73 #include <com/sun/star/awt/VclWindowPeerAttribute.hpp>
74 #include <com/sun/star/awt/PosSize.hpp>
75 #include <com/sun/star/awt/XDevice.hpp>
76 #include <com/sun/star/awt/XSystemDependentWindowPeer.hpp>
77 #include <com/sun/star/awt/XTopWindow.hpp>
78 #ifndef _COM_SUN_STAR_UI_XMODULEUICONFIGURATIONMANAGER_HPP_
79 #include <com/sun/star/ui/XModuleUIConfigurationManagerSupplier.hpp>
80 #endif
81 #include <com/sun/star/ui/XUIConfigurationManagerSupplier.hpp>
82 #include <com/sun/star/ui/UIElementType.hpp>
83 #include <com/sun/star/container/XNameReplace.hpp>
84 #include <com/sun/star/container/XNameContainer.hpp>
85 #include <com/sun/star/ui/XUIFunctionListener.hpp>
86 #include <com/sun/star/frame/LayoutManagerEvents.hpp>
87 #include <com/sun/star/frame/XDispatchProvider.hpp>
88 #include <com/sun/star/frame/XDispatchHelper.hpp>
89 #include <com/sun/star/lang/DisposedException.hpp>
90
91 //_________________________________________________________________________________________________________________
92 // other includes
93 //_________________________________________________________________________________________________________________
94 #include <svtools/imgdef.hxx>
95 #include <vcl/window.hxx>
96 #include <vcl/wrkwin.hxx>
97 #include <vcl/dockingarea.hxx>
98 #include <vcl/svapp.hxx>
99 #include <vcl/i18nhelp.hxx>
100 #include <vcl/wall.hxx>
101 #ifndef _TOOLKIT_HELPER_VCLUNOHELPER_HXX_
102 #include <toolkit/unohlp.hxx>
103 #endif
104 #include <toolkit/awt/vclxwindow.hxx>
105 #include <toolkit/awt/vclxmenu.hxx>
106 #include <comphelper/mediadescriptor.hxx>
107 #include <rtl/logfile.hxx>
108 #include <svtools/cmdoptions.hxx>
109
110 #include <algorithm>
111 #include <boost/bind.hpp>
112 // ______________________________________________
113 // using namespace
114
115 using namespace ::com::sun::star;
116 using namespace com::sun::star::uno;
117 using namespace com::sun::star::beans;
118 using namespace com::sun::star::util;
119 using namespace com::sun::star::lang;
120 using namespace com::sun::star::container;
121 using namespace ::com::sun::star::ui;
122 using namespace com::sun::star::frame;
123 using namespace ::com::sun::star::frame;
124
125 #define UIRESOURCE_PROTOCO_ASCII "private:"
126 #define UIRESOURCE_RESOURCE_ASCII "resource"
127 #define UIRESOURCE_URL_ASCII "private:resource"
128 #define UIRESOURCE_URL rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( UIRESOURCE_URL_ASCII ))
129
130 // ATTENTION!
131 // This value is directly copied from the sfx2 project.
132 // You have to change BOTH values, see sfx2/inc/sfx2/sfxsids.hrc (SID_DOCKWIN_START)
133 static const sal_Int32 DOCKWIN_ID_BASE = 9800;
134
135 bool lcl_checkUIElement(const Reference< XUIElement >& xUIElement,css::awt::Rectangle& _rPosSize,Reference< css::awt::XWindow >& _xWindow)
136 {
137 bool bRet = xUIElement.is();
138 if ( bRet )
139 {
140 vos::OGuard aGuard( Application::GetSolarMutex() );
141 _xWindow.set( xUIElement->getRealInterface(), UNO_QUERY );
142 _rPosSize = _xWindow->getPosSize();
143
144 Window* pWindow = VCLUnoHelper::GetWindow( _xWindow );
145 if ( pWindow->GetType() == WINDOW_TOOLBOX )
146 {
147 ::Size aSize = ((ToolBox*)pWindow)->CalcWindowSizePixel( 1 );
148 _rPosSize.Width = aSize.Width();
149 _rPosSize.Height = aSize.Height();
150 }
151 } // if ( xUIElement.is() )
152 return bRet;
153 }
154
155 // convert alignment constant to vcl's WindowAlign type
156 static WindowAlign ImplConvertAlignment( sal_Int16 aAlignment )
157 {
158 if ( aAlignment == DockingArea_DOCKINGAREA_LEFT )
159 return WINDOWALIGN_LEFT;
160 else if ( aAlignment == DockingArea_DOCKINGAREA_RIGHT )
161 return WINDOWALIGN_RIGHT;
162 else if ( aAlignment == DockingArea_DOCKINGAREA_TOP )
163 return WINDOWALIGN_TOP;
164 else
165 return WINDOWALIGN_BOTTOM;
166 }
167
168 //_________________________________________________________________________________________________________________
169 // Namespace
170 //_________________________________________________________________________________________________________________
171 //
172
173 namespace framework
174 {
175
176 struct UIElementVisibility
177 {
178 rtl::OUString aName;
179 bool bVisible;
180 };
181
182 bool LayoutManager::UIElement::operator< ( const LayoutManager::UIElement& aUIElement ) const
183 {
184 if ( !m_xUIElement.is() && aUIElement.m_xUIElement.is() )
185 return false;
186 else if ( m_xUIElement.is() && !aUIElement.m_xUIElement.is() )
187 return true;
188 else if ( !m_bVisible && aUIElement.m_bVisible )
189 return false;
190 else if ( m_bVisible && !aUIElement.m_bVisible )
191 return true;
192 else if ( !m_bFloating && aUIElement.m_bFloating )
193 return true;
194 else if ( m_bFloating && !aUIElement.m_bFloating )
195 return false;
196 else
197 {
198 if ( m_bFloating )
199 {
200 bool bEqual = ( m_aFloatingData.m_aPos.Y() == aUIElement.m_aFloatingData.m_aPos.Y() );
201 if ( bEqual )
202 return ( m_aFloatingData.m_aPos.X() < aUIElement.m_aFloatingData.m_aPos.X() );
203 else
204 return ( m_aFloatingData.m_aPos.Y() < aUIElement.m_aFloatingData.m_aPos.Y() );
205 }
206 else
207 {
208 if ( m_aDockedData.m_nDockedArea < aUIElement.m_aDockedData.m_nDockedArea )
209 return true;
210 else if ( m_aDockedData.m_nDockedArea > aUIElement.m_aDockedData.m_nDockedArea )
211 return false;
212 else
213 {
214 if ( m_aDockedData.m_nDockedArea == DockingArea_DOCKINGAREA_TOP ||
215 m_aDockedData.m_nDockedArea == DockingArea_DOCKINGAREA_BOTTOM )
216 {
217 if ( !( m_aDockedData.m_aPos.Y() == aUIElement.m_aDockedData.m_aPos.Y() ) )
218 return ( m_aDockedData.m_aPos.Y() < aUIElement.m_aDockedData.m_aPos.Y() );
219 else
220 {
221 bool bEqual = ( m_aDockedData.m_aPos.X() == aUIElement.m_aDockedData.m_aPos.X() );
222 if ( bEqual )
223 {
224 return m_bUserActive && !aUIElement.m_bUserActive;
225 }
226 else
227 return ( m_aDockedData.m_aPos.X() < aUIElement.m_aDockedData.m_aPos.X() );
228 }
229 }
230 else
231 {
232 if ( !( m_aDockedData.m_aPos.X() == aUIElement.m_aDockedData.m_aPos.X() ) )
233 return ( m_aDockedData.m_aPos.X() < aUIElement.m_aDockedData.m_aPos.X() );
234 else
235 {
236 bool bEqual = ( m_aDockedData.m_aPos.Y() == aUIElement.m_aDockedData.m_aPos.Y() );
237 if ( bEqual )
238 {
239 return m_bUserActive && !aUIElement.m_bUserActive;
240 }
241 else
242 return ( m_aDockedData.m_aPos.Y() < aUIElement.m_aDockedData.m_aPos.Y() );
243 }
244 }
245 }
246 }
247 }
248 }
249
250 LayoutManager::UIElement& LayoutManager::UIElement::operator= ( const LayoutManager::UIElement& rUIElement )
251 {
252 m_aType = rUIElement.m_aType;
253 m_aName = rUIElement.m_aName;
254 m_aUIName = rUIElement.m_aUIName;
255 m_xUIElement = rUIElement.m_xUIElement;
256 m_bFloating = rUIElement.m_bFloating;
257 m_bVisible = rUIElement.m_bVisible;
258 m_bUserActive = rUIElement.m_bUserActive;
259 m_bCreateNewRowCol0 = rUIElement.m_bCreateNewRowCol0;
260 m_bDeactiveHide = rUIElement.m_bDeactiveHide;
261 m_bMasterHide = rUIElement.m_bMasterHide;
262 m_bContextSensitive = rUIElement.m_bContextSensitive;
263 m_bContextActive = rUIElement.m_bContextActive;
264 m_bNoClose = rUIElement.m_bNoClose;
265 m_bSoftClose = rUIElement.m_bSoftClose;
266 m_bStateRead = rUIElement.m_bStateRead;
267 m_nStyle = rUIElement.m_nStyle;
268 m_aDockedData = rUIElement.m_aDockedData;
269 m_aFloatingData = rUIElement.m_aFloatingData;
270 return *this;
271 }
272
273 static Reference< XModel > impl_getModelFromFrame( const Reference< XFrame >& rFrame )
274 {
275 // Query for the model to get check the context information
276 Reference< XModel > xModel;
277 if ( rFrame.is() )
278 {
279 Reference< XController > xController( rFrame->getController(), UNO_QUERY );
280 if ( xController.is() )
281 xModel = xController->getModel();
282 }
283
284 return xModel;
285 }
286
287 static sal_Bool implts_isPreviewModel( const Reference< XModel >& xModel )
288 {
289 if ( xModel.is() )
290 {
291 ::comphelper::MediaDescriptor aDesc( xModel->getArgs() );
292 return aDesc.getUnpackedValueOrDefault(::comphelper::MediaDescriptor::PROP_PREVIEW(), (sal_Bool)sal_False);
293 }
294 else
295 return sal_False;
296 }
297
298 static sal_Bool implts_isFrameOrWindowTop( const css::uno::Reference< css::frame::XFrame >& xFrame )
299 {
300 if (xFrame->isTop())
301 return sal_True;
302
303 css::uno::Reference< css::awt::XTopWindow > xWindowCheck(xFrame->getContainerWindow(), css::uno::UNO_QUERY); // dont use _THROW here ... its a check only
304 if (xWindowCheck.is())
305 {
306 // --> PB 2007-06-18 #i76867# top and system window is required.
307 ::vos::OGuard aSolarLock(&Application::GetSolarMutex());
308 css::uno::Reference< css::awt::XWindow > xWindow( xWindowCheck, UNO_QUERY );
309 Window* pWindow = VCLUnoHelper::GetWindow( xWindow );
310 return ( pWindow && pWindow->IsSystemWindow() );
311 // <--
312 }
313
314 return sal_False;
315 }
316
317 static void impl_setDockingWindowVisibility( const css::uno::Reference< css::lang::XMultiServiceFactory>& rSMGR, const css::uno::Reference< css::frame::XFrame >& rFrame, const ::rtl::OUString& rDockingWindowName, bool bVisible )
318 {
319 const ::rtl::OUString aDockWinPrefixCommand( RTL_CONSTASCII_USTRINGPARAM( "DockingWindow" ));
320 css::uno::WeakReference< css::frame::XDispatchHelper > xDispatchHelper;
321
322 sal_Int32 nID = rDockingWindowName.toInt32();
323 sal_Int32 nIndex = nID - DOCKWIN_ID_BASE;
324
325 css::uno::Reference< css::frame::XDispatchProvider > xProvider(rFrame, css::uno::UNO_QUERY);
326 if ( nIndex >= 0 && xProvider.is() )
327 {
328 ::rtl::OUString aDockWinCommand( RTL_CONSTASCII_USTRINGPARAM( ".uno:" ));
329 ::rtl::OUString aDockWinArgName( aDockWinPrefixCommand );
330
331 aDockWinArgName += ::rtl::OUString::valueOf( nIndex );
332
333 css::uno::Sequence< css::beans::PropertyValue > aArgs(1);
334 aArgs[0].Name = aDockWinArgName;
335 aArgs[0].Value = css::uno::makeAny( bVisible );
336
337 css::uno::Reference< css::frame::XDispatchHelper > xDispatcher( xDispatchHelper );
338 if ( !xDispatcher.is())
339 {
340 xDispatcher = css::uno::Reference< css::frame::XDispatchHelper >(
341 rSMGR->createInstance(SERVICENAME_DISPATCHHELPER), css::uno::UNO_QUERY_THROW);
342 }
343
344 aDockWinCommand = aDockWinCommand + aDockWinArgName;
345 xDispatcher->executeDispatch(
346 xProvider,
347 aDockWinCommand,
348 ::rtl::OUString::createFromAscii("_self"),
349 0,
350 aArgs);
351 }
352 }
353
354 //*****************************************************************************************************************
355 // XInterface, XTypeProvider, XServiceInfo
356 //*****************************************************************************************************************
357 DEFINE_XINTERFACE_14 ( LayoutManager ,
358 OWeakObject ,
359 DIRECT_INTERFACE( css::lang::XTypeProvider ),
360 DIRECT_INTERFACE( css::lang::XServiceInfo ),
361 DIRECT_INTERFACE( ::com::sun::star::frame::XLayoutManager ),
362 DIRECT_INTERFACE( css::awt::XWindowListener ),
363 DIRECT_INTERFACE( css::frame::XFrameActionListener ),
364 DIRECT_INTERFACE( ::com::sun::star::ui::XUIConfigurationListener ),
365 DIRECT_INTERFACE( ::com::sun::star::frame::XInplaceLayout ),
366 DIRECT_INTERFACE( css::awt::XDockableWindowListener ),
367 DIRECT_INTERFACE( ::com::sun::star::frame::XMenuBarMergingAcceptor ),
368 DIRECT_INTERFACE( css::frame::XLayoutManagerEventBroadcaster ),
369 DERIVED_INTERFACE( css::lang::XEventListener, css::frame::XFrameActionListener ),
370 DIRECT_INTERFACE( ::com::sun::star::beans::XMultiPropertySet ),
371 DIRECT_INTERFACE( ::com::sun::star::beans::XFastPropertySet ),
372 DIRECT_INTERFACE( ::com::sun::star::beans::XPropertySet )
373 )
374
375 DEFINE_XTYPEPROVIDER_14 ( LayoutManager ,
376 css::lang::XTypeProvider ,
377 css::lang::XServiceInfo ,
378 ::com::sun::star::frame::XLayoutManager ,
379 css::awt::XWindowListener ,
380 css::frame::XFrameActionListener ,
381 css::lang::XEventListener ,
382 ::com::sun::star::ui::XUIConfigurationListener ,
383 ::com::sun::star::frame::XInplaceLayout ,
384 css::awt::XDockableWindowListener ,
385 ::com::sun::star::frame::XMenuBarMergingAcceptor ,
386 css::frame::XLayoutManagerEventBroadcaster ,
387 ::com::sun::star::beans::XMultiPropertySet ,
388 ::com::sun::star::beans::XFastPropertySet ,
389 ::com::sun::star::beans::XPropertySet
390 )
391
392 DEFINE_XSERVICEINFO_MULTISERVICE ( LayoutManager ,
393 ::cppu::OWeakObject ,
394 SERVICENAME_LAYOUTMANAGER ,
395 IMPLEMENTATIONNAME_LAYOUTMANAGER
396 )
397
398 DEFINE_INIT_SERVICE ( LayoutManager, {} )
399
400
401 LayoutManager::LayoutManager( const Reference< XMultiServiceFactory >& xServiceManager ) :
402 ThreadHelpBase( &Application::GetSolarMutex() )
403 , ::cppu::OBroadcastHelperVar< ::cppu::OMultiTypeInterfaceContainerHelper, ::cppu::OMultiTypeInterfaceContainerHelper::keyType >( m_aLock.getShareableOslMutex() )
404 , ::cppu::OPropertySetHelper ( *(static_cast< ::cppu::OBroadcastHelper* >(this)) )
405 , ::cppu::OWeakObject ( )
406 , m_xSMGR( xServiceManager )
407 , m_xURLTransformer( Reference< XURLTransformer >( xServiceManager->createInstance(
408 SERVICENAME_URLTRANSFORMER),
409 UNO_QUERY ))
410 , m_nLockCount( 0 )
411 , m_bActive( sal_False )
412 , m_bInplaceMenuSet( sal_False )
413 , m_bDockingInProgress( sal_False )
414 , m_bMenuVisible( sal_True )
415 , m_bComponentAttached( sal_False )
416 , m_bDoLayout( sal_False )
417 , m_bVisible( sal_True )
418 , m_bParentWindowVisible( sal_False )
419 , m_bMustDoLayout( sal_True )
420 , m_bAutomaticToolbars( sal_True )
421 , m_bStoreWindowState( sal_False )
422 , m_bHideCurrentUI( false )
423 , m_bGlobalSettings( sal_False )
424 , m_eDockOperation( DOCKOP_ON_COLROW )
425 , m_pInplaceMenuBar( NULL )
426 , m_xModuleManager( Reference< XModuleManager >(
427 xServiceManager->createInstance( SERVICENAME_MODULEMANAGER ), UNO_QUERY ))
428 , m_xUIElementFactoryManager( Reference< ::com::sun::star::ui::XUIElementFactory >(
429 xServiceManager->createInstance( SERVICENAME_UIELEMENTFACTORYMANAGER ), UNO_QUERY ))
430 , m_bMenuBarCloser( sal_False )
431 , m_xPersistentWindowStateSupplier( Reference< XNameAccess >(
432 xServiceManager->createInstance( SERVICENAME_WINDOWSTATECONFIGURATION ), UNO_QUERY ))
433 , m_pGlobalSettings( 0 )
434 , m_aCustomTbxPrefix( RTL_CONSTASCII_USTRINGPARAM( "custom_" ))
435 , m_aFullCustomTbxPrefix( RTL_CONSTASCII_USTRINGPARAM( "private:resource/toolbar/custom_" ))
436 , m_aFullAddonTbxPrefix( RTL_CONSTASCII_USTRINGPARAM( "private:resource/toolbar/addon_" ))
437 , m_aStatusBarAlias( RTL_CONSTASCII_USTRINGPARAM( "private:resource/statusbar/statusbar" ))
438 , m_aProgressBarAlias( RTL_CONSTASCII_USTRINGPARAM( "private:resource/progressbar/progressbar" ))
439 , m_aPropDocked( RTL_CONSTASCII_USTRINGPARAM( WINDOWSTATE_PROPERTY_DOCKED ))
440 , m_aPropVisible( RTL_CONSTASCII_USTRINGPARAM( WINDOWSTATE_PROPERTY_VISIBLE ))
441 , m_aPropDockingArea( RTL_CONSTASCII_USTRINGPARAM( WINDOWSTATE_PROPERTY_DOCKINGAREA ))
442 , m_aPropDockPos( RTL_CONSTASCII_USTRINGPARAM( WINDOWSTATE_PROPERTY_DOCKPOS ))
443 , m_aPropPos( RTL_CONSTASCII_USTRINGPARAM( WINDOWSTATE_PROPERTY_POS ))
444 , m_aPropSize( RTL_CONSTASCII_USTRINGPARAM( WINDOWSTATE_PROPERTY_SIZE ))
445 , m_aPropUIName( RTL_CONSTASCII_USTRINGPARAM( WINDOWSTATE_PROPERTY_UINAME ))
446 , m_aPropStyle( RTL_CONSTASCII_USTRINGPARAM( WINDOWSTATE_PROPERTY_STYLE ))
447 , m_aPropLocked( RTL_CONSTASCII_USTRINGPARAM( WINDOWSTATE_PROPERTY_LOCKED ))
448 , m_aCustomizeCmd( RTL_CONSTASCII_USTRINGPARAM( "ConfigureDialog" ))
449 , m_pAddonOptions( 0 )
450 , m_aListenerContainer( m_aLock.getShareableOslMutex() )
451 {
452 // Initialize statusbar member
453 m_aStatusBarElement.m_aType = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "statusbar" ));
454 m_aStatusBarElement.m_aName = m_aStatusBarAlias;
455
456 m_pMiscOptions = new SvtMiscOptions();
457
458 m_pMiscOptions->AddListener( LINK( this, LayoutManager, OptionsChanged ) );
459 Application::AddEventListener( LINK( this, LayoutManager, SettingsChanged ) );
460 m_eSymbolsSize = m_pMiscOptions->GetSymbolsSize();
461 m_eSymbolsStyle = m_pMiscOptions->GetCurrentSymbolsStyle();
462
463 m_aAsyncLayoutTimer.SetTimeout( 50 );
464 m_aAsyncLayoutTimer.SetTimeoutHdl( LINK( this, LayoutManager, AsyncLayoutHdl ) );
465 }
466
467 LayoutManager::~LayoutManager()
468 {
469 Application::RemoveEventListener( LINK( this, LayoutManager, SettingsChanged ) );
470 if ( m_pMiscOptions )
471 {
472 m_pMiscOptions->RemoveListener( LINK( this, LayoutManager, OptionsChanged ) );
473 delete m_pMiscOptions;
474 m_pMiscOptions = 0;
475 }
476 m_aAsyncLayoutTimer.Stop();
477 }
478
479 // Internal helper function
480 void LayoutManager::impl_clearUpMenuBar()
481 {
482 implts_lock();
483
484 // Clear up VCL menu bar to prepare shutdown
485 if ( m_xContainerWindow.is() )
486 {
487 vos::OGuard aGuard( Application::GetSolarMutex() );
488
489 Window* pWindow = VCLUnoHelper::GetWindow( m_xContainerWindow );
490 while ( pWindow && !pWindow->IsSystemWindow() )
491 pWindow = pWindow->GetParent();
492
493 if ( pWindow )
494 {
495 MenuBar* pSetMenuBar = 0;
496 if ( m_xInplaceMenuBar.is() )
497 pSetMenuBar = (MenuBar *)m_pInplaceMenuBar->GetMenuBar();
498 else
499 {
500 Reference< css::awt::XMenuBar > xMenuBar;
501
502 Reference< XPropertySet > xPropSet( m_xMenuBar, UNO_QUERY );
503 if ( xPropSet.is() )
504 {
505 try
506 {
507 xPropSet->getPropertyValue( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "XMenuBar" ))) >>= xMenuBar;
508 }
509 catch ( com::sun::star::beans::UnknownPropertyException )
510 {
511 }
512 catch ( com::sun::star::lang::WrappedTargetException )
513 {
514 }
515 }
516
517 VCLXMenu* pAwtMenuBar = VCLXMenu::GetImplementation( xMenuBar );
518 if ( pAwtMenuBar )
519 pSetMenuBar = (MenuBar*)pAwtMenuBar->GetMenu();
520 }
521
522 MenuBar* pTopMenuBar = ((SystemWindow *)pWindow)->GetMenuBar();
523 if ( pSetMenuBar == pTopMenuBar )
524 ((SystemWindow *)pWindow)->SetMenuBar( 0 );
525 }
526 }
527
528 // reset inplace menubar manager
529 m_pInplaceMenuBar = 0;
530 if ( m_xInplaceMenuBar.is() )
531 {
532 m_xInplaceMenuBar->dispose();
533 m_xInplaceMenuBar.clear();
534 }
535
536 Reference< XComponent > xComp( m_xMenuBar, UNO_QUERY );
537 if ( xComp.is() )
538 xComp->dispose();
539 m_xMenuBar.clear();
540 implts_unlock();
541 }
542
543 sal_Bool LayoutManager::impl_parseResourceURL( const rtl::OUString aResourceURL, rtl::OUString& aElementType, rtl::OUString& aElementName )
544 {
545 URL aURL;
546 sal_Int32 nIndex = 0;
547
548 aURL.Complete = aResourceURL;
549 m_xURLTransformer->parseStrict( aURL );
550
551 ::rtl::OUString aUIResource = aURL.Path.getToken( 0, (sal_Unicode)'/', nIndex );
552
553 if (( aURL.Protocol.equalsIgnoreAsciiCaseAscii( UIRESOURCE_PROTOCO_ASCII )) &&
554 ( aUIResource.equalsIgnoreAsciiCaseAscii( UIRESOURCE_RESOURCE_ASCII )))
555 {
556 aElementType = aURL.Path.getToken( 0, (sal_Unicode)'/', nIndex );
557 aElementName = aURL.Path.getToken( 0, (sal_Unicode)'/', nIndex );
558 return sal_True;
559 }
560
561 return sal_False;
562 }
563
564 void LayoutManager::implts_lock()
565 {
566 /* SAFE AREA ----------------------------------------------------------------------------------------------- */
567 WriteGuard aWriteLock( m_aLock );
568 ++m_nLockCount;
569 aWriteLock.unlock();
570 /* SAFE AREA ----------------------------------------------------------------------------------------------- */
571 }
572
573 sal_Bool LayoutManager::implts_unlock()
574 {
575 /* SAFE AREA ----------------------------------------------------------------------------------------------- */
576 WriteGuard aWriteLock( m_aLock );
577 --m_nLockCount;
578 if ( m_nLockCount < 0 )
579 m_nLockCount = 0;
580 return ( m_nLockCount == 0 );
581 /* SAFE AREA ----------------------------------------------------------------------------------------------- */
582 }
583
584 void LayoutManager::implts_reset( sal_Bool bAttached )
585 {
586 /* SAFE AREA ----------------------------------------------------------------------------------------------- */
587 ReadGuard aReadLock( m_aLock );
588 Reference< XFrame > xFrame = m_xFrame;
589 Reference< css::awt::XWindow > xContainerWindow( m_xContainerWindow );
590 Reference< css::awt::XWindow > xTopDockingWindow = m_xDockAreaWindows[DockingArea_DOCKINGAREA_TOP];
591 Reference< css::awt::XWindow > xLeftDockingWindow = m_xDockAreaWindows[DockingArea_DOCKINGAREA_LEFT];
592 Reference< css::awt::XWindow > xRightDockingWindow = m_xDockAreaWindows[DockingArea_DOCKINGAREA_RIGHT];
593 Reference< css::awt::XWindow > xBottomDockingWindow = m_xDockAreaWindows[DockingArea_DOCKINGAREA_BOTTOM];
594 Reference< XUIConfiguration > xModuleCfgMgr( m_xModuleCfgMgr, UNO_QUERY );
595 Reference< XUIConfiguration > xDocCfgMgr( m_xDocCfgMgr, UNO_QUERY );
596 Reference< XNameAccess > xPersistentWindowState( m_xPersistentWindowState );
597 Reference< XMultiServiceFactory > xServiceManager( m_xSMGR );
598 Reference< XNameAccess > xPersistentWindowStateSupplier( m_xPersistentWindowStateSupplier );
599 ::rtl::OUString aModuleIdentifier( m_aModuleIdentifier );
600 sal_Bool bAutomaticToolbars( m_bAutomaticToolbars );
601 aReadLock.unlock();
602 /* SAFE AREA ----------------------------------------------------------------------------------------------- */
603
604 implts_lock();
605
606 Reference< XModel > xModel;
607 if ( xFrame.is() )
608 {
609 if ( bAttached )
610 {
611 ::rtl::OUString aOldModuleIdentifier( aModuleIdentifier );
612 try
613 {
614 aModuleIdentifier = m_xModuleManager->identify( Reference< XInterface >( xFrame, UNO_QUERY ) );
615 }
616 catch( Exception& )
617 {
618 }
619
620 if ( aModuleIdentifier.getLength() && aOldModuleIdentifier != aModuleIdentifier )
621 {
622 Reference< XModuleUIConfigurationManagerSupplier > xModuleCfgSupplier;
623 if ( xServiceManager.is() )
624 xModuleCfgSupplier = Reference< XModuleUIConfigurationManagerSupplier >(
625 xServiceManager->createInstance( SERVICENAME_MODULEUICONFIGURATIONMANAGERSUPPLIER ), UNO_QUERY );
626
627 if ( xModuleCfgMgr.is() )
628 {
629 try
630 {
631 // Remove listener to old module ui configuration manager
632 xModuleCfgMgr->removeConfigurationListener( Reference< XUIConfigurationListener >( static_cast< OWeakObject* >( this ), UNO_QUERY ));
633 }
634 catch ( Exception& )
635 {
636 }
637 }
638
639 try
640 {
641 // Add listener to new module ui configuration manager
642 xModuleCfgMgr = Reference< XUIConfiguration >( xModuleCfgSupplier->getUIConfigurationManager( aModuleIdentifier ), UNO_QUERY );
643 if ( xModuleCfgMgr.is() )
644 xModuleCfgMgr->addConfigurationListener( Reference< XUIConfigurationListener >( static_cast< OWeakObject* >( this ), UNO_QUERY ));
645 }
646 catch ( Exception& )
647 {
648 }
649
650 try
651 {
652 // Retrieve persistent window state reference for our new module
653 if ( xPersistentWindowStateSupplier.is() )
654 xPersistentWindowStateSupplier->getByName( aModuleIdentifier ) >>= xPersistentWindowState;
655 }
656 catch ( NoSuchElementException& )
657 {
658 }
659 catch ( WrappedTargetException& )
660 {
661 }
662 }
663
664 xModel = impl_getModelFromFrame( xFrame );
665 if ( xModel.is() )
666 {
667 Reference< XUIConfigurationManagerSupplier > xUIConfigurationManagerSupplier( xModel, UNO_QUERY );
668 if ( xUIConfigurationManagerSupplier.is() )
669 {
670 if ( xDocCfgMgr.is() )
671 {
672 try
673 {
674 // Remove listener to old ui configuration manager
675 xDocCfgMgr->removeConfigurationListener( Reference< XUIConfigurationListener >( static_cast< OWeakObject* >( this ), UNO_QUERY ));
676 }
677 catch ( Exception& )
678 {
679 }
680 }
681
682 try
683 {
684 xDocCfgMgr = Reference< XUIConfiguration >( xUIConfigurationManagerSupplier->getUIConfigurationManager(), UNO_QUERY );
685 if ( xDocCfgMgr.is() )
686 xDocCfgMgr->addConfigurationListener( Reference< XUIConfigurationListener >( static_cast< OWeakObject* >( this ), UNO_QUERY ));
687 }
688 catch ( Exception& )
689 {
690 }
691 }
692 }
693 }
694 else
695 {
696 // Remove configuration listeners before we can release our references
697 if ( xModuleCfgMgr.is() )
698 {
699 try
700 {
701 xModuleCfgMgr->removeConfigurationListener(
702 Reference< XUIConfigurationListener >( static_cast< OWeakObject* >( this ), UNO_QUERY ));
703 }
704 catch ( Exception& )
705 {
706 }
707 }
708
709 if ( xDocCfgMgr.is() )
710 {
711 try
712 {
713 xDocCfgMgr->removeConfigurationListener(
714 Reference< XUIConfigurationListener >( static_cast< OWeakObject* >( this ), UNO_QUERY ));
715 }
716 catch ( Exception& )
717 {
718 }
719 }
720
721 // Release references to our configuration managers as we currently don't have
722 // an attached module.
723 xModuleCfgMgr.clear();
724 xDocCfgMgr.clear();
725 xPersistentWindowState.clear();
726 aModuleIdentifier = ::rtl::OUString();
727 }
728
729 /* SAFE AREA ----------------------------------------------------------------------------------------------- */
730 WriteGuard aWriteLock( m_aLock );
731 m_xModel = xModel;
732 m_aDockingArea = css::awt::Rectangle();
733 m_bComponentAttached = bAttached;
734 m_aModuleIdentifier = aModuleIdentifier;
735 m_xModuleCfgMgr = Reference< XUIConfigurationManager >( xModuleCfgMgr, UNO_QUERY );
736 m_xDocCfgMgr = Reference< XUIConfigurationManager >( xDocCfgMgr, UNO_QUERY );
737 m_xPersistentWindowState = xPersistentWindowState;
738 m_aStatusBarElement.m_bStateRead = sal_False; // reset state to read data again!
739 aWriteLock.unlock();
740 /* SAFE AREA ----------------------------------------------------------------------------------------------- */
741
742 if ( bAttached )
743 {
744 // reset docking area windows back to zero size
745 try
746 {
747 if ( xTopDockingWindow.is() )
748 xTopDockingWindow->setPosSize( 0, 0, 0, 0, css::awt::PosSize::POSSIZE );
749 if ( xLeftDockingWindow.is() )
750 xLeftDockingWindow->setPosSize( 0, 0, 0, 0, css::awt::PosSize::POSSIZE );
751 if ( xRightDockingWindow.is() )
752 xRightDockingWindow->setPosSize( 0, 0, 0, 0, css::awt::PosSize::POSSIZE );
753 if ( xBottomDockingWindow.is() )
754 xBottomDockingWindow->setPosSize( 0, 0, 0, 0, css::awt::PosSize::POSSIZE );
755 }
756 catch ( Exception& )
757 {
758 }
759
760 if ( bAutomaticToolbars )
761 {
762 implts_createCustomToolBars();
763 implts_createAddonsToolBars();
764 implts_createNonContextSensitiveToolBars();
765 }
766 implts_sortUIElements();
767 }
768 else
769 implts_destroyElements();
770 }
771
772 implts_unlock();
773 }
774
775 sal_Bool LayoutManager::implts_isEmbeddedLayoutManager() const
776 {
777 // check if this layout manager is currently using the embedded feature
778 /* SAFE AREA ----------------------------------------------------------------------------------------------- */
779 ReadGuard aReadLock( m_aLock );
780 Reference< XFrame > xFrame = m_xFrame;
781 Reference< css::awt::XWindow > xContainerWindow( m_xContainerWindow );
782 aReadLock.unlock();
783 /* SAFE AREA ----------------------------------------------------------------------------------------------- */
784
785 Reference< css::awt::XWindow > xFrameContainerWindow = xFrame->getContainerWindow();
786 if ( xFrameContainerWindow == xContainerWindow )
787 return sal_False;
788 else
789 return sal_True;
790 }
791
792 void LayoutManager::implts_destroyElements()
793 {
794 UIElementVector aUIElementVector;
795
796 WriteGuard aWriteLock( m_aLock );
797 aUIElementVector = m_aUIElements;
798 m_aUIElements.clear();
799 aWriteLock.unlock();
800
801 UIElementVector::iterator pIter;
802 for ( pIter = aUIElementVector.begin(); pIter != aUIElementVector.end(); pIter++ )
803 {
804 Reference< XComponent > xComponent( pIter->m_xUIElement, UNO_QUERY );
805 if ( xComponent.is() )
806 xComponent->dispose();
807 }
808
809 implts_destroyStatusBar();
810
811 aWriteLock.lock();
812 impl_clearUpMenuBar();
813 aWriteLock.unlock();
814 }
815
816 void LayoutManager::implts_destroyDockingAreaWindows()
817 {
818 std::vector< Reference< css::awt::XWindow > > oldDockingAreaWindows;
819
820 /* SAFE AREA ----------------------------------------------------------------------------------------------- */
821 WriteGuard aWriteLock( m_aLock );
822 oldDockingAreaWindows.push_back( m_xDockAreaWindows[DockingArea_DOCKINGAREA_TOP] );
823 oldDockingAreaWindows.push_back( m_xDockAreaWindows[DockingArea_DOCKINGAREA_BOTTOM] );
824 oldDockingAreaWindows.push_back( m_xDockAreaWindows[DockingArea_DOCKINGAREA_LEFT] );
825 oldDockingAreaWindows.push_back( m_xDockAreaWindows[DockingArea_DOCKINGAREA_RIGHT] );
826
827 m_xDockAreaWindows[DockingArea_DOCKINGAREA_TOP].clear();
828 m_xDockAreaWindows[DockingArea_DOCKINGAREA_BOTTOM].clear();
829 m_xDockAreaWindows[DockingArea_DOCKINGAREA_LEFT].clear();
830 m_xDockAreaWindows[DockingArea_DOCKINGAREA_RIGHT].clear();
831 aWriteLock.unlock();
832 /* SAFE AREA ----------------------------------------------------------------------------------------------- */
833
834 const sal_uInt32 nCount = oldDockingAreaWindows.size();
835 for ( sal_uInt32 i=0; i < nCount; i++ )
836 {
837 if ( oldDockingAreaWindows[i].is() )
838 {
839 try
840 {
841 oldDockingAreaWindows[i]->dispose();
842 }
843 catch ( Exception& )
844 {
845 }
846 }
847 }
848 }
849
850 void LayoutManager::implts_createCustomToolBar( const rtl::OUString& aTbxResName, const rtl::OUString& aTitle )
851 {
852 if ( aTbxResName.getLength() > 0 )
853 {
854 createElement( aTbxResName );
855 if ( aTitle )
856 {
857 Reference< XUIElement > xUIElement = getElement( aTbxResName );
858 if ( xUIElement.is() )
859 {
860 vos::OGuard aGuard( Application::GetSolarMutex() );
861
862 Reference< css::awt::XWindow > xWindow( xUIElement->getRealInterface(), UNO_QUERY );
863 Window* pWindow = VCLUnoHelper::GetWindow( xWindow );
864 if ( pWindow )
865 pWindow->SetText( aTitle );
866 }
867 }
868 }
869 }
870
871 void LayoutManager::implts_createCustomToolBars(
872 const ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Sequence< ::com::sun::star::beans::PropertyValue > >& aTbxSeqSeq )
873 {
874 const Sequence< PropertyValue >* pTbxSeq = aTbxSeqSeq.getConstArray();
875 for ( sal_Int32 i = 0; i < aTbxSeqSeq.getLength(); i++ )
876 {
877 const Sequence< PropertyValue >& rTbxSeq = pTbxSeq[i];
878 ::rtl::OUString aTbxResName;
879 ::rtl::OUString aTbxTitle;
880 for ( sal_Int32 j = 0; j < rTbxSeq.getLength(); j++ )
881 {
882 if ( rTbxSeq[j].Name.equalsAscii( "ResourceURL" ))
883 rTbxSeq[j].Value >>= aTbxResName;
884 else if ( rTbxSeq[j].Name.equalsAscii( "UIName" ))
885 rTbxSeq[j].Value >>= aTbxTitle;
886 }
887
888 // Only create custom toolbars. Their name have to start with "custom_"!
889 if ( aTbxResName.getLength() > 0 && aTbxResName.indexOf( m_aCustomTbxPrefix ) != -1 )
890 implts_createCustomToolBar( aTbxResName, aTbxTitle );
891 }
892 }
893
894 void LayoutManager::implts_createCustomToolBars()
895 {
896 ReadGuard aReadLock( m_aLock );
897 if ( !m_bComponentAttached )
898 return;
899
900 Reference< XUIElementFactory > xUIElementFactory( m_xUIElementFactoryManager );
901 Reference< XFrame > xFrame( m_xFrame );
902 Reference< XModel > xModel;
903 Reference< XUIConfigurationManager > xModuleCfgMgr( m_xModuleCfgMgr, UNO_QUERY );
904 Reference< XUIConfigurationManager > xDocCfgMgr( m_xDocCfgMgr, UNO_QUERY );
905 aReadLock.unlock();
906
907 if ( xFrame.is() )
908 {
909 xModel = impl_getModelFromFrame( xFrame );
910 if ( implts_isPreviewModel( xModel ))
911 return; // no custom toolbars for preview frame!
912
913 Sequence< Sequence< PropertyValue > > aTbxSeq;
914 if ( xDocCfgMgr.is() )
915 {
916 aTbxSeq = xDocCfgMgr->getUIElementsInfo( UIElementType::TOOLBAR );
917 implts_createCustomToolBars( aTbxSeq ); // first create all document based toolbars
918 }
919 if ( xModuleCfgMgr.is() )
920 {
921 aTbxSeq = xModuleCfgMgr->getUIElementsInfo( UIElementType::TOOLBAR );
922 implts_createCustomToolBars( aTbxSeq ); // second create module based toolbars
923 }
924 }
925 }
926
927 rtl::OUString LayoutManager::implts_generateGenericAddonToolbarTitle( sal_Int32 nNumber ) const
928 {
929 String aAddonGenericTitle;
930
931 aAddonGenericTitle = String( FwkResId( STR_TOOLBAR_TITLE_ADDON ));
932 const vcl::I18nHelper& rI18nHelper = Application::GetSettings().GetUILocaleI18nHelper();
933
934 String aNumStr = rI18nHelper.GetNum( nNumber, 0, FALSE, FALSE );
935 aAddonGenericTitle.SearchAndReplaceAscii( "%num%", aNumStr );
936
937 return rtl::OUString( aAddonGenericTitle );
938 }
939
940 void LayoutManager::implts_createAddonsToolBars()
941 {
942 WriteGuard aWriteLock( m_aLock );
943 if ( !m_bComponentAttached )
944 return;
945
946 Reference< XModel > xModel;
947 Reference< XFrame > xFrame( m_xFrame );
948 if ( !xFrame.is() )
949 return;
950
951 if ( !m_pAddonOptions )
952 m_pAddonOptions = new AddonsOptions;
953
954 Reference< XUIElementFactory > xUIElementFactory( m_xUIElementFactoryManager );
955 aWriteLock.unlock();
956
957 xModel = impl_getModelFromFrame( xFrame );
958 if ( implts_isPreviewModel( xModel ))
959 return; // no addon toolbars for preview frame!
960
961 UIElementVector aUIElementVector;
962 Sequence< Sequence< PropertyValue > > aAddonToolBarData;
963 Reference< XUIElement > xUIElement;
964
965 sal_uInt32 nCount = m_pAddonOptions->GetAddonsToolBarCount();
966 ::rtl::OUString aAddonsToolBarStaticName( m_aFullAddonTbxPrefix );
967 ::rtl::OUString aElementType( RTL_CONSTASCII_USTRINGPARAM( "toolbar" ));
968
969 Sequence< PropertyValue > aPropSeq( 2 );
970 aPropSeq[0].Name = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Frame" ));
971 aPropSeq[0].Value <<= xFrame;
972 aPropSeq[1].Name = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "ConfigurationData" ));
973 for ( sal_uInt32 i = 0; i < nCount; i++ )
974 {
975 ::rtl::OUString aAddonToolBarName( aAddonsToolBarStaticName + m_pAddonOptions->GetAddonsToolbarResourceName(i) );
976 aAddonToolBarData = m_pAddonOptions->GetAddonsToolBarPart( i );
977 aPropSeq[1].Value <<= aAddonToolBarData;
978
979 aWriteLock.lock();
980 UIElement aElement = impl_findElement( aAddonToolBarName );
981 aWriteLock.unlock();
982
983 // #i79828
984 // It's now possible that we are called more than once. Be sure to not create
985 // add-on toolbars more than once!
986 if ( aElement.m_xUIElement.is() )
987 continue;
988
989 try
990 {
991 xUIElement = xUIElementFactory->createUIElement( aAddonToolBarName, aPropSeq );
992 if ( xUIElement.is() )
993 {
994 Reference< css::awt::XDockableWindow > xDockWindow( xUIElement->getRealInterface(), UNO_QUERY );
995 if ( xDockWindow.is() )
996 {
997 try
998 {
999 xDockWindow->addDockableWindowListener( Reference< css::awt::XDockableWindowListener >( static_cast< OWeakObject * >( this ), UNO_QUERY ));
1000 xDockWindow->enableDocking( sal_True );
1001 Reference< css::awt::XWindow > xWindow( xDockWindow, UNO_QUERY );
1002 if ( xWindow.is() )
1003 xWindow->addWindowListener( Reference< css::awt::XWindowListener >( static_cast< OWeakObject * >( this ), UNO_QUERY ));
1004 }
1005 catch ( Exception& )
1006 {
1007 }
1008 }
1009
1010 ::rtl::OUString aGenericAddonTitle = implts_generateGenericAddonToolbarTitle( i+1 );
1011
1012 if ( aElement.m_aName.getLength() > 0 )
1013 {
1014 // Reuse a local entry so we are able to use the latest
1015 // UI changes for this document.
1016 implts_setElementData( aElement, xDockWindow );
1017 aElement.m_xUIElement = xUIElement;
1018 if ( aElement.m_aUIName.getLength() == 0 )
1019 {
1020 aElement.m_aUIName = aGenericAddonTitle;
1021 implts_writeWindowStateData( aElement.m_aName, aElement );
1022 }
1023 }
1024 else
1025 {
1026 // Create new UI element and try to read its state data
1027 UIElement aNewToolbar( aAddonToolBarName, aElementType, xUIElement );
1028 aNewToolbar.m_bFloating = sal_True;
1029 implts_readWindowStateData( aAddonToolBarName, aNewToolbar );
1030 implts_setElementData( aNewToolbar, xDockWindow );
1031 if ( aNewToolbar.m_aUIName.getLength() == 0 )
1032 {
1033 aNewToolbar.m_aUIName = aGenericAddonTitle;
1034 implts_writeWindowStateData( aNewToolbar.m_aName, aNewToolbar );
1035 }
1036 implts_insertUIElement( aNewToolbar );
1037 }
1038
1039 Reference< css::awt::XWindow > xWindow( xDockWindow, UNO_QUERY );
1040 if ( xWindow.is() )
1041 {
1042 // Set generic title for add-on toolbar
1043 vos::OGuard aGuard( Application::GetSolarMutex() );
1044 Window* pWindow = VCLUnoHelper::GetWindow( xWindow );
1045 if ( pWindow->GetText().Len() == 0 )
1046 pWindow->SetText( aGenericAddonTitle );
1047 if ( pWindow->GetType() == WINDOW_TOOLBOX )
1048 {
1049 ToolBox* pToolbar = (ToolBox *)pWindow;
1050 pToolbar->SetMenuType();
1051 }
1052 }
1053 }
1054 }
1055 catch ( NoSuchElementException& )
1056 {
1057 }
1058 catch ( IllegalArgumentException& )
1059 {
1060 }
1061 }
1062 }
1063
1064 void LayoutManager::implts_createNonContextSensitiveToolBars()
1065 {
1066 ReadGuard aReadLock( m_aLock );
1067
1068 if ( !m_xPersistentWindowState.is() ||
1069 !m_xFrame.is() ||
1070 !m_bComponentAttached )
1071 return;
1072
1073 Reference< XFrame > xFrame( m_xFrame );
1074
1075 Reference< XUIElementFactory > xUIElementFactory( m_xUIElementFactoryManager );
1076 Reference< XNameAccess > xPersistentWindowState( m_xPersistentWindowState );
1077 aReadLock.unlock();
1078
1079 if ( implts_isPreviewModel( impl_getModelFromFrame( xFrame )))
1080 return;
1081
1082 std::vector< rtl::OUString > aMakeVisibleToolbars;
1083
1084 try
1085 {
1086 Sequence< rtl::OUString > aToolbarNames = xPersistentWindowState->getElementNames();
1087
1088 if ( aToolbarNames.getLength() > 0 )
1089 {
1090 rtl::OUString aElementType;
1091 rtl::OUString aElementName;
1092 rtl::OUString aName;
1093
1094 Reference< ::com::sun::star::ui::XUIElement > xUIElement;
1095 aMakeVisibleToolbars.reserve(aToolbarNames.getLength());
1096 WriteGuard aWriteLock( m_aLock );
1097
1098 const rtl::OUString* pTbNames = aToolbarNames.getConstArray();
1099 for ( sal_Int32 i = 0; i < aToolbarNames.getLength(); i++ )
1100 {
1101 aName = pTbNames[i];
1102 if ( impl_parseResourceURL( aName, aElementType, aElementName ))
1103 {
1104 // Check that we only create:
1105 // - Toolbars (the statusbar is also member of the persistent window state)
1106 // - Not custom toolbars, there are created with their own method (implts_createCustomToolbars)
1107 if ( aElementType.equalsIgnoreAsciiCaseAscii( "toolbar" ) &&
1108 aElementName.indexOf( m_aCustomTbxPrefix ) == -1 )
1109 {
1110 UIElement aNewToolbar( aName, aElementType, xUIElement );
1111 bool bFound = implts_findElement( aName, aNewToolbar );
1112 if ( !bFound )
1113 implts_readWindowStateData( aName, aNewToolbar );
1114
1115 if ( aNewToolbar.m_bVisible &&
1116 !aNewToolbar.m_bContextSensitive )
1117 {
1118 if ( !bFound )
1119 implts_insertUIElement( aNewToolbar );
1120 aMakeVisibleToolbars.push_back( aName );
1121 }
1122 }
1123 }
1124 }
1125 }
1126 }
1127 catch ( RuntimeException& e )
1128 {
1129 throw e;
1130 }
1131 catch ( Exception& )
1132 {
1133 }
1134
1135 if ( !aMakeVisibleToolbars.empty() )
1136 {
1137 implts_lock();
1138 ::std::for_each( aMakeVisibleToolbars.begin(), aMakeVisibleToolbars.end(),::boost::bind( &LayoutManager::requestElement, this,_1 ));
1139 implts_unlock();
1140 }
1141 }
1142
1143 void LayoutManager::implts_toggleFloatingUIElementsVisibility( sal_Bool bActive )
1144 {
1145 WriteGuard aWriteLock( m_aLock );
1146 UIElementVector::iterator pIter;
1147
1148 ReadGuard aReadLock( m_aLock );
1149 for ( pIter = m_aUIElements.begin(); pIter != m_aUIElements.end(); pIter++ )
1150 {
1151 if ( pIter->m_xUIElement.is() )
1152 {
1153 Reference< css::awt::XDockableWindow > xDockWindow( pIter->m_xUIElement->getRealInterface(), UNO_QUERY );
1154 Reference< css::awt::XWindow > xWindow( xDockWindow, UNO_QUERY );
1155 if ( xDockWindow.is() && xWindow.is() )
1156 {
1157 sal_Bool bVisible( sal_True );
1158 vos::OGuard aGuard( Application::GetSolarMutex() );
1159 Window* pWindow = VCLUnoHelper::GetWindow( xWindow );
1160 if ( pWindow )
1161 bVisible = pWindow->IsVisible();
1162
1163 if ( xDockWindow->isFloating() )
1164 {
1165 if ( bActive )
1166 {
1167 if ( !bVisible && pIter->m_bDeactiveHide )
1168 {
1169 pIter->m_bDeactiveHide = sal_False;
1170 // we need VCL here to pass special flags to Show()
1171 if( pWindow )
1172 pWindow->Show( TRUE, SHOW_NOFOCUSCHANGE | SHOW_NOACTIVATE );
1173 //xWindow->setVisible( sal_True );
1174 }
1175 }
1176 else
1177 {
1178 if ( bVisible )
1179 {
1180 pIter->m_bDeactiveHide = sal_True;
1181 xWindow->setVisible( sal_False );
1182 }
1183 }
1184 }
1185 }
1186 }
1187 }
1188 }
1189
1190 sal_Bool LayoutManager::implts_findElement( const rtl::OUString& aName, rtl::OUString& aElementType, rtl::OUString& aElementName, Reference< XUIElement >& xUIElement )
1191 {
1192 if ( impl_parseResourceURL( aName, aElementType, aElementName ))
1193 {
1194 if ( aElementType.equalsIgnoreAsciiCaseAscii( "menubar" ) &&
1195 aElementName.equalsIgnoreAsciiCaseAscii( "menubar" ))
1196 {
1197 ReadGuard aReadLock( m_aLock );
1198 xUIElement = m_xMenuBar;
1199 return sal_True;
1200 }
1201 else if (( aElementType.equalsIgnoreAsciiCaseAscii( "statusbar" ) &&
1202 aElementName.equalsIgnoreAsciiCaseAscii( "statusbar" )) ||
1203 ( m_aStatusBarElement.m_aName == aName ))
1204 {
1205 ReadGuard aReadLock( m_aLock );
1206 xUIElement = m_aStatusBarElement.m_xUIElement;
1207 return sal_True;
1208 }
1209 else if ( aElementType.equalsIgnoreAsciiCaseAscii( "progressbar" ) &&
1210 aElementName.equalsIgnoreAsciiCaseAscii( "progressbar" ))
1211 {
1212 ReadGuard aReadLock( m_aLock );
1213 xUIElement = m_aProgressBarElement.m_xUIElement;
1214 return sal_True;
1215 }
1216 else
1217 {
1218 UIElementVector::const_iterator pIter;
1219
1220 ReadGuard aReadLock( m_aLock );
1221 for ( pIter = m_aUIElements.begin(); pIter != m_aUIElements.end(); pIter++ )
1222 {
1223 if ( pIter->m_aName == aName )
1224 {
1225 xUIElement = pIter->m_xUIElement;
1226 return sal_True;
1227 }
1228 }
1229 }
1230 }
1231
1232 return sal_False;
1233 }
1234
1235 sal_Bool LayoutManager::implts_findElement( const Reference< XInterface >& xUIElement, UIElement& aElementData )
1236 {
1237 UIElementVector::const_iterator pIter;
1238
1239 ReadGuard aReadLock( m_aLock );
1240 for ( pIter = m_aUIElements.begin(); pIter != m_aUIElements.end(); pIter++ )
1241 {
1242 if ( pIter->m_xUIElement.is() )
1243 {
1244 Reference< XInterface > xIfac( pIter->m_xUIElement->getRealInterface(), UNO_QUERY );
1245 if ( xIfac == xUIElement )
1246 {
1247 aElementData = *pIter;
1248 return sal_True;
1249 }
1250 }
1251 }
1252
1253 return sal_False;
1254 }
1255
1256 sal_Bool LayoutManager::implts_findElement( const rtl::OUString& aName, UIElement& aElementData )
1257 {
1258 UIElementVector::const_iterator pIter;
1259
1260 ReadGuard aReadLock( m_aLock );
1261 for ( pIter = m_aUIElements.begin(); pIter != m_aUIElements.end(); pIter++ )
1262 {
1263 if ( pIter->m_aName == aName )
1264 {
1265 aElementData = *pIter;
1266 return sal_True;
1267 }
1268 }
1269
1270 return sal_False;
1271 }
1272
1273 LayoutManager::UIElement& LayoutManager::impl_findElement( const rtl::OUString& aName )
1274 {
1275 static UIElement aEmptyElement;
1276
1277 UIElementVector::iterator pIter;
1278
1279 ReadGuard aReadLock( m_aLock );
1280 for ( pIter = m_aUIElements.begin(); pIter != m_aUIElements.end(); pIter++ )
1281 {
1282 if ( pIter->m_aName == aName )
1283 return *pIter;
1284 }
1285
1286 return aEmptyElement;
1287 }
1288
1289 sal_Bool LayoutManager::implts_insertUIElement( const UIElement& rUIElement )
1290 {
1291 UIElement aTempData;
1292 bool bFound = implts_findElement( rUIElement.m_aName, aTempData );
1293
1294 #ifdef DBG_UTIL
1295 if ( bFound )
1296 {
1297 char aBuffer[256];
1298 const sal_Int32 MAX_NAME_LENGTH = 128;
1299 ::rtl::OString aName = ::rtl::OUStringToOString( rUIElement.m_aName, RTL_TEXTENCODING_ASCII_US );
1300 aName = aName.copy( ::std::min( MAX_NAME_LENGTH, aName.getLength() ));
1301 sprintf( aBuffer, "Try to insert an already existing user interface element (%s) into the list\n", aName.getStr() );
1302 DBG_ASSERT( bFound, aBuffer );
1303 }
1304 #endif
1305
1306 bool bResult( false );
1307 if ( !bFound )
1308 {
1309 WriteGuard aWriteLock( m_aLock );
1310 m_aUIElements.push_back( rUIElement );
1311 bResult = true;
1312 }
1313 return bResult;
1314 }
1315
1316 void LayoutManager::implts_writeNewStateData( const rtl::OUString aName, const Reference< css::awt::XWindow >& xWindow )
1317 {
1318 css::awt::Rectangle aPos;
1319 css::awt::Size aSize;
1320 sal_Bool bVisible( sal_False );
1321 sal_Bool bFloating( sal_True );
1322
1323 if ( xWindow.is() )
1324 {
1325 Reference< css::awt::XDockableWindow > xDockWindow( xWindow, UNO_QUERY );
1326 if ( xDockWindow.is() )
1327 bFloating = xDockWindow->isFloating();
1328
1329 Reference< css::awt::XWindow2 > xWindow2( xWindow, UNO_QUERY );
1330 if( xWindow2.is() )
1331 {
1332 aPos = xWindow2->getPosSize();
1333 aSize = xWindow2->getOutputSize(); // always use output size for consistency
1334 bVisible = xWindow2->isVisible();
1335 }
1336 }
1337
1338 WriteGuard aWriteLock( m_aLock );
1339 UIElement& rUIElement = impl_findElement( aName );
1340 if ( rUIElement.m_xUIElement.is() && xWindow.is() )
1341 {
1342 rUIElement.m_bVisible = bVisible;
1343 rUIElement.m_bFloating = bFloating;
1344 if ( bFloating )
1345 {
1346 rUIElement.m_aFloatingData.m_aPos = ::Point( aPos.X, aPos.Y );
1347 rUIElement.m_aFloatingData.m_aSize = ::Size( aSize.Width, aSize.Height );
1348 }
1349 }
1350
1351 implts_writeWindowStateData( aName, rUIElement );
1352
1353 aWriteLock.unlock();
1354 }
1355
1356 void LayoutManager::implts_refreshContextToolbarsVisibility()
1357 {
1358 std::vector< UIElementVisibility > aToolbarVisibleVector;
1359
1360 ReadGuard aReadLock( m_aLock );
1361 /* SAFE AREA ----------------------------------------------------------------------------------------------- */
1362 if ( !m_bVisible || !m_bAutomaticToolbars )
1363 return;
1364
1365 UIElementVisibility aUIElementVisible;
1366
1367 UIElementVector::iterator pIter;
1368 for ( pIter = m_aUIElements.begin(); pIter != m_aUIElements.end(); pIter++ )
1369 {
1370 if ( pIter->m_aType.equalsAsciiL( "toolbar", 7 ))
1371 {
1372 aUIElementVisible.aName = pIter->m_aName;
1373 aUIElementVisible.bVisible = pIter->m_bVisible;
1374 aToolbarVisibleVector.push_back( aUIElementVisible );
1375 }
1376 }
1377 /* SAFE AREA ----------------------------------------------------------------------------------------------- */
1378 aReadLock.unlock();
1379
1380 UIElement aUIElement;
1381 const sal_uInt32 nCount = aToolbarVisibleVector.size();
1382 for ( sal_uInt32 i = 0; i < nCount; i++ )
1383 {
1384 UIElementVisibility& rToolbar = aToolbarVisibleVector[i];
1385
1386 sal_Bool bVisible = rToolbar.bVisible;
1387 if ( implts_readWindowStateData( rToolbar.aName, aUIElement ) &&
1388 aUIElement.m_bVisible != bVisible )
1389 {
1390 WriteGuard aWriteLock( m_aLock );
1391 /* SAFE AREA ----------------------------------------------------------------------------------------------- */
1392 UIElement& rUIElement = impl_findElement( rToolbar.aName );
1393
1394 if ( rUIElement.m_aName == rToolbar.aName )
1395 rUIElement.m_bVisible = aUIElement.m_bVisible;
1396 /* SAFE AREA ----------------------------------------------------------------------------------------------- */
1397 aWriteLock.unlock();
1398 }
1399 }
1400 }
1401
1402 sal_Bool LayoutManager::implts_readWindowStateData( const rtl::OUString& aName, UIElement& rElementData )
1403 {
1404 sal_Bool bGetSettingsState( sal_False );
1405
1406 WriteGuard aWriteLock( m_aLock );
1407 Reference< XNameAccess > xPersistentWindowState( m_xPersistentWindowState );
1408 aWriteLock.unlock();
1409
1410 if ( xPersistentWindowState.is() )
1411 {
1412 aWriteLock.lock();
1413 sal_Bool bGlobalSettings( m_bGlobalSettings );
1414 GlobalSettings* pGlobalSettings( 0 );
1415 if ( m_pGlobalSettings == 0 )
1416 {
1417 m_pGlobalSettings = new GlobalSettings( m_xSMGR );
1418 bGetSettingsState = sal_True;
1419 }
1420 pGlobalSettings = m_pGlobalSettings;
1421 aWriteLock.unlock();
1422
1423 try
1424 {
1425 Sequence< PropertyValue > aWindowState;
1426 if ( xPersistentWindowState->getByName( aName ) >>= aWindowState )
1427 {
1428 sal_Bool bValue( sal_False );
1429 for ( sal_Int32 n = 0; n < aWindowState.getLength(); n++ )
1430 {
1431 if ( aWindowState[n].Name == m_aPropDocked )
1432 {
1433 if ( aWindowState[n].Value >>= bValue )
1434 rElementData.m_bFloating = !bValue;
1435 }
1436 else if ( aWindowState[n].Name == m_aPropVisible )
1437 {
1438 if ( aWindowState[n].Value >>= bValue )
1439 rElementData.m_bVisible = bValue;
1440 }
1441 else if ( aWindowState[n].Name == m_aPropDockingArea )
1442 {
1443 ::com::sun::star::ui::DockingArea eDockingArea;
1444 if ( aWindowState[n].Value >>= eDockingArea )
1445 rElementData.m_aDockedData.m_nDockedArea = sal_Int16( eDockingArea );
1446 }
1447 else if ( aWindowState[n].Name == m_aPropDockPos )
1448 {
1449 css::awt::Point aPoint;
1450 if ( aWindowState[n].Value >>= aPoint )
1451 {
1452 rElementData.m_aDockedData.m_aPos.X() = aPoint.X;
1453 rElementData.m_aDockedData.m_aPos.Y() = aPoint.Y;
1454 }
1455 }
1456 else if ( aWindowState[n].Name == m_aPropPos )
1457 {
1458 css::awt::Point aPoint;
1459 if ( aWindowState[n].Value >>= aPoint )
1460 {
1461 rElementData.m_aFloatingData.m_aPos.X() = aPoint.X;
1462 rElementData.m_aFloatingData.m_aPos.Y() = aPoint.Y;
1463 }
1464 }
1465 else if ( aWindowState[n].Name == m_aPropSize )
1466 {
1467 css::awt::Size aSize;
1468 if ( aWindowState[n].Value >>= aSize )
1469 {
1470 rElementData.m_aFloatingData.m_aSize.Width() = aSize.Width;
1471 rElementData.m_aFloatingData.m_aSize.Height() = aSize.Height;
1472 }
1473 }
1474 else if ( aWindowState[n].Name == m_aPropUIName )
1475 aWindowState[n].Value >>= rElementData.m_aUIName;
1476 else if ( aWindowState[n].Name == m_aPropStyle )
1477 {
1478 sal_Int32 nStyle = 0;
1479 if ( aWindowState[n].Value >>= nStyle )
1480 rElementData.m_nStyle = sal_Int16( nStyle );
1481 }
1482 else if ( aWindowState[n].Name == m_aPropLocked )
1483 {
1484 if ( aWindowState[n].Value >>= bValue )
1485 rElementData.m_aDockedData.m_bLocked = bValue;
1486 }
1487 else if ( aWindowState[n].Name.equalsAscii( WINDOWSTATE_PROPERTY_CONTEXT ))
1488 {
1489 if ( aWindowState[n].Value >>= bValue )
1490 rElementData.m_bContextSensitive = bValue;
1491 }
1492 else if ( aWindowState[n].Name.equalsAscii( WINDOWSTATE_PROPERTY_NOCLOSE ))
1493 {
1494 if ( aWindowState[n].Value >>= bValue )
1495 rElementData.m_bNoClose = bValue;
1496 }
1497 else if ( aWindowState[n].Name.equalsAscii( WINDOWSTATE_PROPERTY_CONTEXTACTIVE ))
1498 {
1499 if ( aWindowState[n].Value >>= bValue )
1500 rElementData.m_bContextActive = bValue;
1501 }
1502 else if ( aWindowState[n].Name.equalsAscii( WINDOWSTATE_PROPERTY_SOFTCLOSE ))
1503 {
1504 if ( aWindowState[n].Value >>= bValue )
1505 rElementData.m_bSoftClose = bValue;
1506 }
1507 }
1508 }
1509
1510 // oversteer values with global settings
1511 if ( pGlobalSettings && ( bGetSettingsState || bGlobalSettings ))
1512 {
1513 if ( pGlobalSettings->HasStatesInfo( GlobalSettings::UIELEMENT_TYPE_TOOLBAR ))
1514 {
1515 WriteGuard aWriteLock2( m_aLock );
1516 m_bGlobalSettings = sal_True;
1517 aWriteLock2.unlock();
1518
1519 css::uno::Any aValue;
1520 sal_Bool bValue = sal_Bool();
1521 if ( pGlobalSettings->GetStateInfo( GlobalSettings::UIELEMENT_TYPE_TOOLBAR,
1522 GlobalSettings::STATEINFO_LOCKED,
1523 aValue ))
1524 aValue >>= rElementData.m_aDockedData.m_bLocked;
1525 if ( pGlobalSettings->GetStateInfo( GlobalSettings::UIELEMENT_TYPE_TOOLBAR,
1526 GlobalSettings::STATEINFO_DOCKED,
1527 aValue ))
1528 {
1529 if ( aValue >>= bValue )
1530 rElementData.m_bFloating = !bValue;
1531 }
1532 }
1533 }
1534
1535 return sal_True;
1536 }
1537 catch ( NoSuchElementException& )
1538 {
1539 }
1540 }
1541
1542 return sal_False;
1543 }
1544
1545 void LayoutManager::implts_writeWindowStateData( const rtl::OUString& aName, const UIElement& rElementData )
1546 {
1547 WriteGuard aWriteLock( m_aLock );
1548 Reference< XNameAccess > xPersistentWindowState( m_xPersistentWindowState );
1549
1550 // set flag to determine that we triggered the notification
1551 m_bStoreWindowState = sal_True;
1552 aWriteLock.unlock();
1553
1554 sal_Bool bPersistent( sal_False );
1555 Reference< XPropertySet > xPropSet( rElementData.m_xUIElement, UNO_QUERY );
1556 if ( xPropSet.is() )
1557 {
1558 try
1559 {
1560 // Check persistent flag of the user interface element
1561 xPropSet->getPropertyValue( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Persistent" ))) >>= bPersistent;
1562 }
1563 catch ( com::sun::star::beans::UnknownPropertyException )
1564 {
1565 // Non-configurable elements should at least store their dimension/position
1566 bPersistent = sal_True;
1567 }
1568 catch ( com::sun::star::lang::WrappedTargetException )
1569 {
1570 }
1571 }
1572
1573 if ( bPersistent && xPersistentWindowState.is() )
1574 {
1575 try
1576 {
1577 Sequence< PropertyValue > aWindowState( 8 );
1578
1579 aWindowState[0].Name = m_aPropDocked;
1580 aWindowState[0].Value = makeAny( sal_Bool( !rElementData.m_bFloating ));
1581 aWindowState[1].Name = m_aPropVisible;
1582 aWindowState[1].Value = makeAny( sal_Bool( rElementData.m_bVisible ));
1583
1584 aWindowState[2].Name = m_aPropDockingArea;
1585 aWindowState[2].Value = makeAny( static_cast< DockingArea >( rElementData.m_aDockedData.m_nDockedArea ) );
1586
1587 css::awt::Point aPos;
1588 aPos.X = rElementData.m_aDockedData.m_aPos.X();
1589 aPos.Y = rElementData.m_aDockedData.m_aPos.Y();
1590 aWindowState[3].Name = m_aPropDockPos;
1591 aWindowState[3].Value <<= aPos;
1592
1593 aPos.X = rElementData.m_aFloatingData.m_aPos.X();
1594 aPos.Y = rElementData.m_aFloatingData.m_aPos.Y();
1595 aWindowState[4].Name = m_aPropPos;
1596 aWindowState[4].Value <<= aPos;
1597
1598 css::awt::Size aSize;
1599 aSize.Width = rElementData.m_aFloatingData.m_aSize.Width();
1600 aSize.Height = rElementData.m_aFloatingData.m_aSize.Height();
1601 aWindowState[5].Name = m_aPropSize;
1602 aWindowState[5].Value <<= aSize;
1603 aWindowState[6].Name = m_aPropUIName;
1604 aWindowState[6].Value = makeAny( rElementData.m_aUIName );
1605 aWindowState[7].Name = m_aPropLocked;
1606 aWindowState[7].Value = makeAny( rElementData.m_aDockedData.m_bLocked );
1607
1608 if ( xPersistentWindowState->hasByName( aName ))
1609 {
1610 Reference< XNameReplace > xReplace( xPersistentWindowState, UNO_QUERY );
1611 xReplace->replaceByName( aName, makeAny( aWindowState ));
1612 }
1613 else
1614 {
1615 Reference< XNameContainer > xInsert( xPersistentWindowState, UNO_QUERY );
1616 xInsert->insertByName( aName, makeAny( aWindowState ));
1617 }
1618 }
1619 catch ( Exception& )
1620 {
1621 }
1622 }
1623
1624 // Reset flag
1625 aWriteLock.lock();
1626 m_bStoreWindowState = sal_False;
1627 aWriteLock.unlock();
1628 }
1629
1630 void LayoutManager::implts_setElementData( UIElement& rElement, const Reference< css::awt::XDockableWindow >& rDockWindow )
1631 {
1632 ReadGuard aReadLock( m_aLock );
1633 sal_Bool bShowElement( rElement.m_bVisible && !rElement.m_bMasterHide && m_bParentWindowVisible );
1634 aReadLock.unlock();
1635
1636 Reference< css::awt::XDockableWindow > xDockWindow( rDockWindow );
1637 Reference< css::awt::XWindow2 > xWindow( xDockWindow, UNO_QUERY );
1638
1639 Window* pWindow( 0 );
1640 ToolBox* pToolBox( 0 );
1641
1642 if ( xDockWindow.is() && xWindow.is() )
1643 {
1644 {
1645 vos::OGuard aGuard( Application::GetSolarMutex() );
1646 pWindow = VCLUnoHelper::GetWindow( xWindow );
1647 if ( pWindow )
1648 {
1649 String aText = pWindow->GetText();
1650 if ( aText.Len() == 0 )
1651 pWindow->SetText( rElement.m_aUIName );
1652 if ( rElement.m_bNoClose )
1653 pWindow->SetStyle( pWindow->GetStyle() & ~WB_CLOSEABLE );
1654 if ( pWindow->GetType() == WINDOW_TOOLBOX )
1655 pToolBox = (ToolBox *)pWindow;
1656 }
1657 if ( pToolBox )
1658 {
1659 if (( rElement.m_nStyle < 0 ) ||
1660 ( rElement.m_nStyle > BUTTON_SYMBOLTEXT ))
1661 rElement.m_nStyle = BUTTON_SYMBOL;
1662 pToolBox->SetButtonType( (ButtonType)rElement.m_nStyle );
1663 if ( rElement.m_bNoClose )
1664 pToolBox->SetFloatStyle( pToolBox->GetFloatStyle() & ~WB_CLOSEABLE );
1665 }
1666 }
1667
1668 if ( rElement.m_bFloating )
1669 {
1670 if ( pWindow )
1671 {
1672 vos::OGuard aGuard( Application::GetSolarMutex() );
1673 String aText = pWindow->GetText();
1674 if ( aText.Len() == 0 )
1675 pWindow->SetText( rElement.m_aUIName );
1676 }
1677
1678 ::Point aPos( rElement.m_aFloatingData.m_aPos.X(),
1679 rElement.m_aFloatingData.m_aPos.Y() );
1680 sal_Bool bWriteData( sal_False );
1681 sal_Bool bUndefPos = ( rElement.m_aFloatingData.m_aPos.X() == SAL_MAX_INT32 ||
1682 rElement.m_aFloatingData.m_aPos.Y() == SAL_MAX_INT32 );
1683 sal_Bool bSetSize = ( rElement.m_aFloatingData.m_aSize.Width() != 0 &&
1684 rElement.m_aFloatingData.m_aSize.Height() != 0 );
1685 xDockWindow->setFloatingMode( sal_True );
1686 if ( bUndefPos )
1687 {
1688 aPos = implts_findNextCascadeFloatingPos();
1689 rElement.m_aFloatingData.m_aPos = aPos; // set new cascaded position
1690 bWriteData = sal_True;
1691 }
1692
1693 if( bSetSize )
1694 xWindow->setOutputSize( AWTSize( rElement.m_aFloatingData.m_aSize ) );
1695 else
1696 {
1697 if( pToolBox )
1698 {
1699 // set an optimal initial floating size
1700 vos::OGuard aGuard( Application::GetSolarMutex() );
1701 ::Size aSize( pToolBox->CalcFloatingWindowSizePixel() );
1702 pToolBox->SetOutputSizePixel( aSize );
1703 }
1704 }
1705
1706 // #i60882# IMPORTANT: Set position after size as it is
1707 // possible that we position some part of the toolbar
1708 // outside of the desktop. A default constructed toolbar
1709 // always has one line. Now VCL automatically
1710 // position the toolbar back into the desktop. Therefore
1711 // we resize the toolbar with the new (wrong) position.
1712 // To fix this problem we have to set the size BEFORE the
1713 // position.
1714 xWindow->setPosSize( aPos.X(), aPos.Y(), 0, 0,
1715 css::awt::PosSize::POS );
1716
1717 if ( bWriteData )
1718 implts_writeWindowStateData( rElement.m_aName, rElement );
1719 if ( bShowElement && pWindow )
1720 {
1721 vos::OGuard aGuard( Application::GetSolarMutex() );
1722 pWindow->Show( sal_True, SHOW_NOFOCUSCHANGE | SHOW_NOACTIVATE );
1723 }
1724 }
1725 else
1726 {
1727 ::Point aDockPos;
1728 ::Point aPixelPos;
1729 sal_Bool bSetSize( sal_False );
1730 ::Size aSize;
1731
1732 if ( pToolBox )
1733 {
1734 vos::OGuard aGuard( Application::GetSolarMutex() );
1735 pToolBox->SetAlign( ImplConvertAlignment(rElement.m_aDockedData.m_nDockedArea ) );
1736 pToolBox->SetLineCount( 1 );
1737 if ( rElement.m_aDockedData.m_bLocked )
1738 xDockWindow->lock();
1739 aSize = pToolBox->CalcWindowSizePixel();
1740 bSetSize = sal_True;
1741
1742 if (( rElement.m_aDockedData.m_aPos.X() == SAL_MAX_INT32 ) &&
1743 ( rElement.m_aDockedData.m_aPos.Y() == SAL_MAX_INT32 ))
1744 {
1745 implts_findNextDockingPos( (DockingArea)rElement.m_aDockedData.m_nDockedArea,
1746 aSize,
1747 aDockPos,
1748 aPixelPos );
1749 rElement.m_aDockedData.m_aPos = aDockPos;
1750 }
1751 }
1752
1753 xWindow->setPosSize( aPixelPos.X(),
1754 aPixelPos.Y(),
1755 0, 0,
1756 css::awt::PosSize::POS );
1757 if( bSetSize )
1758 xWindow->setOutputSize( AWTSize( aSize) );
1759
1760 if ( bShowElement && pWindow )
1761 {
1762 vos::OGuard aGuard( Application::GetSolarMutex() );
1763 pWindow->Show( sal_True );
1764 }
1765 }
1766 }
1767 }
1768
1769 ::Point LayoutManager::implts_findNextCascadeFloatingPos()
1770 {
1771 const sal_Int32 nHotZoneX = 50;
1772 const sal_Int32 nHotZoneY = 50;
1773 const sal_Int32 nCascadeIndentX = 15;
1774 const sal_Int32 nCascadeIndentY = 15;
1775
1776 ReadGuard aReadLock( m_aLock );
1777 Reference< css::awt::XWindow > xContainerWindow = m_xContainerWindow;
1778 Reference< css::awt::XWindow > xTopDockingWindow = m_xDockAreaWindows[DockingArea_DOCKINGAREA_TOP];
1779 Reference< css::awt::XWindow > xLeftDockingWindow = m_xDockAreaWindows[DockingArea_DOCKINGAREA_LEFT];
1780 aReadLock.unlock();
1781
1782 ::Point aStartPos( nCascadeIndentX, nCascadeIndentY );
1783 ::Point aCurrPos( aStartPos );
1784 css::awt::Rectangle aRect;
1785
1786 Window* pContainerWindow( 0 );
1787 if ( xContainerWindow.is() )
1788 {
1789 vos::OGuard aGuard( Application::GetSolarMutex() );
1790 pContainerWindow = VCLUnoHelper::GetWindow( xContainerWindow );
1791 if ( pContainerWindow )
1792 aStartPos = pContainerWindow->OutputToScreenPixel( aStartPos );
1793 }
1794
1795 // Determine size of top and left docking area
1796 css::awt::Rectangle aTopRect = xTopDockingWindow->getPosSize();
1797 css::awt::Rectangle aLeftRect = xLeftDockingWindow->getPosSize();
1798
1799 aStartPos.X() += aLeftRect.Width + nCascadeIndentX;
1800 aStartPos.Y() += aTopRect.Height + nCascadeIndentY;
1801 aCurrPos = aStartPos;
1802
1803 // Try to find a cascaded position for the new floating window
1804 UIElementVector::const_iterator pIter;
1805 for ( pIter = m_aUIElements.begin(); pIter != m_aUIElements.end(); pIter++ )
1806 {
1807 if ( pIter->m_xUIElement.is() )
1808 {
1809 Reference< css::awt::XDockableWindow > xDockWindow( pIter->m_xUIElement->getRealInterface(), UNO_QUERY );
1810 Reference< css::awt::XWindow > xWindow( xDockWindow, UNO_QUERY );
1811 if ( xDockWindow.is() && xDockWindow->isFloating() )
1812 {
1813 vos::OGuard aGuard( Application::GetSolarMutex() );
1814 Window* pWindow = VCLUnoHelper::GetWindow( xWindow );
1815 if ( pWindow && pWindow->IsVisible() )
1816 {
1817 css::awt::Rectangle aFloatRect = xWindow->getPosSize();
1818 if ((( aFloatRect.X - nHotZoneX ) <= aCurrPos.X() ) &&
1819 ( aFloatRect.X >= aCurrPos.X() ) &&
1820 (( aFloatRect.Y - nHotZoneY ) <= aCurrPos.Y() ) &&
1821 ( aFloatRect.Y >= aCurrPos.Y() ))
1822 {
1823 aCurrPos.X() = aFloatRect.X + nCascadeIndentX;
1824 aCurrPos.Y() = aFloatRect.Y + nCascadeIndentY;
1825 }
1826 }
1827 }
1828 }
1829 }
1830
1831 return aCurrPos;
1832 }
1833
1834 void LayoutManager::implts_findNextDockingPos( DockingArea DockingArea, const ::Size& aUIElementSize, ::Point& rVirtualPos, ::Point& rPixelPos )
1835 {
1836 ReadGuard aReadLock( m_aLock );
1837 Reference< css::awt::XWindow > xDockingWindow = m_xDockAreaWindows[DockingArea];
1838 ::Size aDockingWinSize;
1839 Window* pDockingWindow( 0 );
1840 aReadLock.unlock();
1841
1842 if (( DockingArea < DockingArea_DOCKINGAREA_TOP ) ||
1843 ( DockingArea > DockingArea_DOCKINGAREA_RIGHT ))
1844 DockingArea = DockingArea_DOCKINGAREA_TOP;
1845
1846 {
1847 // Retrieve output size from container Window
1848 vos::OGuard aGuard( Application::GetSolarMutex() );
1849 pDockingWindow = VCLUnoHelper::GetWindow( xDockingWindow );
1850 if ( pDockingWindow )
1851 aDockingWinSize = pDockingWindow->GetOutputSizePixel();
1852 }
1853
1854 sal_Int32 nFreeRowColPixelPos( 0 );
1855 sal_Int32 nMaxSpace( 0 );
1856 sal_Int32 nNeededSpace( 0 );
1857 sal_Int32 nTopDockingAreaSize( 0 );
1858
1859 if (( DockingArea == DockingArea_DOCKINGAREA_TOP ) ||
1860 ( DockingArea == DockingArea_DOCKINGAREA_BOTTOM ))
1861 {
1862 nMaxSpace = aDockingWinSize.Width();
1863 nNeededSpace = aUIElementSize.Width();
1864 }
1865 else
1866 {
1867 nMaxSpace = aDockingWinSize.Height();
1868 nNeededSpace = aUIElementSize.Height();
1869 nTopDockingAreaSize = implts_getTopBottomDockingAreaSizes().Width();
1870 }
1871
1872 std::vector< SingleRowColumnWindowData > aRowColumnsWindowData;
1873
1874 implts_getDockingAreaElementInfos( DockingArea, aRowColumnsWindowData );
1875 sal_Int32 nPixelPos( 0 );
1876 const sal_uInt32 nCount = aRowColumnsWindowData.size();
1877 for ( sal_uInt32 i = 0; i < nCount; i++ )
1878 {
1879 SingleRowColumnWindowData& rRowColumnWindowData = aRowColumnsWindowData[i];
1880
1881 if (( DockingArea == DockingArea_DOCKINGAREA_BOTTOM ) ||
1882 ( DockingArea == DockingArea_DOCKINGAREA_RIGHT ))
1883 nPixelPos += rRowColumnWindowData.nStaticSize;
1884
1885 if ((( nMaxSpace - rRowColumnWindowData.nVarSize ) >= nNeededSpace ) ||
1886 ( rRowColumnWindowData.nSpace >= nNeededSpace ))
1887 {
1888 // Check current row where we can find the needed space
1889 sal_Int32 nCurrPos( 0 );
1890 const sal_uInt32 nWindowSizesCount = rRowColumnWindowData.aRowColumnWindowSizes.size();
1891 for ( sal_uInt32 j = 0; j < nWindowSizesCount; j++ )
1892 {
1893 css::awt::Rectangle rRect = rRowColumnWindowData.aRowColumnWindowSizes[j];
1894 sal_Int32& rSpace = rRowColumnWindowData.aRowColumnSpace[j];
1895 if (( DockingArea == DockingArea_DOCKINGAREA_TOP ) ||
1896 ( DockingArea == DockingArea_DOCKINGAREA_BOTTOM ))
1897 {
1898 if ( rSpace >= nNeededSpace )
1899 {
1900 rVirtualPos = ::Point( nCurrPos, rRowColumnWindowData.nRowColumn );
1901 if ( DockingArea == DockingArea_DOCKINGAREA_TOP )
1902 rPixelPos = ::Point( nCurrPos, nPixelPos );
1903 else
1904 rPixelPos = ::Point( nCurrPos, aDockingWinSize.Height() - nPixelPos );
1905 return;
1906 }
1907 nCurrPos = rRect.X + rRect.Width;
1908 }
1909 else
1910 {
1911 if ( rSpace >= nNeededSpace )
1912 {
1913 rVirtualPos = ::Point( rRowColumnWindowData.nRowColumn, nCurrPos );
1914 if ( DockingArea == DockingArea_DOCKINGAREA_LEFT )
1915 rPixelPos = ::Point( nPixelPos, nTopDockingAreaSize + nCurrPos );
1916 else
1917 rPixelPos = ::Point( aDockingWinSize.Width() - nPixelPos , nTopDockingAreaSize + nCurrPos );
1918 return;
1919 }
1920 nCurrPos = rRect.Y + rRect.Height;
1921 }
1922 }
1923
1924 if (( nCurrPos + nNeededSpace ) <= nMaxSpace )
1925 {
1926 if (( DockingArea == DockingArea_DOCKINGAREA_TOP ) ||
1927 ( DockingArea == DockingArea_DOCKINGAREA_BOTTOM ))
1928 {
1929 rVirtualPos = ::Point( nCurrPos, rRowColumnWindowData.nRowColumn );
1930 if ( DockingArea == DockingArea_DOCKINGAREA_TOP )
1931 rPixelPos = ::Point( nCurrPos, nPixelPos );
1932 else
1933 rPixelPos = ::Point( nCurrPos, aDockingWinSize.Height() - nPixelPos );
1934 return;
1935 }
1936 else
1937 {
1938 rVirtualPos = ::Point( rRowColumnWindowData.nRowColumn, nCurrPos );
1939 if ( DockingArea == DockingArea_DOCKINGAREA_LEFT )
1940 rPixelPos = ::Point( nPixelPos, nTopDockingAreaSize + nCurrPos );
1941 else
1942 rPixelPos = ::Point( aDockingWinSize.Width() - nPixelPos , nTopDockingAreaSize + nCurrPos );
1943 return;
1944 }
1945 }
1946 }
1947
1948 if (( DockingArea == DockingArea_DOCKINGAREA_TOP ) ||
1949 ( DockingArea == DockingArea_DOCKINGAREA_LEFT ))
1950 nPixelPos += rRowColumnWindowData.nStaticSize;
1951 }
1952
1953 sal_Int32 nNextFreeRowCol( 0 );
1954 sal_Int32 nRowColumnsCount = aRowColumnsWindowData.size();
1955 if ( nRowColumnsCount > 0 )
1956 nNextFreeRowCol = aRowColumnsWindowData[nRowColumnsCount-1].nRowColumn+1;
1957 else
1958 nNextFreeRowCol = 0;
1959
1960 if ( nNextFreeRowCol == 0 )
1961 {
1962 if ( DockingArea == DockingArea_DOCKINGAREA_BOTTOM )
1963 nFreeRowColPixelPos = aDockingWinSize.Height() - aUIElementSize.Height();
1964 else if ( DockingArea == DockingArea_DOCKINGAREA_RIGHT )
1965 nFreeRowColPixelPos = aDockingWinSize.Width() - aUIElementSize.Width();
1966 }
1967
1968 if (( DockingArea == DockingArea_DOCKINGAREA_TOP ) ||
1969 ( DockingArea == DockingArea_DOCKINGAREA_BOTTOM ))
1970 {
1971 rVirtualPos = ::Point( 0, nNextFreeRowCol );
1972 if ( DockingArea == DockingArea_DOCKINGAREA_TOP )
1973 rPixelPos = ::Point( 0, nFreeRowColPixelPos );
1974 else
1975 rPixelPos = ::Point( 0, aDockingWinSize.Height() - nFreeRowColPixelPos );
1976 }
1977 else
1978 {
1979 rVirtualPos = ::Point( nNextFreeRowCol, 0 );
1980 rPixelPos = ::Point( aDockingWinSize.Width() - nFreeRowColPixelPos, 0 );
1981 }
1982 }
1983
1984 ::Size LayoutManager::implts_getContainerWindowOutputSize()
1985 {
1986 ReadGuard aReadLock( m_aLock );
1987 Reference< css::awt::XWindow > xContainerWindow = m_xContainerWindow;
1988 ::Size aContainerWinSize;
1989 Window* pContainerWindow( 0 );
1990 aReadLock.unlock();
1991
1992 // Retrieve output size from container Window
1993 vos::OGuard aGuard( Application::GetSolarMutex() );
1994 pContainerWindow = VCLUnoHelper::GetWindow( xContainerWindow );
1995 if ( pContainerWindow )
1996 return pContainerWindow->GetOutputSizePixel();
1997 else
1998 return ::Size();
1999 }
2000
2001 void LayoutManager::implts_sortUIElements()
2002 {
2003 WriteGuard aWriteLock( m_aLock );
2004 UIElementVector::iterator pIterStart = m_aUIElements.begin();
2005 UIElementVector::iterator pIterEnd = m_aUIElements.end();
2006
2007 std::stable_sort( pIterStart, pIterEnd ); // first created element should first
2008
2009 // We have to reset our temporary flags.
2010 UIElementVector::iterator pIter;
2011 for ( pIter = m_aUIElements.begin(); pIter != m_aUIElements.end(); pIter++ )
2012 {
2013 // why check, just set it to false
2014 //if ( pIter->m_bUserActive )
2015 pIter->m_bUserActive = sal_False;
2016 }
2017
2018 #ifdef DBG_UTIL
2019 implts_checkElementContainer();
2020 #endif
2021 aWriteLock.unlock();
2022 }
2023
2024 void LayoutManager::implts_getDockingAreaElementInfos( DockingArea eDockingArea, std::vector< SingleRowColumnWindowData >& rRowColumnsWindowData )
2025 {
2026 std::vector< UIElement > aWindowVector;
2027
2028 if (( eDockingArea < DockingArea_DOCKINGAREA_TOP ) ||
2029 ( eDockingArea > DockingArea_DOCKINGAREA_RIGHT ))
2030 eDockingArea = DockingArea_DOCKINGAREA_TOP;
2031
2032 Reference< css::awt::XWindow > xDockAreaWindow;
2033
2034 /* SAFE AREA ----------------------------------------------------------------------------------------------- */
2035 ReadGuard aReadLock( m_aLock );
2036 aWindowVector.reserve(m_aUIElements.size());
2037 xDockAreaWindow = m_xDockAreaWindows[eDockingArea];
2038 UIElementVector::iterator pIter;
2039 for ( pIter = m_aUIElements.begin(); pIter != m_aUIElements.end(); pIter++ )
2040 {
2041 if ( pIter->m_aDockedData.m_nDockedArea == eDockingArea && pIter->m_bVisible && !pIter->m_bFloating )
2042 {
2043 Reference< XUIElement > xUIElement( pIter->m_xUIElement );
2044 if ( xUIElement.is() )
2045 {
2046 Reference< css::awt::XWindow > xWindow( xUIElement->getRealInterface(), UNO_QUERY );
2047 Reference< css::awt::XDockableWindow > xDockWindow( xWindow, UNO_QUERY );
2048 if ( xDockWindow.is() )
2049 {
2050 // docked windows
2051 aWindowVector.push_back( *pIter );
2052 }
2053 }
2054 }
2055 }
2056 aReadLock.unlock();
2057 /* SAFE AREA ----------------------------------------------------------------------------------------------- */
2058
2059 rRowColumnsWindowData.clear();
2060
2061 // Collect data from windows that are on the same row/column
2062 sal_Int32 j;
2063 sal_Int32 nIndex( 0 );
2064 sal_Int32 nLastPos( 0 );
2065 sal_Int32 nCurrPos( -1 );
2066 sal_Int32 nLastRowColPixelPos( 0 );
2067 css::awt::Rectangle aDockAreaRect;
2068
2069 if ( xDockAreaWindow.is() )
2070 aDockAreaRect = xDockAreaWindow->getPosSize();
2071
2072 if ( eDockingArea == DockingArea_DOCKINGAREA_TOP )
2073 nLastRowColPixelPos = 0;
2074 else if ( eDockingArea == DockingArea_DOCKINGAREA_BOTTOM )
2075 nLastRowColPixelPos = aDockAreaRect.Height;
2076 else if ( eDockingArea == DockingArea_DOCKINGAREA_LEFT )
2077 nLastRowColPixelPos = 0;
2078 else
2079 nLastRowColPixelPos = aDockAreaRect.Width;
2080
2081 const sal_uInt32 nCount = aWindowVector.size();
2082 for ( j = 0; j < sal_Int32( nCount); j++ )
2083 {
2084 const UIElement& rElement = aWindowVector[j];
2085 Reference< css::awt::XWindow > xWindow;
2086 Reference< XUIElement > xUIElement( rElement.m_xUIElement );
2087 css::awt::Rectangle aPosSize;
2088 if ( !lcl_checkUIElement(xUIElement,aPosSize,xWindow) )
2089 continue;
2090 if (( eDockingArea == DockingArea_DOCKINGAREA_TOP ) ||
2091 ( eDockingArea == DockingArea_DOCKINGAREA_BOTTOM ))
2092 {
2093 if ( nCurrPos == -1 )
2094 {
2095 nCurrPos = rElement.m_aDockedData.m_aPos.Y();
2096 nLastPos = 0;
2097
2098 SingleRowColumnWindowData aRowColumnWindowData;
2099 aRowColumnWindowData.nRowColumn = nCurrPos;
2100 rRowColumnsWindowData.push_back( aRowColumnWindowData );
2101 }
2102
2103 sal_Int32 nSpace( 0 );
2104 if ( rElement.m_aDockedData.m_aPos.Y() != nCurrPos )
2105 {
2106 if ( eDockingArea == DockingArea_DOCKINGAREA_TOP )
2107 nLastRowColPixelPos += rRowColumnsWindowData[nIndex].nStaticSize;
2108 else
2109 nLastRowColPixelPos -= rRowColumnsWindowData[nIndex].nStaticSize;
2110 ++nIndex;
2111 nLastPos = 0;
2112 nCurrPos = rElement.m_aDockedData.m_aPos.Y();
2113 SingleRowColumnWindowData aRowColumnWindowData;
2114 aRowColumnWindowData.nRowColumn = nCurrPos;
2115 rRowColumnsWindowData.push_back( aRowColumnWindowData );
2116 }
2117
2118 // Calc space before an element and store it
2119 nSpace = ( rElement.m_aDockedData.m_aPos.X() - nLastPos );
2120 if ( rElement.m_aDockedData.m_aPos.X() >= nLastPos )
2121 {
2122 rRowColumnsWindowData[nIndex].nSpace += nSpace;
2123 nLastPos = rElement.m_aDockedData.m_aPos.X() + aPosSize.Width;
2124 }
2125 else
2126 {
2127 nSpace = 0;
2128 nLastPos += aPosSize.Width;
2129 }
2130 rRowColumnsWindowData[nIndex].aRowColumnSpace.push_back( nSpace );
2131
2132 rRowColumnsWindowData[nIndex].aRowColumnWindows.push_back( xWindow );
2133 rRowColumnsWindowData[nIndex].aUIElementNames.push_back( rElement.m_aName );
2134 rRowColumnsWindowData[nIndex].aRowColumnWindowSizes.push_back(
2135 css::awt::Rectangle( rElement.m_aDockedData.m_aPos.X(),
2136 rElement.m_aDockedData.m_aPos.Y(),
2137 aPosSize.Width,
2138 aPosSize.Height ));
2139 if ( rRowColumnsWindowData[nIndex].nStaticSize < aPosSize.Height )
2140 rRowColumnsWindowData[nIndex].nStaticSize = aPosSize.Height;
2141 if ( eDockingArea == DockingArea_DOCKINGAREA_TOP )
2142 rRowColumnsWindowData[nIndex].aRowColumnRect = css::awt::Rectangle( 0, nLastRowColPixelPos,
2143 aDockAreaRect.Width, aPosSize.Height );
2144 else
2145 rRowColumnsWindowData[nIndex].aRowColumnRect = css::awt::Rectangle( 0, ( nLastRowColPixelPos - aPosSize.Height ),
2146 aDockAreaRect.Width, aPosSize.Height );
2147 rRowColumnsWindowData[nIndex].nVarSize += aPosSize.Width + nSpace;
2148 }
2149 else
2150 {
2151 if ( nCurrPos == -1 )
2152 {
2153 nCurrPos = rElement.m_aDockedData.m_aPos.X();
2154 nLastPos = 0;
2155
2156 SingleRowColumnWindowData aRowColumnWindowData;
2157 aRowColumnWindowData.nRowColumn = nCurrPos;
2158 rRowColumnsWindowData.push_back( aRowColumnWindowData );
2159 }
2160
2161 sal_Int32 nSpace( 0 );
2162 if ( rElement.m_aDockedData.m_aPos.X() != nCurrPos )
2163 {
2164 if ( eDockingArea == DockingArea_DOCKINGAREA_LEFT )
2165 nLastRowColPixelPos += rRowColumnsWindowData[nIndex].nStaticSize;
2166 else
2167 nLastRowColPixelPos -= rRowColumnsWindowData[nIndex].nStaticSize;
2168 ++nIndex;
2169 nLastPos = 0;
2170 nCurrPos = rElement.m_aDockedData.m_aPos.X();
2171 SingleRowColumnWindowData aRowColumnWindowData;
2172 aRowColumnWindowData.nRowColumn = nCurrPos;
2173 rRowColumnsWindowData.push_back( aRowColumnWindowData );
2174 }
2175
2176 // Calc space before an element and store it
2177 nSpace = ( rElement.m_aDockedData.m_aPos.Y() - nLastPos );
2178 if ( rElement.m_aDockedData.m_aPos.Y() > nLastPos )
2179 {
2180 rRowColumnsWindowData[nIndex].nSpace += nSpace;
2181 nLastPos = rElement.m_aDockedData.m_aPos.Y() + aPosSize.Height;
2182 }
2183 else
2184 {
2185 nSpace = 0;
2186 nLastPos += aPosSize.Height;
2187 }
2188 rRowColumnsWindowData[nIndex].aRowColumnSpace.push_back( nSpace );
2189
2190 rRowColumnsWindowData[nIndex].aRowColumnWindows.push_back( xWindow );
2191 rRowColumnsWindowData[nIndex].aUIElementNames.push_back( rElement.m_aName );
2192 rRowColumnsWindowData[nIndex].aRowColumnWindowSizes.push_back(
2193 css::awt::Rectangle( rElement.m_aDockedData.m_aPos.X(),
2194 rElement.m_aDockedData.m_aPos.Y(),
2195 aPosSize.Width,
2196 aPosSize.Height ));
2197 if ( rRowColumnsWindowData[nIndex].nStaticSize < aPosSize.Width )
2198 rRowColumnsWindowData[nIndex].nStaticSize = aPosSize.Width;
2199 if ( eDockingArea == DockingArea_DOCKINGAREA_LEFT )
2200 rRowColumnsWindowData[nIndex].aRowColumnRect = css::awt::Rectangle( nLastRowColPixelPos, 0,
2201 aPosSize.Width, aDockAreaRect.Height );
2202 else
2203 rRowColumnsWindowData[nIndex].aRowColumnRect = css::awt::Rectangle( ( nLastRowColPixelPos - aPosSize.Width ), 0,
2204 aPosSize.Width, aDockAreaRect.Height );
2205 rRowColumnsWindowData[nIndex].nVarSize += aPosSize.Height + nSpace;
2206 }
2207 }
2208 }
2209
2210 void LayoutManager::implts_getDockingAreaElementInfoOnSingleRowCol( DockingArea eDockingArea, sal_Int32 nRowCol, SingleRowColumnWindowData& rRowColumnWindowData )
2211 {
2212 std::vector< UIElement > aWindowVector;
2213
2214 if (( eDockingArea < DockingArea_DOCKINGAREA_TOP ) ||
2215 ( eDockingArea > DockingArea_DOCKINGAREA_RIGHT ))
2216 eDockingArea = DockingArea_DOCKINGAREA_TOP;
2217
2218 sal_Bool bHorzDockArea = (( eDockingArea == DockingArea_DOCKINGAREA_TOP ) ||
2219 ( eDockingArea == DockingArea_DOCKINGAREA_BOTTOM ));
2220
2221 /* SAFE AREA ----------------------------------------------------------------------------------------------- */
2222 ReadGuard aReadLock( m_aLock );
2223 UIElementVector::iterator pIter;
2224 UIElementVector::iterator pEnd = m_aUIElements.end();
2225 for ( pIter = m_aUIElements.begin(); pIter != pEnd; pIter++ )
2226 {
2227 if ( pIter->m_aDockedData.m_nDockedArea == eDockingArea )
2228 {
2229 sal_Bool bSameRowCol = bHorzDockArea ?
2230 ( pIter->m_aDockedData.m_aPos.Y() == nRowCol ) :
2231 ( pIter->m_aDockedData.m_aPos.X() == nRowCol );
2232 Reference< XUIElement > xUIElement( pIter->m_xUIElement );
2233
2234 if ( bSameRowCol && xUIElement.is() )
2235 {
2236 Reference< css::awt::XWindow > xWindow( xUIElement->getRealInterface(), UNO_QUERY );
2237 if ( xWindow.is() )
2238 {
2239 vos::OGuard aGuard( Application::GetSolarMutex() );
2240 Window* pWindow = VCLUnoHelper::GetWindow( xWindow );
2241 Reference< css::awt::XDockableWindow > xDockWindow( xWindow, UNO_QUERY );
2242 if ( pWindow && pIter->m_bVisible && xDockWindow.is() && !pIter->m_bFloating )
2243 {
2244 // docked windows
2245 aWindowVector.push_back( *pIter );
2246 }
2247 }
2248 }
2249 }
2250 }
2251 aReadLock.unlock();
2252 /* SAFE AREA ----------------------------------------------------------------------------------------------- */
2253
2254 // Initialize structure
2255 rRowColumnWindowData.aUIElementNames.clear();
2256 rRowColumnWindowData.aRowColumnWindows.clear();
2257 rRowColumnWindowData.aRowColumnWindowSizes.clear();
2258 rRowColumnWindowData.aRowColumnSpace.clear();
2259 rRowColumnWindowData.nVarSize = 0;
2260 rRowColumnWindowData.nStaticSize = 0;
2261 rRowColumnWindowData.nSpace = 0;
2262 rRowColumnWindowData.nRowColumn = nRowCol;
2263
2264 // Collect data from windows that are on the same row/column
2265 sal_Int32 j;
2266 sal_Int32 nLastPos( 0 );
2267
2268 const sal_uInt32 nCount = aWindowVector.size();
2269 for ( j = 0; j < sal_Int32( nCount); j++ )
2270 {
2271 const UIElement& rElement = aWindowVector[j];
2272 Reference< css::awt::XWindow > xWindow;
2273 Reference< XUIElement > xUIElement( rElement.m_xUIElement );
2274 css::awt::Rectangle aPosSize;
2275 if ( !lcl_checkUIElement(xUIElement,aPosSize,xWindow) )
2276 continue;
2277
2278 sal_Int32 nSpace;
2279 if (( eDockingArea == DockingArea_DOCKINGAREA_TOP ) ||
2280 ( eDockingArea == DockingArea_DOCKINGAREA_BOTTOM ))
2281 {
2282 nSpace = ( rElement.m_aDockedData.m_aPos.X() - nLastPos );
2283
2284 // Calc space before an element and store it
2285 if ( rElement.m_aDockedData.m_aPos.X() > nLastPos )
2286 rRowColumnWindowData.nSpace += nSpace;
2287 else
2288 nSpace = 0;
2289
2290 nLastPos = rElement.m_aDockedData.m_aPos.X() + aPosSize.Width;
2291
2292
2293 rRowColumnWindowData.aRowColumnWindowSizes.push_back(
2294 css::awt::Rectangle( rElement.m_aDockedData.m_aPos.X(),
2295 rElement.m_aDockedData.m_aPos.Y(),
2296 aPosSize.Width,
2297 aPosSize.Height ));
2298 if ( rRowColumnWindowData.nStaticSize < aPosSize.Height )
2299 rRowColumnWindowData.nStaticSize = aPosSize.Height;
2300 rRowColumnWindowData.nVarSize += aPosSize.Width;
2301 }
2302 else
2303 {
2304 // Calc space before an element and store it
2305 nSpace = ( rElement.m_aDockedData.m_aPos.Y() - nLastPos );
2306 if ( rElement.m_aDockedData.m_aPos.Y() > nLastPos )
2307 rRowColumnWindowData.nSpace += nSpace;
2308 else
2309 nSpace = 0;
2310
2311 nLastPos = rElement.m_aDockedData.m_aPos.Y() + aPosSize.Height;
2312
2313 rRowColumnWindowData.aRowColumnWindowSizes.push_back(
2314 css::awt::Rectangle( rElement.m_aDockedData.m_aPos.X(),
2315 rElement.m_aDockedData.m_aPos.Y(),
2316 aPosSize.Width,
2317 aPosSize.Height ));
2318 if ( rRowColumnWindowData.nStaticSize < aPosSize.Width )
2319 rRowColumnWindowData.nStaticSize = aPosSize.Width;
2320 rRowColumnWindowData.nVarSize += aPosSize.Height;
2321 }
2322
2323 rRowColumnWindowData.aUIElementNames.push_back( rElement.m_aName );
2324 rRowColumnWindowData.aRowColumnWindows.push_back( xWindow );
2325 rRowColumnWindowData.aRowColumnSpace.push_back( nSpace );
2326 rRowColumnWindowData.nVarSize += nSpace;
2327 }
2328 }
2329
2330 ::Rectangle LayoutManager::implts_determineFrontDockingRect(
2331 DockingArea eDockingArea,
2332 sal_Int32 nRowCol,
2333 const ::Rectangle& rDockedElementRect,
2334 const ::rtl::OUString& rMovedElementName,
2335 const ::Rectangle& rMovedElementRect )
2336 {
2337 SingleRowColumnWindowData aRowColumnWindowData;
2338
2339 sal_Bool bHorzDockArea = (( eDockingArea == DockingArea_DOCKINGAREA_TOP ) ||
2340 ( eDockingArea == DockingArea_DOCKINGAREA_BOTTOM ));
2341
2342 implts_getDockingAreaElementInfoOnSingleRowCol( eDockingArea, nRowCol, aRowColumnWindowData );
2343 if ( aRowColumnWindowData.aRowColumnWindows.empty() )
2344 return rMovedElementRect;
2345 else
2346 {
2347 sal_Int32 nSpace( 0 );
2348 ::Rectangle aFrontDockingRect( rMovedElementRect );
2349 const sal_uInt32 nCount = aRowColumnWindowData.aRowColumnWindows.size();
2350 for ( sal_uInt32 i = 0; i < nCount; i++ )
2351 {
2352 if ( bHorzDockArea )
2353 {
2354 if ( aRowColumnWindowData.aRowColumnWindowSizes[i].X >= rDockedElementRect.Left() )
2355 {
2356 nSpace += aRowColumnWindowData.aRowColumnSpace[i];
2357 break;
2358 }
2359 else if ( aRowColumnWindowData.aUIElementNames[i] == rMovedElementName )
2360 nSpace += aRowColumnWindowData.aRowColumnWindowSizes[i].Width +
2361 aRowColumnWindowData.aRowColumnSpace[i];
2362 else
2363 nSpace = 0;
2364 }
2365 else
2366 {
2367 if ( aRowColumnWindowData.aRowColumnWindowSizes[i].Y >= rDockedElementRect.Top() )
2368 {
2369 nSpace += aRowColumnWindowData.aRowColumnSpace[i];
2370 break;
2371 }
2372 else if ( aRowColumnWindowData.aUIElementNames[i] == rMovedElementName )
2373 nSpace += aRowColumnWindowData.aRowColumnWindowSizes[i].Height +
2374 aRowColumnWindowData.aRowColumnSpace[i];
2375 else
2376 nSpace = 0;
2377 }
2378 }
2379
2380 if ( nSpace > 0 )
2381 {
2382 sal_Int32 nMove = std::min( nSpace, static_cast<sal_Int32>(aFrontDockingRect.getWidth()) );
2383 if ( bHorzDockArea )
2384 aFrontDockingRect.Move( -nMove, 0 );
2385 else
2386 aFrontDockingRect.Move( 0, -nMove );
2387 }
2388
2389 return aFrontDockingRect;
2390 }
2391 }
2392
2393 ::Rectangle LayoutManager::implts_getWindowRectFromRowColumn(
2394 ::com::sun::star::ui::DockingArea DockingArea,
2395 const SingleRowColumnWindowData& rRowColumnWindowData,
2396 const ::Point& rMousePos,
2397 const rtl::OUString& rExcludeElementName )
2398 {
2399 ::Rectangle aWinRect;
2400
2401 if (( DockingArea < DockingArea_DOCKINGAREA_TOP ) ||
2402 ( DockingArea > DockingArea_DOCKINGAREA_RIGHT ))
2403 DockingArea = DockingArea_DOCKINGAREA_TOP;
2404
2405 if ( rRowColumnWindowData.aRowColumnWindows.empty() )
2406 return aWinRect;
2407 else
2408 {
2409 ReadGuard aReadLock( m_aLock );
2410 Reference< css::awt::XWindow > xContainerWindow = m_xContainerWindow;
2411 Reference< css::awt::XWindow > xDockingAreaWindow = m_xDockAreaWindows[DockingArea];
2412 aReadLock.unlock();
2413
2414 // Calc correct position of the column/row rectangle to be able to compare it with mouse pos/tracking rect
2415 vos::OGuard aGuard( Application::GetSolarMutex() );
2416
2417 // Retrieve output size from container Window
2418 Window* pContainerWindow( VCLUnoHelper::GetWindow( xContainerWindow ));
2419 Window* pDockingAreaWindow( VCLUnoHelper::GetWindow( xDockingAreaWindow ));
2420 if ( pDockingAreaWindow && pContainerWindow )
2421 {
2422 const sal_uInt32 nCount = rRowColumnWindowData.aRowColumnWindows.size();
2423 for ( sal_uInt32 i = 0; i < nCount; i++ )
2424 {
2425 css::awt::Rectangle aWindowRect = rRowColumnWindowData.aRowColumnWindows[i]->getPosSize();
2426 ::Rectangle aRect( aWindowRect.X, aWindowRect.Y, aWindowRect.X+aWindowRect.Width, aWindowRect.Y+aWindowRect.Height );
2427 aRect.SetPos( pContainerWindow->ScreenToOutputPixel( pDockingAreaWindow->OutputToScreenPixel( aRect.TopLeft() )));
2428 if ( aRect.IsInside( rMousePos ))
2429 {
2430 // Check if we have found the excluded element. If yes, we have to provide an empty rectangle.
2431 // We prevent that a toolbar cannot be moved when the mouse pointer is inside its own rectangle!
2432 if ( rExcludeElementName != rRowColumnWindowData.aUIElementNames[i] )
2433 return aRect;
2434 else
2435 break;
2436 }
2437 }
2438 }
2439 }
2440
2441 return aWinRect;
2442 }
2443
2444 framework::LayoutManager::DockingOperation
2445 LayoutManager::implts_determineDockingOperation(
2446 ::com::sun::star::ui::DockingArea DockingArea,
2447 const ::Rectangle& rRowColRect,
2448 const Point& rMousePos )
2449 {
2450 const sal_Int32 nHorzVerticalRegionSize = 6;
2451 const sal_Int32 nHorzVerticalMoveRegion = 4;
2452
2453 if ( rRowColRect.IsInside( rMousePos ))
2454 {
2455 if (( DockingArea == DockingArea_DOCKINGAREA_TOP ) ||
2456 ( DockingArea == DockingArea_DOCKINGAREA_BOTTOM ))
2457 {
2458 sal_Int32 nRegion = rRowColRect.getHeight() / nHorzVerticalRegionSize;
2459 sal_Int32 nPosY = rRowColRect.Top() + nRegion;
2460
2461 if ( rMousePos.Y() < nPosY )
2462 return ( DockingArea == DockingArea_DOCKINGAREA_TOP ) ? DOCKOP_BEFORE_COLROW : DOCKOP_AFTER_COLROW;
2463 else if ( rMousePos.Y() < ( nPosY + nRegion*nHorzVerticalMoveRegion ))
2464 return DOCKOP_ON_COLROW;
2465 else
2466 return ( DockingArea == DockingArea_DOCKINGAREA_TOP ) ? DOCKOP_AFTER_COLROW : DOCKOP_BEFORE_COLROW;
2467 }
2468 else
2469 {
2470 sal_Int32 nRegion = rRowColRect.getWidth() / nHorzVerticalRegionSize;
2471 sal_Int32 nPosX = rRowColRect.Left() + nRegion;
2472
2473 if ( rMousePos.X() < nPosX )
2474 return ( DockingArea == DockingArea_DOCKINGAREA_LEFT ) ? DOCKOP_BEFORE_COLROW : DOCKOP_AFTER_COLROW;
2475 else if ( rMousePos.X() < ( nPosX + nRegion*nHorzVerticalMoveRegion ))
2476 return DOCKOP_ON_COLROW;
2477 else
2478 return ( DockingArea == DockingArea_DOCKINGAREA_LEFT ) ? DOCKOP_AFTER_COLROW : DOCKOP_BEFORE_COLROW;
2479 }
2480 }
2481 else
2482 return DOCKOP_ON_COLROW;
2483 }
2484
2485 ::Rectangle LayoutManager::implts_calcTrackingAndElementRect(
2486 ::com::sun::star::ui::DockingArea eDockingArea,
2487 sal_Int32 nRowCol,
2488 UIElement& rUIElement,
2489 const ::Rectangle& rTrackingRect,
2490 const ::Rectangle& rRowColumnRect,
2491 const ::Size& rContainerWinSize )
2492 {
2493 sal_Bool bHorizontalDockArea( ( eDockingArea == DockingArea_DOCKINGAREA_TOP ) ||
2494 ( eDockingArea == DockingArea_DOCKINGAREA_BOTTOM ));
2495
2496 sal_Int32 nTopDockingAreaSize( implts_getTopBottomDockingAreaSizes().Width() );
2497 sal_Int32 nBottomDockingAreaSize( implts_getTopBottomDockingAreaSizes().Height() );
2498
2499 ::Size aStatusBarSize( implts_getStatusBarSize() );
2500 sal_Int32 nMaxLeftRightDockAreaSize = rContainerWinSize.Height() -
2501 nTopDockingAreaSize -
2502 nBottomDockingAreaSize -
2503 aStatusBarSize.Height();
2504
2505 ::Rectangle aTrackingRect( rTrackingRect );
2506 if ( bHorizontalDockArea )
2507 {
2508 sal_Int32 nPosX( std::max( sal_Int32( rTrackingRect.Left()), sal_Int32( 0 )));
2509 if (( nPosX + rTrackingRect.getWidth()) > rContainerWinSize.Width() )
2510 nPosX = std::min( nPosX,
2511 std::max( sal_Int32( rContainerWinSize.Width() - rTrackingRect.getWidth() ),
2512 sal_Int32( 0 )));
2513
2514 sal_Int32 nSize = std::min( rContainerWinSize.Width(), rTrackingRect.getWidth() );
2515
2516 aTrackingRect.SetPos( ::Point( nPosX, rRowColumnRect.Top() ));
2517 aTrackingRect.setWidth( nSize );
2518 aTrackingRect.setHeight( rRowColumnRect.getHeight() );
2519
2520 // Set virtual position
2521 rUIElement.m_aDockedData.m_aPos.X() = nPosX;
2522 rUIElement.m_aDockedData.m_aPos.Y() = nRowCol;
2523 }
2524 else
2525 {
2526 sal_Int32 nMaxDockingAreaHeight = std::max( sal_Int32( 0 ),
2527 sal_Int32( nMaxLeftRightDockAreaSize ));
2528
2529 sal_Int32 nPosY( std::max( sal_Int32( aTrackingRect.Top()), sal_Int32( nTopDockingAreaSize )));
2530 if (( nPosY + aTrackingRect.getHeight()) > ( nTopDockingAreaSize + nMaxDockingAreaHeight ))
2531 nPosY = std::min( nPosY,
2532 std::max( sal_Int32( nTopDockingAreaSize + ( nMaxDockingAreaHeight - aTrackingRect.getHeight() )),
2533 sal_Int32( nTopDockingAreaSize )));
2534
2535 sal_Int32 nSize = std::min( nMaxDockingAreaHeight, static_cast<sal_Int32>(aTrackingRect.getHeight()) );
2536
2537 aTrackingRect.SetPos( ::Point( rRowColumnRect.Left(), nPosY ));
2538 aTrackingRect.setWidth( rRowColumnRect.getWidth() );
2539 aTrackingRect.setHeight( nSize );
2540
2541 ReadGuard aReadLock( m_aLock );
2542 Reference< css::awt::XWindow > xDockingAreaWindow = m_xDockAreaWindows[eDockingArea];
2543 Reference< css::awt::XWindow > xContainerWindow = m_xContainerWindow;
2544 aReadLock.unlock();
2545
2546 sal_Int32 nDockPosY( 0 );
2547 Window* pDockingAreaWindow( 0 );
2548 Window* pContainerWindow( 0 );
2549 {
2550 vos::OGuard aGuard( Application::GetSolarMutex() );
2551 pDockingAreaWindow = VCLUnoHelper::GetWindow( xDockingAreaWindow );
2552 pContainerWindow = VCLUnoHelper::GetWindow( xContainerWindow );
2553 nDockPosY = pDockingAreaWindow->ScreenToOutputPixel(
2554 pContainerWindow->OutputToScreenPixel( ::Point( 0, nPosY ))).Y();
2555 }
2556
2557 // Set virtual position
2558 rUIElement.m_aDockedData.m_aPos.X() = nRowCol;
2559 rUIElement.m_aDockedData.m_aPos.Y() = nDockPosY;
2560 }
2561
2562 return aTrackingRect;
2563 }
2564
2565 void implts_setTrackingRect( DockingArea eDockingArea, const Point& rMousePos, ::Rectangle& rTrackingRect )
2566 {
2567 sal_Bool bHorizontalDockArea( ( eDockingArea == DockingArea_DOCKINGAREA_TOP ) ||
2568 ( eDockingArea == DockingArea_DOCKINGAREA_BOTTOM ));
2569
2570 ::Point aPoint = rTrackingRect.TopLeft();
2571 if ( bHorizontalDockArea )
2572 aPoint.X() = rMousePos.X();
2573 else
2574 aPoint.Y() = rMousePos.Y();
2575 rTrackingRect.SetPos( aPoint );
2576 }
2577
2578 void LayoutManager::implts_calcDockingPosSize(
2579 UIElement& rUIElement,
2580 DockingOperation& rDockingOperation,
2581 ::Rectangle& rTrackingRect,
2582 const Point& rMousePos )
2583 {
2584 ReadGuard aReadLock( m_aLock );
2585 Reference< css::awt::XWindow > xContainerWindow = m_xContainerWindow;
2586 ::Size aContainerWinSize;
2587 Window* pContainerWindow( 0 );
2588 aReadLock.unlock();
2589
2590 {
2591 // Retrieve output size from container Window
2592 vos::OGuard aGuard( Application::GetSolarMutex() );
2593 pContainerWindow = VCLUnoHelper::GetWindow( xContainerWindow );
2594 aContainerWinSize = pContainerWindow->GetOutputSizePixel();
2595 }
2596
2597 if ( !rUIElement.m_xUIElement.is() )
2598 {
2599 rTrackingRect = ::Rectangle();
2600 return;
2601 }
2602
2603 Window* pDockWindow( 0 );
2604 Window* pDockingAreaWindow( 0 );
2605 ToolBox* pToolBox( 0 );
2606 Reference< css::awt::XWindow > xWindow( rUIElement.m_xUIElement->getRealInterface(), UNO_QUERY );
2607 Reference< css::awt::XWindow > xDockingAreaWindow;
2608 ::Rectangle aTrackingRect( rTrackingRect );
2609 ::com::sun::star::ui::DockingArea eDockedArea( (::com::sun::star::ui::DockingArea)rUIElement.m_aDockedData.m_nDockedArea );
2610 sal_Int32 nTopDockingAreaSize( implts_getTopBottomDockingAreaSizes().Width() );
2611 sal_Int32 nBottomDockingAreaSize( implts_getTopBottomDockingAreaSizes().Height() );
2612 sal_Bool bHorizontalDockArea( ( eDockedArea == DockingArea_DOCKINGAREA_TOP ) ||
2613 ( eDockedArea == DockingArea_DOCKINGAREA_BOTTOM ));
2614 ::Size aStatusBarSize( implts_getStatusBarSize() );
2615 sal_Int32 nMaxLeftRightDockAreaSize = aContainerWinSize.Height() -
2616 nTopDockingAreaSize -
2617 nBottomDockingAreaSize -
2618 aStatusBarSize.Height();
2619 ::Rectangle aDockingAreaRect;
2620
2621 aReadLock.lock();
2622 xDockingAreaWindow = m_xDockAreaWindows[eDockedArea];
2623 aReadLock.unlock();
2624
2625 {
2626 vos::OGuard aGuard( Application::GetSolarMutex() );
2627 pDockingAreaWindow = VCLUnoHelper::GetWindow( xDockingAreaWindow );
2628 pDockWindow = VCLUnoHelper::GetWindow( xWindow );
2629 if ( pDockWindow && pDockWindow->GetType() == WINDOW_TOOLBOX )
2630 pToolBox = (ToolBox *)pDockWindow;
2631
2632 aDockingAreaRect = ::Rectangle( pDockingAreaWindow->GetPosPixel(), pDockingAreaWindow->GetSizePixel() );
2633 if ( pToolBox )
2634 {
2635 // docked toolbars always have one line
2636 ::Size aSize = pToolBox->CalcWindowSizePixel( 1, ImplConvertAlignment( sal_Int16( eDockedArea )) );
2637 aTrackingRect.SetSize( ::Size( aSize.Width(), aSize.Height() ));
2638 }
2639 }
2640
2641 // default docking operation, dock on the given row/column
2642 sal_Bool bOpOutsideOfDockingArea( !aDockingAreaRect.IsInside( rMousePos ));
2643 std::vector< SingleRowColumnWindowData > aRowColumnsWindowData;
2644
2645 rDockingOperation = DOCKOP_ON_COLROW;
2646 implts_getDockingAreaElementInfos( eDockedArea, aRowColumnsWindowData );
2647
2648 // determine current first row/column and last row/column
2649 sal_Int32 nMaxRowCol( -1 );
2650 sal_Int32 nMinRowCol( SAL_MAX_INT32 );
2651 const sal_uInt32 nCount = aRowColumnsWindowData.size();
2652 for ( sal_uInt32 i = 0; i < nCount; i++ )
2653 {
2654 if ( aRowColumnsWindowData[i].nRowColumn > nMaxRowCol )
2655 nMaxRowCol = aRowColumnsWindowData[i].nRowColumn;
2656 if ( aRowColumnsWindowData[i].nRowColumn < nMinRowCol )
2657 nMinRowCol = aRowColumnsWindowData[i].nRowColumn;
2658 }
2659
2660 if ( !bOpOutsideOfDockingArea )
2661 {
2662 // docking inside our docking area
2663 sal_Int32 nIndex( -1 );
2664 sal_Int32 nRowCol( -1 );
2665 ::Rectangle aWindowRect;
2666 ::Rectangle aRowColumnRect;
2667
2668 const sal_uInt32 nWindowDataCount = aRowColumnsWindowData.size();
2669 for ( sal_uInt32 i = 0; i < nWindowDataCount; i++ )
2670 {
2671 ::Rectangle aRect( aRowColumnsWindowData[i].aRowColumnRect.X,
2672 aRowColumnsWindowData[i].aRowColumnRect.Y,
2673 aRowColumnsWindowData[i].aRowColumnRect.X + aRowColumnsWindowData[i].aRowColumnRect.Width,
2674 aRowColumnsWindowData[i].aRowColumnRect.Y + aRowColumnsWindowData[i].aRowColumnRect.Height );
2675
2676 {
2677 // Calc correct position of the column/row rectangle to be able to compare it with mouse pos/tracking rect
2678 vos::OGuard aGuard( Application::GetSolarMutex() );
2679 aRect.SetPos( pContainerWindow->ScreenToOutputPixel( pDockingAreaWindow->OutputToScreenPixel( aRect.TopLeft() )));
2680 }
2681
2682 sal_Bool bIsInsideRowCol( aRect.IsInside( rMousePos ) );
2683 if ( bIsInsideRowCol )
2684 {
2685 nIndex = i;
2686 nRowCol = aRowColumnsWindowData[i].nRowColumn;
2687 rDockingOperation = implts_determineDockingOperation( eDockedArea, aRect, rMousePos );
2688 aWindowRect = implts_getWindowRectFromRowColumn( eDockedArea, aRowColumnsWindowData[i], rMousePos, rUIElement.m_aName );
2689 aRowColumnRect = aRect;
2690 break;
2691 }
2692 }
2693
2694 OSL_ENSURE( ( nIndex >= 0 ) && ( nRowCol >= 0 ), "Impossible case - no row/column found but mouse pointer is inside our docking area" );
2695 if (( nIndex >= 0 ) && ( nRowCol >= 0 ))
2696 {
2697 if ( rDockingOperation == DOCKOP_ON_COLROW )
2698 {
2699 if ( !aWindowRect.IsEmpty())
2700 {
2701 // Tracking rect is on a row/column and mouse is over a docked toolbar.
2702 // Determine if the tracking rect must be located before/after the docked toolbar.
2703
2704 ::Rectangle aUIElementRect( aWindowRect );
2705 sal_Int32 nMiddle( bHorizontalDockArea ? ( aWindowRect.Left() + aWindowRect.getWidth() / 2 ) :
2706 ( aWindowRect.Top() + aWindowRect.getHeight() / 2 ));
2707 sal_Bool bInsertBefore( bHorizontalDockArea ? ( rMousePos.X() < nMiddle ) : ( rMousePos.Y() < nMiddle ));
2708 if ( bInsertBefore )
2709 {
2710 if ( bHorizontalDockArea )
2711 {
2712 sal_Int32 nSize = ::std::max( sal_Int32( 0 ), std::min( sal_Int32( aContainerWinSize.Width() - aWindowRect.Left() ),
2713 sal_Int32( aTrackingRect.getWidth() )));
2714 if ( nSize == 0 )
2715 nSize = aWindowRect.getWidth();
2716
2717 aUIElementRect.SetSize( ::Size( nSize, aWindowRect.getHeight() ));
2718 aWindowRect = implts_determineFrontDockingRect( eDockedArea, nRowCol, aWindowRect,rUIElement.m_aName, aUIElementRect );
2719
2720 // Set virtual position
2721 rUIElement.m_aDockedData.m_aPos.X() = aWindowRect.Left();
2722 rUIElement.m_aDockedData.m_aPos.Y() = nRowCol;
2723 }
2724 else
2725 {
2726 sal_Int32 nSize = ::std::max( sal_Int32( 0 ), std::min( sal_Int32(
2727 nTopDockingAreaSize + nMaxLeftRightDockAreaSize - aWindowRect.Top() ),
2728 sal_Int32( aTrackingRect.getHeight() )));
2729 if ( nSize == 0 )
2730 nSize = aWindowRect.getHeight();
2731
2732 aUIElementRect.SetSize( ::Size( aWindowRect.getWidth(), nSize ));
2733 aWindowRect = implts_determineFrontDockingRect( eDockedArea, nRowCol, aWindowRect, rUIElement.m_aName, aUIElementRect );
2734
2735 // Set virtual position
2736 sal_Int32 nPosY = pDockingAreaWindow->ScreenToOutputPixel(
2737 pContainerWindow->OutputToScreenPixel( aWindowRect.TopLeft() )).Y();
2738 rUIElement.m_aDockedData.m_aPos.X() = nRowCol;
2739 rUIElement.m_aDockedData.m_aPos.Y() = nPosY;
2740 }
2741
2742 rTrackingRect = aWindowRect;
2743 return;
2744 }
2745 else
2746 {
2747 if ( bHorizontalDockArea )
2748 {
2749 sal_Int32 nSize = ::std::max( sal_Int32( 0 ), std::min( sal_Int32(( aContainerWinSize.Width() ) - aWindowRect.Right() ),
2750 sal_Int32( aTrackingRect.getWidth() )));
2751 if ( nSize == 0 )
2752 {
2753 aUIElementRect.SetPos( ::Point( aContainerWinSize.Width() - aTrackingRect.getWidth(), aWindowRect.Top() ));
2754 aUIElementRect.SetSize( ::Size( aTrackingRect.getWidth(), aWindowRect.getHeight() ));
2755 rUIElement.m_aDockedData.m_aPos.X() = aUIElementRect.Left();
2756 }
2757 else
2758 {
2759 aUIElementRect.SetPos( ::Point( aWindowRect.Right(), aWindowRect.Top() ));
2760 aUIElementRect.SetSize( ::Size( nSize, aWindowRect.getHeight() ));
2761 rUIElement.m_aDockedData.m_aPos.X() = aWindowRect.Right();
2762 }
2763
2764 // Set virtual position
2765 rUIElement.m_aDockedData.m_aPos.Y() = nRowCol;
2766 }
2767 else
2768 {
2769 sal_Int32 nSize = ::std::max( sal_Int32( 0 ), std::min( sal_Int32( nTopDockingAreaSize + nMaxLeftRightDockAreaSize - aWindowRect.Bottom() ),
2770 sal_Int32( aTrackingRect.getHeight() )));
2771 aUIElementRect.SetPos( ::Point( aWindowRect.Left(), aWindowRect.Bottom() ));
2772 aUIElementRect.SetSize( ::Size( aWindowRect.getWidth(), nSize ));
2773
2774 // Set virtual position
2775 sal_Int32 nPosY( 0 );
2776 {
2777 vos::OGuard aGuard( Application::GetSolarMutex() );
2778 nPosY = pDockingAreaWindow->ScreenToOutputPixel(
2779 pContainerWindow->OutputToScreenPixel( aWindowRect.BottomRight() )).Y();
2780 }
2781 rUIElement.m_aDockedData.m_aPos.X() = nRowCol;
2782 rUIElement.m_aDockedData.m_aPos.Y() = nPosY;
2783 }
2784
2785 rTrackingRect = aUIElementRect;
2786 return;
2787 }
2788 }
2789 else
2790 {
2791 implts_setTrackingRect( eDockedArea, rMousePos, aTrackingRect );
2792 rTrackingRect = implts_calcTrackingAndElementRect(
2793 eDockedArea, nRowCol, rUIElement,
2794 aTrackingRect, aRowColumnRect, aContainerWinSize );
2795 return;
2796 }
2797 }
2798 else
2799 {
2800 if ((( nRowCol == nMinRowCol ) && ( rDockingOperation == DOCKOP_BEFORE_COLROW )) ||
2801 (( nRowCol == nMaxRowCol ) && ( rDockingOperation == DOCKOP_AFTER_COLROW )))
2802 bOpOutsideOfDockingArea = sal_True;
2803 else
2804 {
2805 // handle docking before/after a row
2806 implts_setTrackingRect( eDockedArea, rMousePos, aTrackingRect );
2807 rTrackingRect = implts_calcTrackingAndElementRect(
2808 eDockedArea, nRowCol, rUIElement,
2809 aTrackingRect, aRowColumnRect, aContainerWinSize );
2810
2811 sal_Int32 nOffsetX( 0 );
2812 sal_Int32 nOffsetY( 0 );
2813 if ( bHorizontalDockArea )
2814 nOffsetY = sal_Int32( floor( aRowColumnRect.getHeight() / 2 + 0.5 ));
2815 else
2816 nOffsetX = sal_Int32( floor( aRowColumnRect.getWidth() / 2 + 0.5 ));
2817
2818 if ( rDockingOperation == DOCKOP_BEFORE_COLROW )
2819 {
2820 if (( eDockedArea == DockingArea_DOCKINGAREA_TOP ) ||
2821 ( eDockedArea == DockingArea_DOCKINGAREA_LEFT ))
2822 {
2823 // Docking before/after means move track rectangle half column/row.
2824 // As left and top are ordered 0...n instead of right and bottom
2825 // which uses n...0, we have to use negative values for top/left.
2826 nOffsetX *= -1;
2827 nOffsetY *= -1;
2828 }
2829 }
2830 else
2831 {
2832 if (( eDockedArea == DockingArea_DOCKINGAREA_BOTTOM ) ||
2833 ( eDockedArea == DockingArea_DOCKINGAREA_RIGHT ))
2834 {
2835 // Docking before/after means move track rectangle half column/row.
2836 // As left and top are ordered 0...n instead of right and bottom
2837 // which uses n...0, we have to use negative values for top/left.
2838 nOffsetX *= -1;
2839 nOffsetY *= -1;
2840 }
2841 nRowCol++;
2842 }
2843
2844 if ( bHorizontalDockArea )
2845 rUIElement.m_aDockedData.m_aPos.Y() = nRowCol;
2846 else
2847 rUIElement.m_aDockedData.m_aPos.X() = nRowCol;
2848
2849 rTrackingRect.Move( nOffsetX, nOffsetY );
2850 rTrackingRect.SetSize( aTrackingRect.GetSize() );
2851 }
2852 }
2853 }
2854 }
2855
2856 // Docking outside of our docking window area =>
2857 // Users want to dock before/after first/last docked element or to an empty docking area
2858 if ( bOpOutsideOfDockingArea )
2859 {
2860 // set correct size for docking
2861 implts_setTrackingRect( eDockedArea, rMousePos, aTrackingRect );
2862 rTrackingRect = aTrackingRect;
2863
2864 if ( bHorizontalDockArea )
2865 {
2866 sal_Int32 nPosX( std::max( sal_Int32( rTrackingRect.Left()), sal_Int32( 0 )));
2867 if (( nPosX + rTrackingRect.getWidth()) > aContainerWinSize.Width() )
2868 nPosX = std::min( nPosX,
2869 std::max( sal_Int32( aContainerWinSize.Width() - rTrackingRect.getWidth() ),
2870 sal_Int32( 0 )));
2871
2872 sal_Int32 nSize = std::min( aContainerWinSize.Width(), rTrackingRect.getWidth() );
2873 sal_Int32 nDockHeight = std::max( static_cast<sal_Int32>(aDockingAreaRect.getHeight()), sal_Int32( 0 ));
2874 if ( nDockHeight == 0 )
2875 {
2876 sal_Int32 nPosY( std::max( aDockingAreaRect.Top(), aDockingAreaRect.Bottom() ));
2877 if ( eDockedArea == DockingArea_DOCKINGAREA_BOTTOM )
2878 nPosY -= rTrackingRect.getHeight();
2879 rTrackingRect.SetPos( Point( nPosX, nPosY ));
2880 rUIElement.m_aDockedData.m_aPos.Y() = 0;
2881 }
2882 else if ( rMousePos.Y() < ( aDockingAreaRect.Top() + ( nDockHeight / 2 )))
2883 {
2884 rTrackingRect.SetPos( Point( nPosX, aDockingAreaRect.Top() - rTrackingRect.getHeight() ));
2885 if ( eDockedArea == DockingArea_DOCKINGAREA_TOP )
2886 rUIElement.m_aDockedData.m_aPos.Y() = 0;
2887 else
2888 rUIElement.m_aDockedData.m_aPos.Y() = ( nMaxRowCol >= 0 ) ? nMaxRowCol+1 : 0;
2889 rDockingOperation = DOCKOP_BEFORE_COLROW;
2890 }
2891 else
2892 {
2893 rTrackingRect.SetPos( Point( nPosX, aDockingAreaRect.Bottom() ));
2894 if ( eDockedArea == DockingArea_DOCKINGAREA_TOP )
2895 rUIElement.m_aDockedData.m_aPos.Y() = ( nMaxRowCol >= 0 ) ? nMaxRowCol+1 : 0;
2896 else
2897 rUIElement.m_aDockedData.m_aPos.Y() = 0;
2898 rDockingOperation = DOCKOP_AFTER_COLROW;
2899 }
2900 rTrackingRect.setWidth( nSize );
2901
2902 {
2903 vos::OGuard aGuard( Application::GetSolarMutex() );
2904 nPosX = pDockingAreaWindow->ScreenToOutputPixel(
2905 pContainerWindow->OutputToScreenPixel( rTrackingRect.TopLeft() )).X();
2906 }
2907 rUIElement.m_aDockedData.m_aPos.X() = nPosX;
2908 }
2909 else
2910 {
2911 sal_Int32 nMaxDockingAreaHeight = std::max( sal_Int32( 0 ),
2912 sal_Int32( nMaxLeftRightDockAreaSize ));
2913
2914 sal_Int32 nPosY( std::max( sal_Int32( aTrackingRect.Top()), sal_Int32( nTopDockingAreaSize )));
2915 if (( nPosY + aTrackingRect.getHeight()) > ( nTopDockingAreaSize + nMaxDockingAreaHeight ))
2916 nPosY = std::min( nPosY,
2917 std::max( sal_Int32( nTopDockingAreaSize + ( nMaxDockingAreaHeight - aTrackingRect.getHeight() )),
2918 sal_Int32( nTopDockingAreaSize )));
2919
2920 sal_Int32 nSize = std::min( nMaxDockingAreaHeight, static_cast<sal_Int32>(aTrackingRect.getHeight()) );
2921 sal_Int32 nDockWidth = std::max( static_cast<sal_Int32>(aDockingAreaRect.getWidth()), sal_Int32( 0 ));
2922 if ( nDockWidth == 0 )
2923 {
2924 sal_Int32 nPosX( std::max( aDockingAreaRect.Left(), aDockingAreaRect.Right() ));
2925 if ( eDockedArea == DockingArea_DOCKINGAREA_RIGHT )
2926 nPosX -= rTrackingRect.getWidth();
2927 rTrackingRect.SetPos( Point( nPosX, nPosY ));
2928 rUIElement.m_aDockedData.m_aPos.X() = 0;
2929 }
2930 else if ( rMousePos.X() < ( aDockingAreaRect.Left() + ( nDockWidth / 2 )))
2931 {
2932 rTrackingRect.SetPos( Point( aDockingAreaRect.Left() - rTrackingRect.getWidth(), nPosY ));
2933 if ( eDockedArea == DockingArea_DOCKINGAREA_LEFT )
2934 rUIElement.m_aDockedData.m_aPos.X() = 0;
2935 else
2936 rUIElement.m_aDockedData.m_aPos.X() = ( nMaxRowCol >= 0 ) ? nMaxRowCol+1 : 0;
2937 rDockingOperation = DOCKOP_BEFORE_COLROW;
2938 }
2939 else
2940 {
2941 rTrackingRect.SetPos( Point( aDockingAreaRect.Right(), nPosY ));
2942 if ( eDockedArea == DockingArea_DOCKINGAREA_LEFT )
2943 rUIElement.m_aDockedData.m_aPos.X() = ( nMaxRowCol >= 0 ) ? nMaxRowCol+1 : 0;
2944 else
2945 rUIElement.m_aDockedData.m_aPos.X() = 0;
2946 rDockingOperation = DOCKOP_AFTER_COLROW;
2947 }
2948 rTrackingRect.setHeight( nSize );
2949
2950 {
2951 vos::OGuard aGuard( Application::GetSolarMutex() );
2952 nPosY = pDockingAreaWindow->ScreenToOutputPixel(
2953 pContainerWindow->OutputToScreenPixel( rTrackingRect.TopLeft() )).Y();
2954 }
2955 rUIElement.m_aDockedData.m_aPos.Y() = nPosY;
2956 }
2957 }
2958 }
2959
2960 void LayoutManager::implts_renumberRowColumnData(
2961 ::com::sun::star::ui::DockingArea eDockingArea,
2962 DockingOperation /*eDockingOperation*/,
2963 const UIElement& rUIElement )
2964 {
2965 ReadGuard aReadLock( m_aLock );
2966 Reference< XNameAccess > xPersistentWindowState( m_xPersistentWindowState );
2967 aReadLock.unlock();
2968
2969 sal_Bool bHorzDockingArea(( eDockingArea == DockingArea_DOCKINGAREA_TOP ) ||
2970 ( eDockingArea == DockingArea_DOCKINGAREA_BOTTOM ));
2971 sal_Int32 nRowCol( bHorzDockingArea ? rUIElement.m_aDockedData.m_aPos.Y() :
2972 rUIElement.m_aDockedData.m_aPos.X() );
2973
2974 WriteGuard aWriteLock( m_aLock );
2975 UIElementVector::iterator pIter;
2976 for ( pIter = m_aUIElements.begin(); pIter != m_aUIElements.end(); pIter++ )
2977 {
2978 if (( pIter->m_aDockedData.m_nDockedArea == sal_Int16( eDockingArea )) &&
2979 ( pIter->m_aName != rUIElement.m_aName ))
2980 {
2981 // Don't change toolbars without a valid docking position!
2982 if (( pIter->m_aDockedData.m_aPos.X() == SAL_MAX_INT32 ) &&
2983 ( pIter->m_aDockedData.m_aPos.Y() == SAL_MAX_INT32 ))
2984 continue;
2985
2986 sal_Int32 nWindowRowCol = ( bHorzDockingArea ) ?
2987 pIter->m_aDockedData.m_aPos.Y() : pIter->m_aDockedData.m_aPos.X();
2988 if ( nWindowRowCol >= nRowCol )
2989 {
2990 if ( bHorzDockingArea )
2991 pIter->m_aDockedData.m_aPos.Y() += 1;
2992 else
2993 pIter->m_aDockedData.m_aPos.X() += 1;
2994 }
2995 }
2996 }
2997 aWriteLock.unlock();
2998
2999 // We have to change the persistent window state part
3000 if ( xPersistentWindowState.is() )
3001 {
3002 try
3003 {
3004 Sequence< rtl::OUString > aWindowElements = xPersistentWindowState->getElementNames();
3005 for ( sal_Int32 i = 0; i < aWindowElements.getLength(); i++ )
3006 {
3007 if ( rUIElement.m_aName != aWindowElements[i] )
3008 {
3009 try
3010 {
3011 Sequence< PropertyValue > aPropValueSeq;
3012 css::awt::Point aDockedPos;
3013 DockingArea nDockedArea( DockingArea_DOCKINGAREA_DEFAULT );
3014
3015 xPersistentWindowState->getByName( aWindowElements[i] ) >>= aPropValueSeq;
3016 for ( sal_Int32 j = 0; j < aPropValueSeq.getLength(); j++ )
3017 {
3018 if ( aPropValueSeq[j].Name == m_aPropDockingArea )
3019 aPropValueSeq[j].Value >>= nDockedArea;
3020 else if ( aPropValueSeq[j].Name == m_aPropDockPos )
3021 aPropValueSeq[j].Value >>= aDockedPos;
3022 }
3023
3024 // Don't change toolbars without a valid docking position!
3025 if (( aDockedPos.X == SAL_MAX_INT32 ) && ( aDockedPos.Y == SAL_MAX_INT32 ))
3026 continue;
3027
3028 sal_Int32 nWindowRowCol = ( bHorzDockingArea ) ? aDockedPos.Y : aDockedPos.X;
3029 if (( nDockedArea == eDockingArea ) && ( nWindowRowCol >= nRowCol ))
3030 {
3031 if ( bHorzDockingArea )
3032 aDockedPos.Y += 1;
3033 else
3034 aDockedPos.X += 1;
3035
3036 Reference< XNameReplace > xReplace( xPersistentWindowState, UNO_QUERY );
3037 xReplace->replaceByName( aWindowElements[i], makeAny( aPropValueSeq ));
3038 }
3039 }
3040 catch ( Exception& )
3041 {
3042 }
3043 }
3044 }
3045 }
3046 catch ( Exception& )
3047 {
3048 }
3049 }
3050 }
3051
3052 ::Size LayoutManager::implts_getTopBottomDockingAreaSizes()
3053 {
3054 ::Size aSize;
3055 Reference< css::awt::XWindow > xTopDockingAreaWindow;
3056 Reference< css::awt::XWindow > xBottomDockingAreaWindow;
3057
3058 ReadGuard aReadLock( m_aLock );
3059 xTopDockingAreaWindow = m_xDockAreaWindows[DockingArea_DOCKINGAREA_TOP];
3060 xBottomDockingAreaWindow = m_xDockAreaWindows[DockingArea_DOCKINGAREA_BOTTOM];
3061 aReadLock.unlock();
3062
3063 if ( xTopDockingAreaWindow.is() )
3064 aSize.Width() = xTopDockingAreaWindow->getPosSize().Height;
3065 if ( xBottomDockingAreaWindow.is() )
3066 aSize.Height() = xBottomDockingAreaWindow->getPosSize().Height;
3067
3068 return aSize;
3069 }
3070
3071 void LayoutManager::implts_sortActiveElement( const UIElement& )
3072 {
3073 implts_sortUIElements();
3074 }
3075
3076 Reference< XUIElement > LayoutManager::implts_createElement( const rtl::OUString& aName )
3077 {
3078 Reference< ::com::sun::star::ui::XUIElement > xUIElement;
3079
3080 ReadGuard aReadLock( m_aLock );
3081 Sequence< PropertyValue > aPropSeq( 2 );
3082 aPropSeq[0].Name = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Frame" ));
3083 aPropSeq[0].Value <<= m_xFrame;
3084 aPropSeq[1].Name = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Persistent" ));
3085 aPropSeq[1].Value <<= sal_True;
3086
3087 try
3088 {
3089 xUIElement = m_xUIElementFactoryManager->createUIElement( aName, aPropSeq );
3090 }
3091 catch ( NoSuchElementException& )
3092 {
3093 }
3094 catch ( IllegalArgumentException& )
3095 {
3096 }
3097
3098 return xUIElement;
3099 }
3100
3101 Reference< css::awt::XWindowPeer > LayoutManager::implts_createToolkitWindow( const Reference< css::awt::XWindowPeer >& rParent )
3102 {
3103 Reference< css::awt::XWindowPeer > xPeer;
3104 css::uno::Reference< css::awt::XToolkit > xToolkit( m_xSMGR->createInstance( SERVICENAME_VCLTOOLKIT ), css::uno::UNO_QUERY );
3105 if ( xToolkit.is() )
3106 {
3107 // describe window properties.
3108 css::awt::WindowDescriptor aDescriptor;
3109 aDescriptor.Type = css::awt::WindowClass_SIMPLE ;
3110 aDescriptor.WindowServiceName = DECLARE_ASCII("dockingarea") ;
3111 aDescriptor.ParentIndex = -1 ;
3112 aDescriptor.Parent = css::uno::Reference< css::awt::XWindowPeer >( rParent, UNO_QUERY ) ;
3113 aDescriptor.Bounds = css::awt::Rectangle(0,0,0,0) ;
3114 aDescriptor.WindowAttributes = 0 ;
3115
3116 // create a docking area window
3117 xPeer = xToolkit->createWindow( aDescriptor );
3118 }
3119
3120 return xPeer;
3121 }
3122
3123 void LayoutManager::implts_setVisibleState( sal_Bool bShow )
3124 {
3125 /* SAFE AREA ----------------------------------------------------------------------------------------------- */
3126 WriteGuard aWriteLock( m_aLock );
3127 UIElementVector::iterator pIter;
3128 for ( pIter = m_aUIElements.begin(); pIter != m_aUIElements.end(); pIter++ )
3129 pIter->m_bMasterHide = !bShow;
3130 m_aStatusBarElement.m_bMasterHide = !bShow;
3131 aWriteLock.unlock();
3132 /* SAFE AREA ----------------------------------------------------------------------------------------------- */
3133
3134 implts_updateUIElementsVisibleState( bShow );
3135 //implts_doLayout( sal_False );
3136 }
3137
3138 void LayoutManager::implts_updateUIElementsVisibleState( sal_Bool bSetVisible )
3139 {
3140 // notify listeners
3141 css::uno::Any a;
3142 if ( bSetVisible )
3143 implts_notifyListeners( css::frame::LayoutManagerEvents::VISIBLE, a );
3144 else
3145 implts_notifyListeners( css::frame::LayoutManagerEvents::INVISIBLE, a );
3146 std::vector< Reference< css::awt::XWindow > > aWinVector;
3147 sal_Bool bOld;
3148
3149 {
3150 WriteGuard aWriteLock( m_aLock );
3151 m_bDoLayout = sal_True;
3152 bOld = m_bDoLayout;
3153 }
3154
3155 ReadGuard aReadLock( m_aLock );
3156 aWinVector.reserve(m_aUIElements.size());
3157 UIElementVector::iterator pIter;
3158 for ( pIter = m_aUIElements.begin(); pIter != m_aUIElements.end(); pIter++ )
3159 {
3160 if ( pIter->m_xUIElement.is() )
3161 {
3162 Reference< css::awt::XWindow > xWindow( pIter->m_xUIElement->getRealInterface(), UNO_QUERY );
3163 if ( xWindow.is() )
3164 {
3165 if ( bSetVisible )
3166 {
3167 if ( pIter->m_bVisible && !pIter->m_bMasterHide )
3168 aWinVector.push_back( xWindow );
3169 }
3170 else
3171 aWinVector.push_back( xWindow );
3172 }
3173 }
3174 }
3175
3176 aReadLock.unlock();
3177
3178 try
3179 {
3180 vos::OGuard aGuard( Application::GetSolarMutex() );
3181 const sal_uInt32 nCount = aWinVector.size();
3182 for ( sal_uInt32 i = 0; i < nCount; i++ )
3183 {
3184 Reference< css::awt::XWindow > xWindow( aWinVector[i] );
3185 if ( xWindow.is() )
3186 {
3187 // we need VCL here to pass special flags to Show()
3188 Window* pWindow = VCLUnoHelper::GetWindow( xWindow );
3189 if( pWindow )
3190 pWindow->Show( bSetVisible, SHOW_NOFOCUSCHANGE | SHOW_NOACTIVATE );
3191 }
3192 }
3193 }
3194 catch ( DisposedException& )
3195 {
3196 }
3197
3198 // Hide/show menubar according to bSetVisible
3199 aReadLock.lock();
3200 Reference< XUIElement > xMenuBar( m_xMenuBar, UNO_QUERY );
3201 Reference< css::awt::XWindow > xContainerWindow( m_xContainerWindow );
3202 Reference< XComponent > xInplaceMenuBar( m_xInplaceMenuBar );
3203 MenuBarManager* pInplaceMenuBar( m_pInplaceMenuBar );
3204 aReadLock.unlock();
3205
3206 if (( xMenuBar.is() || xInplaceMenuBar.is() ) && xContainerWindow.is() )
3207 {
3208 vos::OGuard aGuard( Application::GetSolarMutex() );
3209
3210 MenuBar* pMenuBar( 0 );
3211 if ( xInplaceMenuBar.is() )
3212 pMenuBar = (MenuBar *)pInplaceMenuBar->GetMenuBar();
3213 else
3214 {
3215 MenuBarWrapper* pMenuBarWrapper = SAL_STATIC_CAST( MenuBarWrapper*, xMenuBar.get() );
3216 pMenuBar = (MenuBar *)pMenuBarWrapper->GetMenuBarManager()->GetMenuBar();
3217 }
3218
3219 Window* pWindow = VCLUnoHelper::GetWindow( xContainerWindow );
3220 while ( pWindow && !pWindow->IsSystemWindow() )
3221 pWindow = pWindow->GetParent();
3222
3223 if ( pWindow )
3224 {
3225 SystemWindow* pSysWindow = (SystemWindow *)pWindow;
3226 if ( bSetVisible )
3227 pSysWindow->SetMenuBar( pMenuBar );
3228 else
3229 pSysWindow->SetMenuBar( 0 );
3230 }
3231 }
3232
3233 // Hide/show the statusbar according to bSetVisible
3234 if ( bSetVisible )
3235 implts_showStatusBar();
3236 else
3237 implts_hideStatusBar();
3238
3239 if ( !bOld )
3240 {
3241 WriteGuard aWriteLock( m_aLock );
3242 m_bDoLayout = sal_False;
3243 }
3244
3245 if ( bSetVisible )
3246 {
3247 implts_createNonContextSensitiveToolBars();
3248 doLayout();
3249 }
3250 else
3251 {
3252 // Set docking area window size to zero
3253 ReadGuard aReadLock2( m_aLock );
3254 Reference< css::awt::XWindow > xTopDockingWindow = m_xDockAreaWindows[DockingArea_DOCKINGAREA_TOP];
3255 Reference< css::awt::XWindow > xLeftDockingWindow = m_xDockAreaWindows[DockingArea_DOCKINGAREA_LEFT];
3256 Reference< css::awt::XWindow > xRightDockingWindow = m_xDockAreaWindows[DockingArea_DOCKINGAREA_RIGHT];
3257 Reference< css::awt::XWindow > xBottomDockingWindow = m_xDockAreaWindows[DockingArea_DOCKINGAREA_BOTTOM];
3258 aReadLock2.unlock();
3259
3260 try
3261 {
3262 if ( xTopDockingWindow.is() )
3263 xTopDockingWindow->setPosSize( 0, 0, 0, 0, css::awt::PosSize::POSSIZE );
3264 if ( xLeftDockingWindow.is() )
3265 xLeftDockingWindow->setPosSize( 0, 0, 0, 0, css::awt::PosSize::POSSIZE );
3266 if ( xRightDockingWindow.is() )
3267 xRightDockingWindow->setPosSize( 0, 0, 0, 0, css::awt::PosSize::POSSIZE );
3268 if ( xBottomDockingWindow.is() )
3269 xBottomDockingWindow->setPosSize( 0, 0, 0, 0, css::awt::PosSize::POSSIZE );
3270
3271 WriteGuard aWriteLock( m_aLock );
3272 m_aDockingArea = css::awt::Rectangle();
3273 m_bMustDoLayout = sal_True;
3274 aWriteLock.unlock();
3275 }
3276 catch ( Exception& )
3277 {
3278 }
3279 }
3280 }
3281
3282 void LayoutManager::implts_setCurrentUIVisibility( sal_Bool bShow )
3283 {
3284 /* SAFE AREA ----------------------------------------------------------------------------------------------- */
3285 WriteGuard aWriteLock( m_aLock );
3286 UIElementVector::iterator pIter;
3287 for ( pIter = m_aUIElements.begin(); pIter != m_aUIElements.end(); pIter++ )
3288 {
3289 if ( !bShow && pIter->m_bVisible && pIter->m_xUIElement.is() )
3290 pIter->m_bMasterHide = true;
3291 else if ( bShow && pIter->m_bMasterHide )
3292 pIter->m_bMasterHide = false;
3293 }
3294
3295 if ( !bShow && m_aStatusBarElement.m_bVisible && m_aStatusBarElement.m_xUIElement.is() )
3296 m_aStatusBarElement.m_bMasterHide = true;
3297 else if ( bShow && m_aStatusBarElement.m_bVisible )
3298 m_aStatusBarElement.m_bMasterHide = false;
3299 aWriteLock.unlock();
3300 /* SAFE AREA ----------------------------------------------------------------------------------------------- */
3301
3302 implts_updateUIElementsVisibleState( bShow );
3303 }
3304
3305 void LayoutManager::implts_destroyStatusBar()
3306 {
3307 Reference< XComponent > xCompStatusBar;
3308
3309 /* SAFE AREA ----------------------------------------------------------------------------------------------- */
3310 WriteGuard aWriteLock( m_aLock );
3311 m_aStatusBarElement.m_aName = rtl::OUString();
3312 xCompStatusBar = Reference< XComponent >( m_aStatusBarElement.m_xUIElement, UNO_QUERY );
3313 m_aStatusBarElement.m_xUIElement.clear();
3314 aWriteLock.unlock();
3315 /* SAFE AREA ----------------------------------------------------------------------------------------------- */
3316
3317 if ( xCompStatusBar.is() )
3318 xCompStatusBar->dispose();
3319
3320 implts_destroyProgressBar();
3321 }
3322
3323 void LayoutManager::implts_createStatusBar( const rtl::OUString& aStatusBarName )
3324 {
3325 /* SAFE AREA ----------------------------------------------------------------------------------------------- */
3326 WriteGuard aWriteLock( m_aLock );
3327 if ( !m_aStatusBarElement.m_xUIElement.is() )
3328 {
3329 implts_readStatusBarState( aStatusBarName );
3330 m_aStatusBarElement.m_aName = aStatusBarName;
3331 m_aStatusBarElement.m_xUIElement = implts_createElement( aStatusBarName );
3332 }
3333
3334 implts_createProgressBar();
3335 /* SAFE AREA ----------------------------------------------------------------------------------------------- */
3336 }
3337
3338 void LayoutManager::implts_readStatusBarState( const rtl::OUString& rStatusBarName )
3339 {
3340 /* SAFE AREA ----------------------------------------------------------------------------------------------- */
3341 WriteGuard aWriteLock( m_aLock );
3342 if ( !m_aStatusBarElement.m_bStateRead )
3343 {
3344 // Read persistent data for status bar if not yet read!
3345 if ( implts_readWindowStateData( rStatusBarName, m_aStatusBarElement ))
3346 m_aStatusBarElement.m_bStateRead = sal_True;
3347 }
3348 /* SAFE AREA ----------------------------------------------------------------------------------------------- */
3349 }
3350
3351 void LayoutManager::implts_createProgressBar()
3352 {
3353 Reference< XUIElement > xStatusBar;
3354 Reference< XUIElement > xProgressBar;
3355 Reference< XUIElement > xProgressBarBackup;
3356 Reference< css::awt::XWindow > xContainerWindow;
3357
3358 /* SAFE AREA ----------------------------------------------------------------------------------------------- */
3359 WriteGuard aWriteLock( m_aLock );
3360 xStatusBar = Reference< XUIElement >( m_aStatusBarElement.m_xUIElement, UNO_QUERY );
3361 xProgressBar = Reference< XUIElement >( m_aProgressBarElement.m_xUIElement, UNO_QUERY );
3362 xProgressBarBackup = m_xProgressBarBackup;
3363 m_xProgressBarBackup.clear();
3364 xContainerWindow = m_xContainerWindow;
3365 aWriteLock.unlock();
3366 /* SAFE AREA ----------------------------------------------------------------------------------------------- */
3367
3368 sal_Bool bRecycled = xProgressBarBackup.is();
3369 ProgressBarWrapper* pWrapper = 0;
3370 if ( bRecycled )
3371 pWrapper = (ProgressBarWrapper*)xProgressBarBackup.get();
3372 else if ( xProgressBar.is() )
3373 pWrapper = (ProgressBarWrapper*)xProgressBar.get();
3374 else
3375 pWrapper = new ProgressBarWrapper();
3376
3377 if ( xStatusBar.is() )
3378 {
3379 Reference< css::awt::XWindow > xWindow( xStatusBar->getRealInterface(), UNO_QUERY );
3380 pWrapper->setStatusBar( xWindow );
3381 }
3382 else
3383 {
3384 Reference< css::awt::XWindow > xStatusBarWindow = pWrapper->getStatusBar();
3385
3386 vos::OGuard aGuard( Application::GetSolarMutex() );
3387 Window* pStatusBarWnd = VCLUnoHelper::GetWindow( xStatusBarWindow );
3388 if ( !pStatusBarWnd )
3389 {
3390 Window* pWindow = VCLUnoHelper::GetWindow( xContainerWindow );
3391 if ( pWindow )
3392 {
3393 StatusBar* pStatusBar = new StatusBar( pWindow, WinBits( WB_LEFT | WB_3DLOOK ) );
3394 Reference< css::awt::XWindow > xStatusBarWindow2( VCLUnoHelper::GetInterface( pStatusBar ));
3395 pWrapper->setStatusBar( xStatusBarWindow2, sal_True );
3396 }
3397 }
3398 }
3399
3400 /* SAFE AREA ----------------------------------------------------------------------------------------------- */
3401 aWriteLock.lock();
3402 m_aProgressBarElement.m_xUIElement = Reference< XUIElement >(
3403 static_cast< cppu::OWeakObject* >( pWrapper ), UNO_QUERY );
3404 aWriteLock.unlock();
3405 /* SAFE AREA ----------------------------------------------------------------------------------------------- */
3406
3407 if ( bRecycled )
3408 implts_showProgressBar();
3409 }
3410
3411 void LayoutManager::implts_backupProgressBarWrapper()
3412 {
3413 // SAFE -> ----------------------------------
3414 WriteGuard aWriteLock(m_aLock);
3415
3416 if (m_xProgressBarBackup.is())
3417 return;
3418
3419 // safe a backup copy of the current progress!
3420 // This copy will be used automaticly inside createProgressBar() which is called
3421 // implictly from implts_doLayout() .-)
3422 m_xProgressBarBackup = m_aProgressBarElement.m_xUIElement;
3423
3424 // remove the relation between this old progress bar and our old status bar.
3425 // Otherwhise we work on disposed items ...
3426 // The internal used ProgressBarWrapper can handle a NULL reference.
3427 if ( m_xProgressBarBackup.is() )
3428 {
3429 ProgressBarWrapper* pWrapper = (ProgressBarWrapper*)m_xProgressBarBackup.get();
3430 if ( pWrapper )
3431 pWrapper->setStatusBar( Reference< css::awt::XWindow >(), sal_False );
3432 }
3433
3434 // prevent us from dispose() the m_aProgressBarElement.m_xUIElement inside implts_reset()
3435 m_aProgressBarElement.m_xUIElement.clear();
3436
3437 aWriteLock.unlock();
3438 // <- SAFE ----------------------------------
3439 }
3440
3441 void LayoutManager::implts_destroyProgressBar()
3442 {
3443 // dont remove the progressbar in general
3444 // We must reuse it if a new status bar is created later.
3445 // Of course there exists one backup only.
3446 // And further this backup will be released inside our dtor.
3447 implts_backupProgressBarWrapper();
3448 }
3449
3450 void LayoutManager::implts_setStatusBarPosSize( const ::Point& rPos, const ::Size& rSize )
3451 {
3452 Reference< XUIElement > xStatusBar;
3453 Reference< XUIElement > xProgressBar;
3454 Reference< css::awt::XWindow > xContainerWindow;
3455
3456 /* SAFE AREA ----------------------------------------------------------------------------------------------- */
3457 ReadGuard aReadLock( m_aLock );
3458 xStatusBar = Reference< XUIElement >( m_aStatusBarElement.m_xUIElement, UNO_QUERY );
3459 xProgressBar = Reference< XUIElement >( m_aProgressBarElement.m_xUIElement, UNO_QUERY );
3460 xContainerWindow = m_xContainerWindow;
3461
3462 Reference< css::awt::XWindow > xWindow;
3463 if ( xStatusBar.is() )
3464 xWindow = Reference< css::awt::XWindow >( xStatusBar->getRealInterface(), UNO_QUERY );
3465 else if ( xProgressBar.is() )
3466 {
3467 ProgressBarWrapper* pWrapper = (ProgressBarWrapper*)xProgressBar.get();
3468 if ( pWrapper )
3469 xWindow = pWrapper->getStatusBar();
3470 }
3471 aReadLock.unlock();
3472 /* SAFE AREA ----------------------------------------------------------------------------------------------- */
3473
3474 if ( xWindow.is() )
3475 {
3476 vos::OGuard aGuard( Application::GetSolarMutex() );
3477 Window* pParentWindow = VCLUnoHelper::GetWindow( xContainerWindow );
3478 Window* pWindow = VCLUnoHelper::GetWindow( xWindow );
3479 if ( pParentWindow && ( pWindow && pWindow->GetType() == WINDOW_STATUSBAR ))
3480 {
3481 Window* pOldParentWindow = pWindow->GetParent();
3482 if ( pParentWindow != pOldParentWindow )
3483 pWindow->SetParent( pParentWindow );
3484 ((StatusBar *)pWindow)->SetPosSizePixel( rPos, rSize );
3485 }
3486 }
3487 }
3488
3489 sal_Bool LayoutManager::implts_showProgressBar()
3490 {
3491 Reference< XUIElement > xStatusBar;
3492 Reference< XUIElement > xProgressBar;
3493 Reference< css::awt::XWindow > xWindow;
3494
3495 /* SAFE AREA ----------------------------------------------------------------------------------------------- */
3496 WriteGuard aWriteLock( m_aLock );
3497 xStatusBar = Reference< XUIElement >( m_aStatusBarElement.m_xUIElement, UNO_QUERY );
3498 xProgressBar = Reference< XUIElement >( m_aProgressBarElement.m_xUIElement, UNO_QUERY );
3499 sal_Bool bVisible( m_bVisible );
3500
3501 m_aProgressBarElement.m_bVisible = sal_True;
3502 if ( bVisible )
3503 {
3504 if ( xStatusBar.is() && !m_aStatusBarElement.m_bMasterHide )
3505 {
3506 xWindow = Reference< css::awt::XWindow >( xStatusBar->getRealInterface(), UNO_QUERY );
3507 }
3508 else if ( xProgressBar.is() )
3509 {
3510 ProgressBarWrapper* pWrapper = (ProgressBarWrapper*)xProgressBar.get();
3511 if ( pWrapper )
3512 xWindow = pWrapper->getStatusBar();
3513 }
3514 }
3515 aWriteLock.unlock();
3516
3517 vos::OGuard aGuard( Application::GetSolarMutex() );
3518 Window* pWindow = VCLUnoHelper::GetWindow( xWindow );
3519 if ( pWindow )
3520 {
3521 if ( !pWindow->IsVisible() )
3522 {
3523 pWindow->Show();
3524 doLayout();
3525 }
3526 return sal_True;
3527 }
3528
3529 return sal_False;
3530 }
3531
3532 sal_Bool LayoutManager::implts_hideProgressBar()
3533 {
3534 Reference< XUIElement > xProgressBar;
3535 Reference< css::awt::XWindow > xWindow;
3536 sal_Bool bHideStatusBar( sal_False );
3537
3538 /* SAFE AREA ----------------------------------------------------------------------------------------------- */
3539 WriteGuard aWriteLock( m_aLock );
3540 xProgressBar = Reference< XUIElement >( m_aProgressBarElement.m_xUIElement, UNO_QUERY );
3541
3542 sal_Bool bInternalStatusBar( sal_False );
3543 if ( xProgressBar.is() )
3544 {
3545 Reference< css::awt::XWindow > xStatusBar;
3546 ProgressBarWrapper* pWrapper = (ProgressBarWrapper*)xProgressBar.get();
3547 if ( pWrapper )
3548 xWindow = pWrapper->getStatusBar();
3549 Reference< css::ui::XUIElement > xStatusBarElement = m_aStatusBarElement.m_xUIElement;
3550 if ( xStatusBarElement.is() )
3551 xStatusBar = Reference< css::awt::XWindow >( xStatusBarElement->getRealInterface(), UNO_QUERY );
3552 bInternalStatusBar = xStatusBar != xWindow;
3553 }
3554 m_aProgressBarElement.m_bVisible = sal_False;
3555 implts_readStatusBarState( m_aStatusBarAlias );
3556 bHideStatusBar = !m_aStatusBarElement.m_bVisible;
3557 aWriteLock.unlock();
3558
3559 vos::OGuard aGuard( Application::GetSolarMutex() );
3560 Window* pWindow = VCLUnoHelper::GetWindow( xWindow );
3561 if ( pWindow && pWindow->IsVisible() &&
3562 ( bHideStatusBar || bInternalStatusBar ))
3563 {
3564 pWindow->Hide();
3565 doLayout();
3566 return sal_True;
3567 }
3568
3569 return sal_False;
3570 }
3571
3572 sal_Bool LayoutManager::implts_showStatusBar( sal_Bool bStoreState )
3573 {
3574 /* SAFE AREA ----------------------------------------------------------------------------------------------- */
3575 WriteGuard aWriteLock( m_aLock );
3576 Reference< css::ui::XUIElement > xStatusBar = m_aStatusBarElement.m_xUIElement;
3577 if ( bStoreState )
3578 m_aStatusBarElement.m_bVisible = sal_True;
3579 aWriteLock.unlock();
3580 /* SAFE AREA ----------------------------------------------------------------------------------------------- */
3581
3582 if ( xStatusBar.is() )
3583 {
3584 Reference< css::awt::XWindow > xWindow( xStatusBar->getRealInterface(), UNO_QUERY );
3585
3586 vos::OGuard aGuard( Application::GetSolarMutex() );
3587 Window* pWindow = VCLUnoHelper::GetWindow( xWindow );
3588 if ( pWindow && !pWindow->IsVisible() )
3589 {
3590 pWindow->Show();
3591 return sal_True;
3592 }
3593 }
3594
3595 return sal_False;
3596 }
3597
3598 sal_Bool LayoutManager::implts_hideStatusBar( sal_Bool bStoreState )
3599 {
3600 /* SAFE AREA ----------------------------------------------------------------------------------------------- */
3601 WriteGuard aWriteLock( m_aLock );
3602 Reference< css::ui::XUIElement > xStatusBar = m_aStatusBarElement.m_xUIElement;
3603 if ( bStoreState )
3604 m_aStatusBarElement.m_bVisible = sal_False;
3605 aWriteLock.unlock();
3606 /* SAFE AREA ----------------------------------------------------------------------------------------------- */
3607
3608 if ( xStatusBar.is() )
3609 {
3610 Reference< css::awt::XWindow > xWindow( xStatusBar->getRealInterface(), UNO_QUERY );
3611
3612 vos::OGuard aGuard( Application::GetSolarMutex() );
3613 Window* pWindow = VCLUnoHelper::GetWindow( xWindow );
3614 if ( pWindow && pWindow->IsVisible() )
3615 {
3616 pWindow->Hide();
3617 return sal_True;
3618 }
3619 }
3620
3621 return sal_False;
3622 }
3623
3624 void LayoutManager::implts_setInplaceMenuBar( const Reference< XIndexAccess >& xMergedMenuBar )
3625 throw (::com::sun::star::uno::RuntimeException)
3626 {
3627 /* SAFE AREA ----------------------------------------------------------------------------------------------- */
3628 WriteGuard aWriteLock( m_aLock );
3629
3630 if ( !m_bInplaceMenuSet )
3631 {
3632 vos::OGuard aGuard( Application::GetSolarMutex() );
3633
3634 // Reset old inplace menubar!
3635 m_pInplaceMenuBar = 0;
3636 if ( m_xInplaceMenuBar.is() )
3637 m_xInplaceMenuBar->dispose();
3638 m_xInplaceMenuBar.clear();
3639 m_bInplaceMenuSet = sal_False;
3640
3641 if ( m_xFrame.is() &&
3642 m_xContainerWindow.is() )
3643 {
3644 rtl::OUString aModuleIdentifier;
3645 Reference< XDispatchProvider > xDispatchProvider;
3646
3647 MenuBar* pMenuBar = new MenuBar;
3648 m_pInplaceMenuBar = new MenuBarManager( m_xSMGR, m_xFrame, m_xURLTransformer,xDispatchProvider, aModuleIdentifier, pMenuBar, sal_True, sal_True );
3649 m_pInplaceMenuBar->SetItemContainer( xMergedMenuBar );
3650
3651 Window* pWindow = VCLUnoHelper::GetWindow( m_xContainerWindow );
3652 while ( pWindow && !pWindow->IsSystemWindow() )
3653 pWindow = pWindow->GetParent();
3654
3655 if ( pWindow )
3656 {
3657 SystemWindow* pSysWindow = (SystemWindow *)pWindow;
3658 pSysWindow->SetMenuBar( pMenuBar );
3659 }
3660
3661 m_bInplaceMenuSet = sal_True;
3662 m_xInplaceMenuBar = Reference< XComponent >( (OWeakObject *)m_pInplaceMenuBar, UNO_QUERY );
3663 }
3664
3665 aWriteLock.unlock();
3666 /* SAFE AREA ----------------------------------------------------------------------------------------------- */
3667 implts_updateMenuBarClose();
3668 }
3669
3670 }
3671
3672 void LayoutManager::implts_resetInplaceMenuBar()
3673 throw (::com::sun::star::uno::RuntimeException)
3674 {
3675 /* SAFE AREA ----------------------------------------------------------------------------------------------- */
3676 WriteGuard aWriteLock( m_aLock );
3677 m_bInplaceMenuSet = sal_False;
3678
3679 // if ( m_xMenuBar.is() &&
3680 if ( m_xContainerWindow.is() )
3681 {
3682 vos::OGuard aGuard( Application::GetSolarMutex() );
3683 MenuBarWrapper* pMenuBarWrapper = SAL_STATIC_CAST( MenuBarWrapper*, m_xMenuBar.get() );
3684 Window* pWindow = VCLUnoHelper::GetWindow( m_xContainerWindow );
3685 while ( pWindow && !pWindow->IsSystemWindow() )
3686 pWindow = pWindow->GetParent();
3687
3688 if ( pWindow )
3689 {
3690 SystemWindow* pSysWindow = (SystemWindow *)pWindow;
3691 if ( pMenuBarWrapper )
3692 pSysWindow->SetMenuBar( (MenuBar *)pMenuBarWrapper->GetMenuBarManager()->GetMenuBar() );
3693 else
3694 pSysWindow->SetMenuBar( 0 );
3695 }
3696 }
3697
3698 // Remove inplace menu bar
3699 m_pInplaceMenuBar = 0;
3700 if ( m_xInplaceMenuBar.is() )
3701 m_xInplaceMenuBar->dispose();
3702 m_xInplaceMenuBar.clear();
3703
3704 aWriteLock.unlock();
3705 /* SAFE AREA ----------------------------------------------------------------------------------------------- */
3706 }
3707
3708 void SAL_CALL LayoutManager::attachFrame( const Reference< XFrame >& xFrame )
3709 throw (::com::sun::star::uno::RuntimeException)
3710 {
3711 /* SAFE AREA ----------------------------------------------------------------------------------------------- */
3712 WriteGuard aWriteLock( m_aLock );
3713 m_xFrame = xFrame;
3714 aWriteLock.unlock();
3715 /* SAFE AREA ----------------------------------------------------------------------------------------------- */
3716 // if ( xFrame.is() )
3717 // xFrame->getContainerWindow()->addWindowListener( Reference< css::awt::XWindowListener >( static_cast< OWeakObject* >( this ), UNO_QUERY ));
3718 }
3719
3720 void SAL_CALL LayoutManager::reset()
3721 throw (RuntimeException)
3722 {
3723 sal_Bool bComponentAttached( sal_False );
3724
3725 /* SAFE AREA ----------------------------------------------------------------------------------------------- */
3726 ReadGuard aReadLock( m_aLock );
3727 bComponentAttached = m_bComponentAttached;
3728 aReadLock.unlock();
3729
3730 implts_reset( sal_True );
3731 }
3732
3733 void SAL_CALL LayoutManager::setInplaceMenuBar( sal_Int64 )
3734 throw (::com::sun::star::uno::RuntimeException)
3735 {
3736 OSL_ENSURE( sal_False, "This method is obsolete and should not be used!\n" );
3737 }
3738
3739 void SAL_CALL LayoutManager::resetInplaceMenuBar()
3740 throw (::com::sun::star::uno::RuntimeException)
3741 {
3742 OSL_ENSURE( sal_False, "This method is obsolete and should not be used!\n" );
3743 }
3744
3745 //---------------------------------------------------------------------------------------------------------
3746 // XMenuBarMergingAcceptor
3747 //---------------------------------------------------------------------------------------------------------
3748 sal_Bool SAL_CALL LayoutManager::setMergedMenuBar(
3749 const Reference< XIndexAccess >& xMergedMenuBar )
3750 throw (::com::sun::star::uno::RuntimeException)
3751 {
3752 implts_setInplaceMenuBar( xMergedMenuBar );
3753
3754 css::uno::Any a;
3755 implts_notifyListeners( css::frame::LayoutManagerEvents::MERGEDMENUBAR, a );
3756 return sal_True;
3757 }
3758
3759 void SAL_CALL LayoutManager::removeMergedMenuBar()
3760 throw (::com::sun::star::uno::RuntimeException)
3761 {
3762 implts_resetInplaceMenuBar();
3763 }
3764
3765 ::com::sun::star::awt::Rectangle SAL_CALL LayoutManager::getCurrentDockingArea()
3766 throw ( RuntimeException )
3767 {
3768 /* SAFE AREA ----------------------------------------------------------------------------------------------- */
3769 ReadGuard aReadLock( m_aLock );
3770 return m_aDockingArea;
3771 }
3772
3773 Reference< XDockingAreaAcceptor > SAL_CALL LayoutManager::getDockingAreaAcceptor()
3774 throw (::com::sun::star::uno::RuntimeException)
3775 {
3776 /* SAFE AREA ----------------------------------------------------------------------------------------------- */
3777 ReadGuard aReadLock( m_aLock );
3778 return m_xDockingAreaAcceptor;
3779 }
3780
3781 void SAL_CALL LayoutManager::setDockingAreaAcceptor( const Reference< ::com::sun::star::ui::XDockingAreaAcceptor >& xDockingAreaAcceptor )
3782 throw ( RuntimeException )
3783 {
3784 /* SAFE AREA ----------------------------------------------------------------------------------------------- */
3785 WriteGuard aWriteLock( m_aLock );
3786
3787 if (( m_xDockingAreaAcceptor == xDockingAreaAcceptor ) ||
3788 !m_xFrame.is() )
3789 return;
3790
3791 // IMPORTANT: Be sure to stop layout timer if don't have a docking area acceptor!
3792 if ( !xDockingAreaAcceptor.is() )
3793 m_aAsyncLayoutTimer.Stop();
3794
3795 sal_Bool bAutomaticToolbars( m_bAutomaticToolbars );
3796 std::vector< Reference< css::awt::XWindow > > oldDockingAreaWindows;
3797
3798 if ( !xDockingAreaAcceptor.is() )
3799 m_aAsyncLayoutTimer.Stop();
3800
3801 // Remove listener from old docking area acceptor
3802 if ( m_xDockingAreaAcceptor.is() )
3803 {
3804 Reference< css::awt::XWindow > xWindow( m_xDockingAreaAcceptor->getContainerWindow() );
3805 if ( xWindow.is() && ( m_xFrame->getContainerWindow() != m_xContainerWindow || !xDockingAreaAcceptor.is() ) )
3806 xWindow->removeWindowListener( Reference< css::awt::XWindowListener >( static_cast< OWeakObject * >( this ), UNO_QUERY ));
3807
3808 oldDockingAreaWindows.push_back( m_xDockAreaWindows[DockingArea_DOCKINGAREA_TOP] );
3809 oldDockingAreaWindows.push_back( m_xDockAreaWindows[DockingArea_DOCKINGAREA_BOTTOM] );
3810 oldDockingAreaWindows.push_back( m_xDockAreaWindows[DockingArea_DOCKINGAREA_LEFT] );
3811 oldDockingAreaWindows.push_back( m_xDockAreaWindows[DockingArea_DOCKINGAREA_RIGHT] );
3812
3813 m_xDockAreaWindows[DockingArea_DOCKINGAREA_TOP].clear();
3814 m_xDockAreaWindows[DockingArea_DOCKINGAREA_BOTTOM].clear();
3815 m_xDockAreaWindows[DockingArea_DOCKINGAREA_LEFT].clear();
3816 m_xDockAreaWindows[DockingArea_DOCKINGAREA_RIGHT].clear();
3817 m_aDockingArea = css::awt::Rectangle();
3818
3819 Window* pContainerWindow = VCLUnoHelper::GetWindow( xWindow );
3820 if ( pContainerWindow )
3821 pContainerWindow->RemoveChildEventListener( LINK( this, LayoutManager, WindowEventListener ) );
3822 }
3823
3824 // Set new docking area acceptor and add ourself as window listener on the container window.
3825 // Create our docking area windows which are parents for all docked windows.
3826 css::uno::Reference< css::awt::XWindow > xTopDockWindow;
3827 css::uno::Reference< css::awt::XWindow > xBottomDockWindow;
3828 css::uno::Reference< css::awt::XWindow > xLeftDockWindow;
3829 css::uno::Reference< css::awt::XWindow > xRightDockWindow;
3830
3831 Reference< ::com::sun::star::ui::XDockingAreaAcceptor > xOldDockingAreaAcceptor( m_xDockingAreaAcceptor );
3832 m_xDockingAreaAcceptor = xDockingAreaAcceptor;
3833 if ( m_xDockingAreaAcceptor.is() )
3834 {
3835 m_aDockingArea = css::awt::Rectangle();
3836 m_xContainerWindow = m_xDockingAreaAcceptor->getContainerWindow();
3837 m_xContainerWindow->addWindowListener( Reference< css::awt::XWindowListener >( static_cast< OWeakObject* >( this ), UNO_QUERY ));
3838
3839 // we always must keep a connection to the window of our frame for resize events
3840 if ( m_xContainerWindow != m_xFrame->getContainerWindow() )
3841 m_xFrame->getContainerWindow()->addWindowListener( Reference< css::awt::XWindowListener >( static_cast< OWeakObject* >( this ), UNO_QUERY ));
3842
3843 // #i37884# set initial visibility state - in the plugin case the container window is already shown
3844 // and we get no notification anymore
3845 {
3846 vos::OGuard aGuard( Application::GetSolarMutex() );
3847 Window* pContainerWindow = VCLUnoHelper::GetWindow( m_xContainerWindow );
3848 if( pContainerWindow )
3849 m_bParentWindowVisible = pContainerWindow->IsVisible();
3850 }
3851
3852 css::uno::Reference< css::awt::XWindowPeer > xParent( m_xContainerWindow, UNO_QUERY );
3853 xTopDockWindow = Reference< css::awt::XWindow >( implts_createToolkitWindow( xParent ), UNO_QUERY );
3854 xBottomDockWindow = Reference< css::awt::XWindow >( implts_createToolkitWindow( xParent ), UNO_QUERY );
3855 xLeftDockWindow = Reference< css::awt::XWindow >( implts_createToolkitWindow( xParent ), UNO_QUERY );
3856 xRightDockWindow = Reference< css::awt::XWindow >( implts_createToolkitWindow( xParent ), UNO_QUERY );
3857 m_xDockAreaWindows[DockingArea_DOCKINGAREA_TOP] = xTopDockWindow;
3858 m_xDockAreaWindows[DockingArea_DOCKINGAREA_BOTTOM] = xBottomDockWindow;
3859 m_xDockAreaWindows[DockingArea_DOCKINGAREA_LEFT] = xLeftDockWindow;
3860 m_xDockAreaWindows[DockingArea_DOCKINGAREA_RIGHT] = xRightDockWindow;
3861 }
3862
3863 aWriteLock.unlock();
3864 /* SAFE AREA ----------------------------------------------------------------------------------------------- */
3865
3866 if ( xDockingAreaAcceptor.is() )
3867 {
3868 vos::OGuard aGuard( Application::GetSolarMutex() );
3869 ::DockingAreaWindow* pWindow;
3870 pWindow = dynamic_cast< ::DockingAreaWindow* >(VCLUnoHelper::GetWindow( xTopDockWindow ) );
3871 if( pWindow ) pWindow->SetAlign( WINDOWALIGN_TOP );
3872 pWindow = dynamic_cast< ::DockingAreaWindow* >(VCLUnoHelper::GetWindow( xBottomDockWindow ) );
3873 if( pWindow ) pWindow->SetAlign( WINDOWALIGN_BOTTOM );
3874 pWindow = dynamic_cast< ::DockingAreaWindow* >(VCLUnoHelper::GetWindow( xLeftDockWindow ) );
3875 if( pWindow ) pWindow->SetAlign( WINDOWALIGN_LEFT );
3876 pWindow = dynamic_cast< ::DockingAreaWindow* >(VCLUnoHelper::GetWindow( xRightDockWindow ) );
3877 if( pWindow ) pWindow->SetAlign( WINDOWALIGN_RIGHT );
3878
3879 // Add layout manager as listener to get notifications about toolbar button activties
3880 Window* pContainerWindow = VCLUnoHelper::GetWindow( m_xContainerWindow );
3881 if ( pContainerWindow )
3882 pContainerWindow->AddChildEventListener( LINK( this, LayoutManager, WindowEventListener ) );
3883
3884 // We have now a new container window, reparent all child windows!
3885 implts_reparentChildWindows();
3886 }
3887 else
3888 implts_destroyElements(); // remove all elements
3889
3890 if ( !oldDockingAreaWindows.empty() )
3891 {
3892 const sal_uInt32 nCount = oldDockingAreaWindows.size();
3893 for ( sal_uInt32 i = 0; i < nCount; ++i )
3894 {
3895 if ( oldDockingAreaWindows[i].is() )
3896 {
3897 try
3898 {
3899 oldDockingAreaWindows[i]->dispose();
3900 }
3901 catch ( Exception& )
3902 {
3903 }
3904 }
3905 }
3906
3907 // Reset docking area size for our old docking area acceptor
3908 css::awt::Rectangle aEmptyRect;
3909 xOldDockingAreaAcceptor->setDockingAreaSpace( aEmptyRect );
3910 }
3911
3912 if ( xDockingAreaAcceptor.is() )
3913 {
3914 if ( bAutomaticToolbars )
3915 {
3916 implts_createAddonsToolBars(); // create addon toolbars
3917 implts_createCustomToolBars(); // create custom toolbars
3918 implts_createNonContextSensitiveToolBars();
3919 }
3920 implts_sortUIElements();
3921 implts_doLayout( sal_True );
3922 }
3923 }
3924
3925 void LayoutManager::implts_reparentChildWindows()
3926 {
3927 UIElementVector aUIElementVector;
3928 UIElement aStatusBarElement;
3929 css::uno::Reference< css::awt::XWindow > xTopDockWindow;
3930 css::uno::Reference< css::awt::XWindow > xBottomDockWindow;
3931 css::uno::Reference< css::awt::XWindow > xLeftDockWindow;
3932 css::uno::Reference< css::awt::XWindow > xRightDockWindow;
3933 css::uno::Reference< css::awt::XWindow > xContainerWindow;
3934 css::uno::Reference< css::awt::XWindow > xStatusBarWindow;
3935
3936 WriteGuard aWriteLock( m_aLock );
3937 aUIElementVector = m_aUIElements;
3938 xTopDockWindow = m_xDockAreaWindows[DockingArea_DOCKINGAREA_TOP];
3939 xBottomDockWindow = m_xDockAreaWindows[DockingArea_DOCKINGAREA_BOTTOM];
3940 xLeftDockWindow = m_xDockAreaWindows[DockingArea_DOCKINGAREA_LEFT];
3941 xRightDockWindow = m_xDockAreaWindows[DockingArea_DOCKINGAREA_RIGHT];
3942 xContainerWindow = m_xContainerWindow;
3943 aStatusBarElement = m_aStatusBarElement;
3944 aWriteLock.unlock();
3945
3946 if ( aStatusBarElement.m_xUIElement.is() )
3947 {
3948 try
3949 {
3950 xStatusBarWindow = Reference< css::awt::XWindow >(
3951 aStatusBarElement.m_xUIElement->getRealInterface(),
3952 UNO_QUERY );
3953 }
3954 catch ( RuntimeException& )
3955 {
3956 throw;
3957 }
3958 catch ( Exception& )
3959 {
3960 }
3961 }
3962
3963 vos::OGuard aGuard( Application::GetSolarMutex() );
3964 Window* pContainerWindow = VCLUnoHelper::GetWindow( xContainerWindow );
3965 Window* pTopDockWindow = VCLUnoHelper::GetWindow( xTopDockWindow );
3966 Window* pBottomDockWindow = VCLUnoHelper::GetWindow( xBottomDockWindow );
3967 Window* pLeftDockWindow = VCLUnoHelper::GetWindow( xLeftDockWindow );
3968 Window* pRightDockWindow = VCLUnoHelper::GetWindow( xRightDockWindow );
3969 if ( pContainerWindow )
3970 {
3971 UIElementVector::iterator pIter;
3972 for ( pIter = aUIElementVector.begin(); pIter != aUIElementVector.end(); pIter++ )
3973 {
3974 Reference< XUIElement > xUIElement( pIter->m_xUIElement );
3975 if ( xUIElement.is() )
3976 {
3977 Reference< css::awt::XWindow > xWindow;
3978 try
3979 {
3980 // We have to retreive the window reference with try/catch as it is
3981 // possible that all elements has been disposed!
3982 xWindow = Reference< css::awt::XWindow >( xUIElement->getRealInterface(), UNO_QUERY );
3983 }
3984 catch ( RuntimeException& )
3985 {
3986 throw;
3987 }
3988 catch ( Exception& )
3989 {
3990 }
3991
3992 Window* pWindow = VCLUnoHelper::GetWindow( xWindow );
3993 if ( pWindow )
3994 {
3995 // Reparent our child windows acording to their current state.
3996 if ( pIter->m_bFloating )
3997 pWindow->SetParent( pContainerWindow );
3998 else
3999 {
4000 if ( pIter->m_aDockedData.m_nDockedArea == DockingArea_DOCKINGAREA_TOP )
4001 pWindow->SetParent( pTopDockWindow );
4002 else if ( pIter->m_aDockedData.m_nDockedArea == DockingArea_DOCKINGAREA_BOTTOM )
4003 pWindow->SetParent( pBottomDockWindow );
4004 else if ( pIter->m_aDockedData.m_nDockedArea == DockingArea_DOCKINGAREA_LEFT )
4005 pWindow->SetParent( pLeftDockWindow );
4006 else
4007 pWindow->SetParent( pRightDockWindow );
4008 }
4009 }
4010 }
4011 }
4012
4013 if ( xStatusBarWindow.is() )
4014 {
4015 Window* pWindow = VCLUnoHelper::GetWindow( xStatusBarWindow );
4016 if ( pWindow )
4017 pWindow->SetParent( pContainerWindow );
4018 }
4019
4020 implts_resetMenuBar();
4021 }
4022 }
4023
4024 IMPL_LINK( LayoutManager, WindowEventListener, VclSimpleEvent*, pEvent )
4025 {
4026 // To enable toolbar controllers to change their image when a sub-toolbar function
4027 // is activated, we need this mechanism. We have NO connection between these toolbars
4028 // anymore!
4029 if ( pEvent && pEvent->ISA( VclWindowEvent ))
4030 {
4031 if ( pEvent->GetId() == VCLEVENT_TOOLBOX_SELECT )
4032 {
4033 Window* pWindow( ((VclWindowEvent*)pEvent)->GetWindow() );
4034 ToolBox* pToolBox( 0 );
4035 rtl::OUString aToolbarName;
4036 rtl::OUString aCommand;
4037
4038 if ( pWindow && pWindow->GetType() == WINDOW_TOOLBOX )
4039 {
4040 pToolBox = (ToolBox *)pWindow;
4041 aToolbarName = pToolBox->GetSmartHelpId().GetStr();
4042 sal_Int32 i = aToolbarName.lastIndexOf( ':' );
4043 if (( aToolbarName.getLength() > 0 ) &&
4044 ( i > 0 ) && (( i+ 1 ) < aToolbarName.getLength() ))
4045 {
4046 // Remove ".HelpId:" protocol from toolbar name
4047 aToolbarName = aToolbarName.copy( i+1 );
4048
4049 USHORT nId = pToolBox->GetCurItemId();
4050 if ( nId > 0 )
4051 aCommand = pToolBox->GetItemCommand( nId );
4052 }
4053 }
4054
4055 if (( aToolbarName.getLength() > 0 ) && ( aCommand.getLength() > 0 ))
4056 {
4057 /* SAFE AREA ----------------------------------------------------------------------------------------------- */
4058 ReadGuard aReadLock( m_aLock );
4059 std::vector< css::uno::Reference< css::ui::XUIFunctionListener > > aListenerArray;
4060 UIElementVector::iterator pIter;
4061
4062 for ( pIter = m_aUIElements.begin(); pIter != m_aUIElements.end(); pIter++ )
4063 {
4064 if ( pIter->m_aType.equalsAscii( "toolbar" ) &&
4065 pIter->m_xUIElement.is() )
4066 {
4067 css::uno::Reference< css::ui::XUIFunctionListener > xListener( pIter->m_xUIElement, UNO_QUERY );
4068 if ( xListener.is() )
4069 aListenerArray.push_back( xListener );
4070 }
4071 }
4072 aReadLock.unlock();
4073 /* SAFE AREA ----------------------------------------------------------------------------------------------- */
4074
4075 const sal_uInt32 nCount = aListenerArray.size();
4076 for ( sal_uInt32 i = 0; i < nCount; ++i )
4077 {
4078 try
4079 {
4080 aListenerArray[i]->functionExecute( aToolbarName, aCommand );
4081 }
4082 catch ( RuntimeException& e )
4083 {
4084 throw e;
4085 }
4086 catch ( Exception& ) {}
4087 }
4088 }
4089 }
4090 else if ( pEvent->GetId() == VCLEVENT_TOOLBOX_FORMATCHANGED )
4091 {
4092 /* SAFE AREA ----------------------------------------------------------------------------------------------- */
4093 ReadGuard aReadLock( m_aLock );
4094
4095 Window* pWindow( ((VclWindowEvent*)pEvent)->GetWindow() );
4096 ToolBox* pToolBox( 0 );
4097 rtl::OUString aToolbarName;
4098
4099 if ( pWindow && pWindow->GetType() == WINDOW_TOOLBOX )
4100 {
4101 pToolBox = (ToolBox *)pWindow;
4102 aToolbarName = pToolBox->GetSmartHelpId().GetStr();
4103 if (( aToolbarName.getLength() > 0 ) && ( m_nLockCount == 0 ))
4104 m_aAsyncLayoutTimer.Start();
4105 }
4106 /* SAFE AREA ----------------------------------------------------------------------------------------------- */
4107 }
4108 }
4109
4110 return 1;
4111 }
4112
4113 void SAL_CALL LayoutManager::createElement( const ::rtl::OUString& aName )
4114 throw (RuntimeException)
4115 {
4116 RTL_LOGFILE_CONTEXT( aLog, "framework (cd100003) ::LayoutManager::createElement" );
4117
4118 /* SAFE AREA ----------------------------------------------------------------------------------------------- */
4119 ReadGuard aReadLock( m_aLock );
4120 Reference< XFrame > xFrame = m_xFrame;
4121 Reference< XURLTransformer > xURLTransformer = m_xURLTransformer;
4122 sal_Bool bInPlaceMenu = m_bInplaceMenuSet;
4123 aReadLock.unlock();
4124 /* SAFE AREA ----------------------------------------------------------------------------------------------- */
4125
4126 if ( !xFrame.is() )
4127 return;
4128
4129 Reference< XModel > xModel( impl_getModelFromFrame( xFrame ) );
4130
4131 /* SAFE AREA ----------------------------------------------------------------------------------------------- */
4132 WriteGuard aWriteLock( m_aLock );
4133
4134 sal_Bool bFound( sal_False );
4135 sal_Bool bNotify( sal_False );
4136 ::rtl::OUString aElementType;
4137 ::rtl::OUString aElementName;
4138 Reference< ::com::sun::star::ui::XUIElement > xUIElement;
4139
4140 implts_findElement( aName, aElementType, aElementName, xUIElement );
4141 bFound = xUIElement.is();
4142
4143 if ( /*xFrame.is() && */m_xContainerWindow.is() && !implts_isPreviewModel( xModel ) ) // no bars on preview mode
4144 {
4145 if ( aElementType.equalsIgnoreAsciiCaseAscii( "toolbar" ))
4146 {
4147 if ( !bFound )
4148 {
4149 SvtCommandOptions aCmdOptions;
4150
4151 xUIElement = implts_createElement( aName );
4152 sal_Bool bVisible( sal_False );
4153 if ( xUIElement.is() )
4154 {
4155 Reference< css::awt::XWindow > xWindow( xUIElement->getRealInterface(), UNO_QUERY );
4156 Reference< css::awt::XDockableWindow > xDockWindow( xUIElement->getRealInterface(), UNO_QUERY );
4157 if ( xDockWindow.is() && xWindow.is() )
4158 {
4159 try
4160 {
4161 xDockWindow->addDockableWindowListener( Reference< css::awt::XDockableWindowListener >(
4162 static_cast< OWeakObject * >( this ), UNO_QUERY ));
4163 xWindow->addWindowListener( Reference< css::awt::XWindowListener >(
4164 static_cast< OWeakObject * >( this ), UNO_QUERY ));
4165 xDockWindow->enableDocking( sal_True );
4166 }
4167 catch ( Exception& )
4168 {
4169 }
4170 }
4171
4172 UIElement& rElement = impl_findElement( aName );
4173 if ( rElement.m_aName.getLength() > 0 )
4174 {
4175 // Reuse a local entry so we are able to use the latest
4176 // UI changes for this document.
4177 implts_setElementData( rElement, xDockWindow );
4178 rElement.m_xUIElement = xUIElement;
4179 bVisible = rElement.m_bVisible;
4180 }
4181 else
4182 {
4183 // Create new UI element and try to read its state data
4184 UIElement aNewToolbar( aName, aElementType, xUIElement );
4185 implts_readWindowStateData( aName, aNewToolbar );
4186 implts_setElementData( aNewToolbar, xDockWindow );
4187 implts_insertUIElement( aNewToolbar );
4188 bVisible = aNewToolbar.m_bVisible;
4189 }
4190
4191 // set toolbar menu style according to customize command state
4192 Window* pWindow = VCLUnoHelper::GetWindow( xWindow );
4193 if ( pWindow && pWindow->GetType() == WINDOW_TOOLBOX )
4194 {
4195 ToolBox* pToolbar = (ToolBox *)pWindow;
4196 USHORT nMenuType = pToolbar->GetMenuType();
4197 if ( aCmdOptions.Lookup( SvtCommandOptions::CMDOPTION_DISABLED, m_aCustomizeCmd ))
4198 pToolbar->SetMenuType( nMenuType & ~TOOLBOX_MENUTYPE_CUSTOMIZE );
4199 else
4200 pToolbar->SetMenuType( nMenuType | TOOLBOX_MENUTYPE_CUSTOMIZE );
4201 }
4202 }
4203 aWriteLock.unlock();
4204
4205 implts_sortUIElements();
4206
4207 if ( bVisible )
4208 {
4209 doLayout();
4210 bNotify = sal_True;
4211 }
4212 }
4213 }
4214 else if ( aElementType.equalsIgnoreAsciiCaseAscii( "menubar" ))
4215 {
4216 if ( aElementName.equalsIgnoreAsciiCaseAscii( "menubar" ) && !bInPlaceMenu )
4217 {
4218 vos::OGuard aGuard( Application::GetSolarMutex() );
4219 // PB 2004-12-15 #i38743# don't create a menubar if frame isn't top
4220 if ( !m_xMenuBar.is() && implts_isFrameOrWindowTop(xFrame) )
4221 m_xMenuBar = implts_createElement( aName );
4222
4223 if ( m_xMenuBar.is() && implts_isFrameOrWindowTop(xFrame) )
4224 {
4225 Window* pWindow = VCLUnoHelper::GetWindow( m_xContainerWindow );
4226 while ( pWindow && !pWindow->IsSystemWindow() )
4227 pWindow = pWindow->GetParent();
4228
4229 if ( pWindow )
4230 {
4231 SystemWindow* pSysWindow = (SystemWindow *)pWindow;
4232 Reference< css::awt::XMenuBar > xMenuBar;
4233
4234 Reference< XPropertySet > xPropSet( m_xMenuBar, UNO_QUERY );
4235 if ( xPropSet.is() )
4236 {
4237 try
4238 {
4239 xPropSet->getPropertyValue( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "XMenuBar" ))) >>= xMenuBar;
4240 }
4241 catch ( com::sun::star::beans::UnknownPropertyException )
4242 {
4243 }
4244 catch ( com::sun::star::lang::WrappedTargetException )
4245 {
4246 }
4247 }
4248
4249 if ( xMenuBar.is() )
4250 {
4251 VCLXMenu* pAwtMenuBar = VCLXMenu::GetImplementation( xMenuBar );
4252 if ( pAwtMenuBar )
4253 {
4254 MenuBar* pMenuBar = (MenuBar*)pAwtMenuBar->GetMenu();
4255 if ( pMenuBar )
4256 {
4257 pSysWindow->SetMenuBar( pMenuBar );
4258 pMenuBar->SetDisplayable( m_bMenuVisible );
4259 if ( m_bMenuVisible )
4260 {
4261 bNotify = sal_True;
4262 }
4263 implts_updateMenuBarClose();
4264 }
4265 }
4266 }
4267 }
4268 }
4269 }
4270 aWriteLock.unlock();
4271 }
4272 else if ( aElementType.equalsIgnoreAsciiCaseAscii( "statusbar" ) && ( implts_isFrameOrWindowTop(xFrame) || implts_isEmbeddedLayoutManager() ))
4273 {
4274 implts_createStatusBar( aName );
4275 bNotify = sal_True;
4276 }
4277 else if ( aElementType.equalsIgnoreAsciiCaseAscii( "progressbar" ) &&
4278 aElementName.equalsIgnoreAsciiCaseAscii( "progressbar" ) &&
4279 implts_isFrameOrWindowTop(xFrame) )
4280 {
4281 implts_createProgressBar();
4282 bNotify = sal_True;
4283 }
4284 else if ( aElementType.equalsIgnoreAsciiCaseAscii( "dockingwindow" ))
4285 {
4286 aWriteLock.unlock();
4287
4288 // The docking window is created by a factory method located in the sfx2 library.
4289 CreateDockingWindow( xFrame, aElementName );
4290 }
4291 }
4292
4293 /* SAFE AREA ----------------------------------------------------------------------------------------------- */
4294 if ( bNotify )
4295 {
4296 // UI element is invisible - provide information to listeners
4297 implts_notifyListeners( css::frame::LayoutManagerEvents::UIELEMENT_VISIBLE, uno::makeAny( aName ) );
4298 }
4299 }
4300
4301 void SAL_CALL LayoutManager::destroyElement( const ::rtl::OUString& aName )
4302 throw (RuntimeException)
4303 {
4304 RTL_LOGFILE_CONTEXT( aLog, "framework (cd100003) ::LayoutManager::destroyElement" );
4305
4306 /* SAFE AREA ----------------------------------------------------------------------------------------------- */
4307 WriteGuard aWriteLock( m_aLock );
4308
4309 sal_Bool bMustLayouted( sal_False );
4310 sal_Bool bMustBeDestroyed( sal_False );
4311 sal_Bool bMustBeSorted( sal_False );
4312 sal_Bool bNotify( sal_False );
4313 ::rtl::OUString aElementType;
4314 ::rtl::OUString aElementName;
4315
4316 Reference< XComponent > xComponent;
4317 if ( impl_parseResourceURL( aName, aElementType, aElementName ))
4318 {
4319 if ( aElementType.equalsIgnoreAsciiCaseAscii( "menubar" ) &&
4320 aElementName.equalsIgnoreAsciiCaseAscii( "menubar" ))
4321 {
4322 if ( !m_bInplaceMenuSet )
4323 {
4324 impl_clearUpMenuBar();
4325 m_xMenuBar.clear();
4326 bNotify = sal_True;
4327 }
4328 }
4329 else if (( aElementType.equalsIgnoreAsciiCaseAscii( "statusbar" ) &&
4330 aElementName.equalsIgnoreAsciiCaseAscii( "statusbar" )) ||
4331 ( m_aStatusBarElement.m_aName == aName ))
4332 {
4333 aWriteLock.unlock();
4334 implts_destroyStatusBar();
4335 bMustLayouted = sal_True;
4336 bNotify = sal_True;
4337 }
4338 else if ( aElementType.equalsIgnoreAsciiCaseAscii( "progressbar" ) &&
4339 aElementName.equalsIgnoreAsciiCaseAscii( "progressbar" ) )
4340 {
4341 aWriteLock.unlock();
4342 implts_createProgressBar();
4343 bMustLayouted = sal_True;
4344 bNotify = sal_True;
4345 }
4346 else if ( aElementType.equalsIgnoreAsciiCaseAscii( "toolbar" ))
4347 {
4348 UIElementVector::iterator pIter;
4349
4350 for ( pIter = m_aUIElements.begin(); pIter != m_aUIElements.end(); pIter++ )
4351 {
4352 if ( pIter->m_aName == aName )
4353 {
4354 xComponent.set( pIter->m_xUIElement, UNO_QUERY );
4355 Reference< XUIElement > xUIElement( pIter->m_xUIElement );
4356 if ( xUIElement.is() )
4357 {
4358 Reference< css::awt::XWindow > xWindow( xUIElement->getRealInterface(), UNO_QUERY );
4359 Reference< css::awt::XDockableWindow > xDockWindow( xWindow, UNO_QUERY );
4360
4361 rtl::OUString aAddonTbResourceName( RTL_CONSTASCII_USTRINGPARAM( "private:resource/toolbar/addon_" ));
4362 if ( aName.indexOf( aAddonTbResourceName ) != 0 )
4363 {
4364 try
4365 {
4366 if ( xWindow.is() )
4367 xWindow->removeWindowListener( Reference< css::awt::XWindowListener >(
4368 static_cast< OWeakObject * >( this ), UNO_QUERY ));
4369 }
4370 catch( Exception& )
4371 {
4372 }
4373
4374 try
4375 {
4376 if ( xDockWindow.is() )
4377 xDockWindow->removeDockableWindowListener( Reference< css::awt::XDockableWindowListener >(
4378 static_cast< OWeakObject * >( this ), UNO_QUERY ));
4379 }
4380 catch ( Exception& )
4381 {
4382 }
4383
4384 bMustBeDestroyed = sal_True;
4385 }
4386 else
4387 {
4388 pIter->m_bVisible = sal_False;
4389 xWindow->setVisible( sal_False );
4390 bNotify = sal_True;
4391 }
4392
4393 if ( !xDockWindow->isFloating() )
4394 bMustLayouted = sal_True;
4395 if ( bMustBeDestroyed )
4396 pIter->m_xUIElement.clear();
4397
4398 bMustBeSorted = sal_True;
4399 }
4400
4401 break;
4402 }
4403 }
4404 }
4405 else if ( aElementType.equalsIgnoreAsciiCaseAscii( "dockingwindow" ))
4406 {
4407 css::uno::Reference< css::frame::XFrame > xFrame( m_xFrame );
4408 css::uno::Reference< css::lang::XMultiServiceFactory > xSMGR( m_xSMGR );
4409 aWriteLock.unlock();
4410
4411 impl_setDockingWindowVisibility( xSMGR, xFrame, aElementName, false );
4412 bMustLayouted = sal_False;
4413 bNotify = sal_False;
4414 }
4415 }
4416 aWriteLock.unlock();
4417 /* SAFE AREA ----------------------------------------------------------------------------------------------- */
4418
4419 if ( bMustBeDestroyed )
4420 {
4421 if ( xComponent.is() )
4422 xComponent->dispose();
4423 bNotify = sal_True;
4424 }
4425
4426 if ( bMustBeSorted )
4427 {
4428 implts_sortUIElements();
4429 if ( bMustLayouted )
4430 doLayout();
4431 }
4432
4433 if ( bNotify )
4434 {
4435 // UI element is invisible - provide information to listeners
4436 implts_notifyListeners( css::frame::LayoutManagerEvents::UIELEMENT_INVISIBLE, uno::makeAny( aName ) );
4437 }
4438 }
4439
4440 ::sal_Bool SAL_CALL LayoutManager::requestElement( const ::rtl::OUString& ResourceURL )
4441 throw (::com::sun::star::uno::RuntimeException)
4442 {
4443 RTL_LOGFILE_CONTEXT( aLog, "framework (cd100003) ::LayoutManager::requestElement" );
4444
4445 ::rtl::OUString aElementType;
4446 ::rtl::OUString aElementName;
4447 UIElementVector::iterator pIter;
4448 sal_Bool bResult( sal_False );
4449 sal_Bool bNotify( sal_False );
4450
4451 WriteGuard aWriteLock( m_aLock );
4452 if ( impl_parseResourceURL( ResourceURL, aElementType, aElementName ))
4453 {
4454 ::rtl::OString aResName = rtl::OUStringToOString( aElementName, RTL_TEXTENCODING_ASCII_US );
4455 RTL_LOGFILE_CONTEXT_TRACE1( aLog, "framework (cd100003) Element %s", aResName.getStr() );
4456
4457 if (( aElementType.equalsIgnoreAsciiCaseAscii( "statusbar" ) &&
4458 aElementName.equalsIgnoreAsciiCaseAscii( "statusbar" )) ||
4459 ( m_aStatusBarElement.m_aName == ResourceURL ))
4460 {
4461 implts_readStatusBarState( ResourceURL );
4462 if ( m_aStatusBarElement.m_bVisible && !m_aStatusBarElement.m_bMasterHide )
4463 {
4464 createElement( ResourceURL );
4465
4466 // There are some situation where we are not able to create an element.
4467 // Therefore we have to check the reference before further action.
4468 // See #i70019#
4469 css::uno::Reference< css::ui::XUIElement > xUIElement( m_aStatusBarElement.m_xUIElement );
4470 if ( xUIElement.is() )
4471 {
4472 // we need VCL here to pass special flags to Show()
4473 vos::OGuard aGuard( Application::GetSolarMutex() );
4474 Reference< css::awt::XWindow > xWindow( xUIElement->getRealInterface(), UNO_QUERY );
4475 Window* pWindow = VCLUnoHelper::GetWindow( xWindow );
4476 if ( pWindow )
4477 {
4478 pWindow->Show( TRUE, SHOW_NOFOCUSCHANGE | SHOW_NOACTIVATE );
4479 doLayout();
4480 bResult = sal_True;
4481 bNotify = sal_True;
4482 }
4483 }
4484 }
4485 }
4486 else if ( aElementType.equalsIgnoreAsciiCaseAscii( "progressbar" ) &&
4487 aElementName.equalsIgnoreAsciiCaseAscii( "progressbar" ) )
4488 {
4489 aWriteLock.unlock();
4490 implts_showProgressBar();
4491 doLayout();
4492 bResult = sal_True;
4493 bNotify = sal_True;
4494 }
4495 else if ( aElementType.equalsIgnoreAsciiCaseAscii( "toolbar" ))
4496 {
4497 if ( m_bVisible )
4498 {
4499 bool bFound( false );
4500 bool bShowElement( false );
4501
4502 for ( pIter = m_aUIElements.begin(); pIter != m_aUIElements.end(); pIter++ )
4503 {
4504 if ( pIter->m_aName == ResourceURL )
4505 {
4506 bFound = sal_True;
4507 bShowElement = ( pIter->m_bVisible && !pIter->m_bMasterHide && m_bParentWindowVisible );
4508
4509 Reference< css::awt::XWindow2 > xContainerWindow( m_xContainerWindow, UNO_QUERY );
4510 if ( xContainerWindow.is() && pIter->m_bFloating )
4511 bShowElement = ( bShowElement && xContainerWindow->isActive() );
4512
4513 if ( pIter->m_xUIElement.is() )
4514 {
4515 Reference< css::awt::XWindow > xWindow( pIter->m_xUIElement->getRealInterface(), UNO_QUERY );
4516 Reference< css::awt::XDockableWindow > xDockWindow( xWindow, UNO_QUERY );
4517
4518 if ( xDockWindow.is() && xDockWindow->isFloating() )
4519 bShowElement = ( bShowElement && xContainerWindow->isActive() );
4520
4521 if ( xDockWindow.is() && bShowElement )
4522 {
4523 pIter->m_bVisible = sal_True;
4524 aWriteLock.unlock();
4525
4526 // we need VCL here to pass special flags to Show()
4527 vos::OGuard aGuard( Application::GetSolarMutex() );
4528 Window* pWindow = VCLUnoHelper::GetWindow( xWindow );
4529 if( pWindow && !pWindow->IsReallyVisible() )
4530 {
4531 pWindow->Show( TRUE, SHOW_NOFOCUSCHANGE | SHOW_NOACTIVATE );
4532 implts_writeNewStateData( ResourceURL, xWindow );
4533
4534 if ( xDockWindow.is() && !xDockWindow->isFloating() )
4535 doLayout();
4536 bResult = sal_True;
4537 bNotify = sal_True;
4538 }
4539
4540 bResult = sal_False;
4541 }
4542 } // if ( pIter->m_xUIElement.is() )
4543 break;
4544 }
4545 }
4546
4547 // Create toolbar on demand when it's visible
4548 if ( !bResult )
4549 {
4550 Reference< ::com::sun::star::ui::XUIElement > xUIElement;
4551 if ( !bFound )
4552 {
4553 UIElement aNewToolbar( aElementName, aElementType, xUIElement );
4554 aNewToolbar.m_aName = ResourceURL;
4555 implts_readWindowStateData( ResourceURL, aNewToolbar );
4556 implts_insertUIElement( aNewToolbar );
4557 aWriteLock.unlock();
4558
4559 implts_sortUIElements();
4560 if ( aNewToolbar.m_bVisible )
4561 createElement( ResourceURL );
4562 bResult = sal_True;
4563 bNotify = sal_True;
4564 }
4565 else if ( bShowElement )
4566 {
4567 aWriteLock.unlock();
4568
4569 createElement( ResourceURL );
4570 bResult = sal_True;
4571 bNotify = sal_True;
4572 }
4573 }
4574 }
4575 }
4576 else if ( aElementType.equalsIgnoreAsciiCaseAscii( "dockingwindow" ))
4577 {
4578 css::uno::Reference< css::frame::XFrame > xFrame( m_xFrame );
4579 aWriteLock.unlock();
4580
4581 CreateDockingWindow( xFrame, aElementName );
4582 }
4583 }
4584
4585 if ( bNotify )
4586 {
4587 // UI element is visible - provide information to listeners
4588 implts_notifyListeners( css::frame::LayoutManagerEvents::UIELEMENT_VISIBLE, uno::makeAny( ResourceURL ) );
4589 }
4590
4591 return bResult;
4592 }
4593
4594 Reference< XUIElement > SAL_CALL LayoutManager::getElement( const ::rtl::OUString& aName )
4595 throw (RuntimeException)
4596 {
4597 ::rtl::OUString aElementType;
4598 ::rtl::OUString aElementName;
4599 Reference< XUIElement > xElement;
4600
4601 implts_findElement( aName, aElementType, aElementName, xElement );
4602 return xElement;
4603 }
4604
4605 Sequence< Reference< ::com::sun::star::ui::XUIElement > > SAL_CALL LayoutManager::getElements()
4606 throw (::com::sun::star::uno::RuntimeException)
4607 {
4608 ReadGuard aReadLock( m_aLock );
4609
4610 sal_Bool bMenuBar( sal_False );
4611 sal_Bool bStatusBar( sal_False );
4612 sal_Int32 nSize = m_aUIElements.size();
4613
4614 if ( m_xMenuBar.is() )
4615 {
4616 ++nSize;
4617 bMenuBar = sal_True;
4618 }
4619 if ( m_aStatusBarElement.m_xUIElement.is() )
4620 {
4621 ++nSize;
4622 bStatusBar = sal_True;
4623 }
4624
4625 Sequence< Reference< ::com::sun::star::ui::XUIElement > > aSeq( nSize );
4626
4627 sal_Int32 nIndex = 0;
4628 UIElementVector::const_iterator pIter;
4629 for ( pIter = m_aUIElements.begin(); pIter != m_aUIElements.end(); pIter++ )
4630 {
4631 if ( pIter->m_xUIElement.is() )
4632 aSeq[nIndex++] = pIter->m_xUIElement;
4633 }
4634 if ( bMenuBar )
4635 aSeq[nIndex++] = m_xMenuBar;
4636 if ( bStatusBar )
4637 aSeq[nIndex++] = m_aStatusBarElement.m_xUIElement;
4638
4639 // Resize sequence as we now know our correct size
4640 aSeq.realloc( nIndex );
4641
4642 return aSeq;
4643 }
4644
4645 sal_Bool SAL_CALL LayoutManager::showElement( const ::rtl::OUString& aName )
4646 throw (RuntimeException)
4647 {
4648 RTL_LOGFILE_CONTEXT( aLog, "framework (cd100003) ::LayoutManager::showElement" );
4649
4650 sal_Bool bResult( sal_False );
4651 sal_Bool bNotify( sal_False );
4652 ::rtl::OUString aElementType;
4653 ::rtl::OUString aElementName;
4654
4655 if ( impl_parseResourceURL( aName, aElementType, aElementName ))
4656 {
4657 ::rtl::OString aResName = rtl::OUStringToOString( aElementName, RTL_TEXTENCODING_ASCII_US );
4658 RTL_LOGFILE_CONTEXT_TRACE1( aLog, "framework (cd100003) Element %s", aResName.getStr() );
4659
4660 if ( aElementType.equalsIgnoreAsciiCaseAscii( "menubar" ) &&
4661 aElementName.equalsIgnoreAsciiCaseAscii( "menubar" ))
4662 {
4663 WriteGuard aWriteLock( m_aLock );
4664 m_bMenuVisible = sal_True;
4665 aWriteLock.unlock();
4666
4667 bResult = implts_resetMenuBar();
4668 bNotify = bResult;
4669 }
4670 else if (( aElementType.equalsIgnoreAsciiCaseAscii( "statusbar" ) &&
4671 aElementName.equalsIgnoreAsciiCaseAscii( "statusbar" )) ||
4672 ( m_aStatusBarElement.m_aName == aName ))
4673 {
4674 WriteGuard aWriteLock( m_aLock );
4675 if ( m_aStatusBarElement.m_xUIElement.is() &&
4676 !m_aStatusBarElement.m_bMasterHide )
4677 {
4678 if ( implts_showStatusBar( sal_True ))
4679 {
4680 implts_writeWindowStateData( m_aStatusBarAlias, m_aStatusBarElement );
4681 doLayout();
4682 bResult = sal_True;
4683 bNotify = sal_True;
4684 }
4685 }
4686 }
4687 else if ( aElementType.equalsIgnoreAsciiCaseAscii( "progressbar" ) &&
4688 aElementName.equalsIgnoreAsciiCaseAscii( "progressbar" ))
4689 {
4690 bNotify = bResult = implts_showProgressBar();
4691 }
4692 else if ( aElementType.equalsIgnoreAsciiCaseAscii( "toolbar" ))
4693 {
4694 UIElementVector::iterator pIter;
4695
4696 WriteGuard aWriteLock( m_aLock );
4697 for ( pIter = m_aUIElements.begin(); pIter != m_aUIElements.end(); pIter++ )
4698 {
4699 if ( pIter->m_aName == aName && pIter->m_xUIElement.is() )
4700 {
4701 UIElement aUIElement = *pIter;
4702 Reference< css::awt::XWindow > xWindow( pIter->m_xUIElement->getRealInterface(), UNO_QUERY );
4703 Reference< css::awt::XDockableWindow > xDockWindow( xWindow, UNO_QUERY );
4704
4705 sal_Bool bShowElement( !pIter->m_bMasterHide && m_bParentWindowVisible );
4706
4707 pIter->m_bVisible = sal_True;
4708 aWriteLock.unlock();
4709
4710 implts_writeWindowStateData( aUIElement.m_aName, aUIElement );
4711 implts_sortUIElements();
4712
4713 if ( xDockWindow.is() && bShowElement )
4714 {
4715 // we need VCL here to pass special flags to Show()
4716 vos::OGuard aGuard( Application::GetSolarMutex() );
4717 Window* pWindow = VCLUnoHelper::GetWindow( xWindow );
4718 if( pWindow )
4719 {
4720 pWindow->Show( TRUE, SHOW_NOFOCUSCHANGE | SHOW_NOACTIVATE );
4721 bNotify = sal_True;
4722 }
4723 implts_writeNewStateData( aName, xWindow );
4724
4725 if ( xDockWindow.is() && !xDockWindow->isFloating() )
4726 doLayout();
4727
4728 bResult = sal_True;
4729 } // if ( xDockWindow.is() && bShowElement )
4730 break;
4731 }
4732 }
4733 }
4734 else if ( aElementType.equalsIgnoreAsciiCaseAscii( "dockingwindow" ))
4735 {
4736 ReadGuard aReadGuard( m_aLock );
4737 css::uno::Reference< css::frame::XFrame > xFrame( m_xFrame );
4738 css::uno::Reference< css::lang::XMultiServiceFactory > xSMGR( m_xSMGR );
4739 aReadGuard.unlock();
4740
4741 impl_setDockingWindowVisibility( xSMGR, xFrame, aElementName, true );
4742 }
4743 }
4744
4745 if ( bNotify )
4746 {
4747 // UI element is visible - provide information to listeners
4748 implts_notifyListeners( css::frame::LayoutManagerEvents::UIELEMENT_VISIBLE, uno::makeAny( aName ) );
4749 }
4750
4751 return bResult;
4752 }
4753
4754 sal_Bool SAL_CALL LayoutManager::hideElement( const ::rtl::OUString& aName )
4755 throw (RuntimeException)
4756 {
4757 RTL_LOGFILE_CONTEXT( aLog, "framework (cd100003) ::LayoutManager::hideElement" );
4758
4759
4760 sal_Bool bResult( sal_False );
4761 sal_Bool bNotify( sal_False );
4762 ::rtl::OUString aElementType;
4763 ::rtl::OUString aElementName;
4764
4765 if ( impl_parseResourceURL( aName, aElementType, aElementName ))
4766 {
4767 ::rtl::OString aResName = rtl::OUStringToOString( aElementName, RTL_TEXTENCODING_ASCII_US );
4768 RTL_LOGFILE_CONTEXT_TRACE1( aLog, "framework (cd100003) Element %s", aResName.getStr() );
4769
4770 if ( aElementType.equalsIgnoreAsciiCaseAscii( "menubar" ) &&
4771 aElementName.equalsIgnoreAsciiCaseAscii( "menubar" ))
4772 {
4773 WriteGuard aWriteLock( m_aLock );
4774
4775 if ( m_xContainerWindow.is() )
4776 {
4777 vos::OGuard aGuard( Application::GetSolarMutex() );
4778 Window* pWindow = VCLUnoHelper::GetWindow( m_xContainerWindow );
4779 while ( pWindow && !pWindow->IsSystemWindow() )
4780 pWindow = pWindow->GetParent();
4781
4782 m_bMenuVisible = sal_False;
4783 if ( pWindow )
4784 {
4785 MenuBar* pMenuBar = ((SystemWindow *)pWindow)->GetMenuBar();
4786 if ( pMenuBar )
4787 {
4788 pMenuBar->SetDisplayable( sal_False );
4789 bResult = sal_True;
4790 bNotify = sal_True;
4791 }
4792 }
4793 }
4794 }
4795 else if (( aElementType.equalsIgnoreAsciiCaseAscii( "statusbar" ) &&
4796 aElementName.equalsIgnoreAsciiCaseAscii( "statusbar" )) ||
4797 ( m_aStatusBarElement.m_aName == aName ))
4798 {
4799 WriteGuard aWriteLock( m_aLock );
4800 if ( m_aStatusBarElement.m_xUIElement.is() &&
4801 !m_aStatusBarElement.m_bMasterHide )
4802 {
4803 if ( implts_hideStatusBar( sal_True ))
4804 {
4805 implts_writeWindowStateData( m_aStatusBarAlias, m_aStatusBarElement );
4806 doLayout();
4807 bNotify = sal_True;
4808 bResult = sal_True;
4809 }
4810 }
4811 }
4812 else if ( aElementType.equalsIgnoreAsciiCaseAscii( "progressbar" ) &&
4813 aElementName.equalsIgnoreAsciiCaseAscii( "progressbar" ))
4814 {
4815 bResult = bNotify = implts_hideProgressBar();
4816 }
4817 else if ( aElementType.equalsIgnoreAsciiCaseAscii( "toolbar" ))
4818 {
4819 UIElementVector::iterator pIter;
4820
4821 WriteGuard aWriteLock( m_aLock );
4822 for ( pIter = m_aUIElements.begin(); pIter != m_aUIElements.end(); pIter++ )
4823 {
4824 if ( pIter->m_aName == aName && pIter->m_xUIElement.is() )
4825 {
4826 Reference< css::awt::XWindow > xWindow( pIter->m_xUIElement->getRealInterface(), UNO_QUERY );
4827 Reference< css::awt::XDockableWindow > xDockWindow( xWindow, UNO_QUERY );
4828
4829 if ( xDockWindow.is() )
4830 {
4831 pIter->m_bVisible = sal_False;
4832 aWriteLock.unlock();
4833
4834 xWindow->setVisible( sal_False );
4835 implts_writeNewStateData( aName, xWindow );
4836
4837 if ( xDockWindow.is() && !xDockWindow->isFloating() )
4838 doLayout();
4839
4840 bResult = sal_True;
4841 bNotify = sal_True;
4842 } // if ( xDockWindow.is() )
4843 break;
4844 }
4845 }
4846 }
4847 else if ( aElementType.equalsIgnoreAsciiCaseAscii( "dockingwindow" ))
4848 {
4849 ReadGuard aReadGuard( m_aLock );
4850 css::uno::Reference< css::frame::XFrame > xFrame( m_xFrame );
4851 css::uno::Reference< css::lang::XMultiServiceFactory > xSMGR( m_xSMGR );
4852 aReadGuard.unlock();
4853
4854 impl_setDockingWindowVisibility( xSMGR, xFrame, aElementName, false );
4855 }
4856 }
4857
4858 if ( bNotify )
4859 {
4860 // UI element is visible - provide information to listeners
4861 implts_notifyListeners( css::frame::LayoutManagerEvents::UIELEMENT_INVISIBLE, uno::makeAny( aName ) );
4862 }
4863
4864 return sal_False;
4865 }
4866
4867 sal_Bool SAL_CALL LayoutManager::dockWindow( const ::rtl::OUString& aName, DockingArea DockingArea, const css::awt::Point& Pos )
4868 throw (RuntimeException)
4869 {
4870 UIElement aUIElement;
4871
4872 if ( implts_findElement( aName, aUIElement ) && aUIElement.m_xUIElement.is() )
4873 {
4874 try
4875 {
4876 Reference< css::awt::XWindow > xWindow( aUIElement.m_xUIElement->getRealInterface(), UNO_QUERY );
4877 Reference< css::awt::XDockableWindow > xDockWindow( xWindow, UNO_QUERY );
4878 if ( xDockWindow.is() )
4879 {
4880 if ( DockingArea != DockingArea_DOCKINGAREA_DEFAULT )
4881 aUIElement.m_aDockedData.m_nDockedArea = sal_Int16( DockingArea );
4882
4883 if (( Pos.X != SAL_MAX_INT32 ) && ( Pos.Y != SAL_MAX_INT32 ))
4884 aUIElement.m_aDockedData.m_aPos = ::Point( Pos.X, Pos.Y );
4885
4886 if ( !xDockWindow->isFloating() )
4887 {
4888 Window* pWindow( 0 );
4889 ToolBox* pToolBox( 0 );
4890
4891 {
4892 vos::OGuard aGuard( Application::GetSolarMutex() );
4893 pWindow = VCLUnoHelper::GetWindow( xWindow );
4894 if ( pWindow && pWindow->GetType() == WINDOW_TOOLBOX )
4895 {
4896 pToolBox = (ToolBox *)pWindow;
4897
4898 // We have to set the alignment of the toolbox. It's possible that the toolbox is moved from a
4899 // horizontal to a vertical docking area!
4900 pToolBox->SetAlign( ImplConvertAlignment( aUIElement.m_aDockedData.m_nDockedArea ));
4901 }
4902 }
4903
4904 if (( aUIElement.m_aDockedData.m_aPos.X() == SAL_MAX_INT32 ) ||
4905 ( aUIElement.m_aDockedData.m_aPos.Y() == SAL_MAX_INT32 ))
4906 {
4907 // Docking on its default position without a preset position -
4908 // we have to find a good place for it.
4909 ::Size aSize;
4910
4911 vos::OGuard aGuard( Application::GetSolarMutex() );
4912 {
4913 if ( pToolBox )
4914 aSize = pToolBox->CalcWindowSizePixel( 1, ImplConvertAlignment( aUIElement.m_aDockedData.m_nDockedArea ) );
4915 else
4916 aSize = pWindow->GetSizePixel();
4917 }
4918
4919 ::Point aPixelPos;
4920 ::Point aDockPos;
4921 implts_findNextDockingPos( (::com::sun::star::ui::DockingArea)aUIElement.m_aDockedData.m_nDockedArea,
4922 aSize,
4923 aDockPos,
4924 aPixelPos );
4925 aUIElement.m_aDockedData.m_aPos = aDockPos;
4926 }
4927 }
4928
4929 WriteGuard aWriteLock( m_aLock );
4930 UIElement& rUIElement = LayoutManager::impl_findElement( aUIElement.m_aName );
4931 if ( rUIElement.m_aName == aName )
4932 {
4933 rUIElement.m_aDockedData.m_nDockedArea = aUIElement.m_aDockedData.m_nDockedArea;
4934 rUIElement.m_aDockedData.m_aPos = aUIElement.m_aDockedData.m_aPos;
4935 }
4936 aWriteLock.unlock();
4937
4938 if ( xDockWindow->isFloating() )
4939 {
4940 // Will call toggle floating mode which will do the rest!
4941 xWindow->setVisible( sal_False );
4942 xDockWindow->setFloatingMode( sal_False );
4943 xWindow->setVisible( sal_True );
4944 }
4945 else
4946 {
4947 implts_writeWindowStateData( aName, aUIElement );
4948 implts_sortUIElements();
4949
4950 if ( aUIElement.m_bVisible )
4951 doLayout();
4952 }
4953
4954 return sal_True;
4955 }
4956 }
4957 catch ( DisposedException& )
4958 {
4959 }
4960 }
4961
4962 return sal_False;
4963 }
4964
4965 ::sal_Bool SAL_CALL LayoutManager::dockAllWindows( ::sal_Int16 nElementType ) throw (::com::sun::star::uno::RuntimeException)
4966 {
4967 if ( nElementType == UIElementType::TOOLBAR )
4968 {
4969 std::vector< rtl::OUString > aToolBarNameVector;
4970
4971 ::rtl::OUString aElementType;
4972 ::rtl::OUString aElementName;
4973
4974 {
4975 ReadGuard aReadLock( m_aLock );
4976 UIElementVector::iterator pIter;
4977 for ( pIter = m_aUIElements.begin(); pIter != m_aUIElements.end(); pIter++ )
4978 {
4979 if ( pIter->m_aType.equalsAscii( "toolbar" ) &&
4980 pIter->m_xUIElement.is() &&
4981 pIter->m_bFloating &&
4982 pIter->m_bVisible )
4983 aToolBarNameVector.push_back( pIter->m_aName );
4984 }
4985 }
4986
4987 const sal_uInt32 nCount = aToolBarNameVector.size();
4988 for ( sal_uInt32 i = 0; i < nCount; ++i )
4989 {
4990 ::com::sun::star::awt::Point aPoint;
4991 aPoint.X = aPoint.Y = SAL_MAX_INT32;
4992 dockWindow( aToolBarNameVector[i], DockingArea_DOCKINGAREA_DEFAULT, aPoint );
4993 }
4994 }
4995
4996 return sal_False;
4997 }
4998
4999 sal_Bool SAL_CALL LayoutManager::floatWindow( const ::rtl::OUString& aName )
5000 throw (RuntimeException)
5001 {
5002 UIElement aUIElement;
5003
5004 if ( implts_findElement( aName, aUIElement ))
5005 {
5006 if ( aUIElement.m_xUIElement.is() )
5007 {
5008 try
5009 {
5010 Reference< css::awt::XWindow > xWindow( aUIElement.m_xUIElement->getRealInterface(), UNO_QUERY );
5011 Reference< css::awt::XDockableWindow > xDockWindow( xWindow, UNO_QUERY );
5012 if ( xWindow.is() && xDockWindow.is() )
5013 {
5014 if ( !xDockWindow->isFloating() )
5015 {
5016 xDockWindow->setFloatingMode( sal_True );
5017 return sal_True;
5018 }
5019 }
5020 }
5021 catch ( DisposedException& )
5022 {
5023 }
5024 }
5025 }
5026
5027 return sal_False;
5028 }
5029
5030 ::sal_Bool SAL_CALL LayoutManager::lockWindow( const ::rtl::OUString& ResourceURL )
5031 throw (::com::sun::star::uno::RuntimeException)
5032 {
5033 UIElement aUIElement;
5034
5035 if ( implts_findElement( ResourceURL, aUIElement ))
5036 {
5037 if ( aUIElement.m_xUIElement.is() )
5038 {
5039 try
5040 {
5041 Reference< css::awt::XWindow > xWindow( aUIElement.m_xUIElement->getRealInterface(), UNO_QUERY );
5042 Reference< css::awt::XDockableWindow > xDockWindow( xWindow, UNO_QUERY );
5043 Window* pWindow = VCLUnoHelper::GetWindow( xWindow );
5044 if ( pWindow &&
5045 pWindow->IsVisible() &&
5046 xDockWindow.is() &&
5047 !xDockWindow->isFloating() )
5048 {
5049 aUIElement.m_aDockedData.m_bLocked = sal_True;
5050 implts_writeWindowStateData( ResourceURL, aUIElement );
5051 xDockWindow->lock();
5052
5053 // Write back lock state
5054 WriteGuard aWriteLock( m_aLock );
5055 UIElement& rUIElement = LayoutManager::impl_findElement( aUIElement.m_aName );
5056 if ( rUIElement.m_aName == aUIElement.m_aName )
5057 rUIElement.m_aDockedData.m_bLocked = aUIElement.m_aDockedData.m_bLocked;
5058 aWriteLock.unlock();
5059
5060 doLayout();
5061 return sal_True;
5062 }
5063 }
5064 catch ( DisposedException& )
5065 {
5066 }
5067 }
5068 }
5069
5070 return sal_False;
5071 }
5072
5073 ::sal_Bool SAL_CALL LayoutManager::unlockWindow( const ::rtl::OUString& ResourceURL )
5074 throw (::com::sun::star::uno::RuntimeException)
5075 {
5076 UIElement aUIElement;
5077
5078 if ( implts_findElement( ResourceURL, aUIElement ))
5079 {
5080 if ( aUIElement.m_xUIElement.is() )
5081 {
5082 try
5083 {
5084 Reference< css::awt::XWindow > xWindow( aUIElement.m_xUIElement->getRealInterface(), UNO_QUERY );
5085 Reference< css::awt::XDockableWindow > xDockWindow( xWindow, UNO_QUERY );
5086 Window* pWindow = VCLUnoHelper::GetWindow( xWindow );
5087 if ( pWindow &&
5088 pWindow->IsVisible() &&
5089 xDockWindow.is() &&
5090 !xDockWindow->isFloating() )
5091 {
5092 aUIElement.m_aDockedData.m_bLocked = sal_False;
5093 implts_writeWindowStateData( ResourceURL, aUIElement );
5094 xDockWindow->unlock();
5095
5096 // Write back lock state
5097 WriteGuard aWriteLock( m_aLock );
5098 UIElement& rUIElement = LayoutManager::impl_findElement( aUIElement.m_aName );
5099 if ( rUIElement.m_aName == aUIElement.m_aName )
5100 rUIElement.m_aDockedData.m_bLocked = aUIElement.m_aDockedData.m_bLocked;
5101 aWriteLock.unlock();
5102
5103 doLayout();
5104 return sal_True;
5105 }
5106 }
5107 catch ( DisposedException& )
5108 {
5109 }
5110 }
5111 }
5112
5113 return sal_False;
5114 }
5115
5116 void SAL_CALL LayoutManager::setElementSize( const ::rtl::OUString& aName, const css::awt::Size& aSize )
5117 throw (RuntimeException)
5118 {
5119 UIElement aUIElement;
5120
5121 if ( implts_findElement( aName, aUIElement ))
5122 {
5123 if ( aUIElement.m_xUIElement.is() )
5124 {
5125 try
5126 {
5127 Reference< css::awt::XWindow > xWindow( aUIElement.m_xUIElement->getRealInterface(), UNO_QUERY );
5128 Reference< css::awt::XWindow2 > xWindow2( aUIElement.m_xUIElement->getRealInterface(), UNO_QUERY );
5129 Reference< css::awt::XDockableWindow > xDockWindow( xWindow, UNO_QUERY );
5130
5131 if ( xWindow.is() && xWindow2.is() && xDockWindow.is() )
5132 {
5133 if ( aUIElement.m_bFloating )
5134 {
5135 xWindow2->setOutputSize( aSize );
5136 implts_writeNewStateData( aName, xWindow );
5137 }
5138 }
5139 }
5140 catch ( DisposedException& )
5141 {
5142 }
5143 }
5144 }
5145 }
5146
5147 void SAL_CALL LayoutManager::setElementPos( const ::rtl::OUString& aName, const css::awt::Point& aPos )
5148 throw (RuntimeException)
5149 {
5150 UIElement aUIElement;
5151
5152 if ( implts_findElement( aName, aUIElement ) && aUIElement.m_xUIElement.is() )
5153 {
5154 try
5155 {
5156 Reference< css::awt::XWindow > xWindow( aUIElement.m_xUIElement->getRealInterface(), UNO_QUERY );
5157 Reference< css::awt::XDockableWindow > xDockWindow( xWindow, UNO_QUERY );
5158
5159 if ( xWindow.is() && xDockWindow.is() )
5160 {
5161 if ( aUIElement.m_bFloating )
5162 {
5163 xWindow->setPosSize( aPos.X, aPos.Y, 0, 0, css::awt::PosSize::POS );
5164 implts_writeNewStateData( aName, xWindow );
5165 }
5166 else
5167 {
5168 WriteGuard aWriteLock( m_aLock );
5169 UIElement& rUIElement = LayoutManager::impl_findElement( aUIElement.m_aName );
5170 if ( rUIElement.m_aName == aName )
5171 rUIElement.m_aDockedData.m_aPos = ::Point( aPos.X, aPos.Y );
5172 aWriteLock.unlock();
5173
5174 aUIElement.m_aDockedData.m_aPos = ::Point( aPos.X, aPos.Y );
5175 implts_writeWindowStateData( aName, aUIElement );
5176 implts_sortUIElements();
5177
5178 if ( aUIElement.m_bVisible )
5179 doLayout();
5180 }
5181 }
5182 }
5183 catch ( DisposedException& )
5184 {
5185 }
5186 }
5187 }
5188
5189 void SAL_CALL LayoutManager::setElementPosSize( const ::rtl::OUString& aName, const css::awt::Point& aPos, const css::awt::Size& aSize )
5190 throw (RuntimeException)
5191 {
5192 UIElement aUIElement;
5193
5194 if ( implts_findElement( aName, aUIElement ))
5195 {
5196 if ( aUIElement.m_xUIElement.is() )
5197 {
5198 try
5199 {
5200 Reference< css::awt::XWindow > xWindow( aUIElement.m_xUIElement->getRealInterface(), UNO_QUERY );
5201 Reference< css::awt::XWindow2 > xWindow2( aUIElement.m_xUIElement->getRealInterface(), UNO_QUERY );
5202 Reference< css::awt::XDockableWindow > xDockWindow( xWindow, UNO_QUERY );
5203
5204 if ( xWindow.is() && xWindow2.is() && xDockWindow.is() )
5205 {
5206 if ( aUIElement.m_bFloating )
5207 {
5208 xWindow2->setPosSize( aPos.X, aPos.Y, 0, 0, css::awt::PosSize::POS );
5209 xWindow2->setOutputSize( aSize );
5210 implts_writeNewStateData( aName, xWindow );
5211 }
5212 else
5213 {
5214 WriteGuard aWriteLock( m_aLock );
5215 UIElement& rUIElement = LayoutManager::impl_findElement( aUIElement.m_aName );
5216 if ( rUIElement.m_aName == aName )
5217 rUIElement.m_aDockedData.m_aPos = ::Point( aPos.X, aPos.Y );
5218 aWriteLock.unlock();
5219
5220 aUIElement.m_aDockedData.m_aPos = ::Point( aPos.X, aPos.Y );
5221 implts_writeWindowStateData( aName, rUIElement );
5222 implts_sortUIElements();
5223
5224 if ( aUIElement.m_bVisible )
5225 doLayout();
5226 }
5227 }
5228 }
5229 catch ( DisposedException& )
5230 {
5231 }
5232 }
5233 }
5234 }
5235
5236 sal_Bool SAL_CALL LayoutManager::isElementVisible( const ::rtl::OUString& aName )
5237 throw (RuntimeException)
5238 {
5239 ::rtl::OUString aElementType;
5240 ::rtl::OUString aElementName;
5241
5242 if ( impl_parseResourceURL( aName, aElementType, aElementName ))
5243 {
5244 if ( aElementType.equalsIgnoreAsciiCaseAscii( "menubar" ) &&
5245 aElementName.equalsIgnoreAsciiCaseAscii( "menubar" ))
5246 {
5247 ReadGuard aReadLock( m_aLock );
5248 if ( m_xContainerWindow.is() )
5249 {
5250 aReadLock.unlock();
5251
5252 vos::OGuard aGuard( Application::GetSolarMutex() );
5253 Window* pWindow = VCLUnoHelper::GetWindow( m_xContainerWindow );
5254 while ( pWindow && !pWindow->IsSystemWindow() )
5255 pWindow = pWindow->GetParent();
5256
5257 if ( pWindow )
5258 {
5259 MenuBar* pMenuBar = ((SystemWindow *)pWindow)->GetMenuBar();
5260 if ( pMenuBar && pMenuBar->IsDisplayable() )
5261 return sal_True;
5262 }
5263 else
5264 {
5265 aReadLock.lock();
5266 return m_bMenuVisible;
5267 }
5268 }
5269 }
5270 else if (( aElementType.equalsIgnoreAsciiCaseAscii( "statusbar" ) &&
5271 aElementName.equalsIgnoreAsciiCaseAscii( "statusbar" )) ||
5272 ( m_aStatusBarElement.m_aName == aName ))
5273 {
5274 if ( m_aStatusBarElement.m_xUIElement.is() )
5275 {
5276 Reference< css::awt::XWindow > xWindow(
5277 m_aStatusBarElement.m_xUIElement->getRealInterface(), UNO_QUERY );
5278 if ( xWindow.is() )
5279 {
5280 Window* pWindow = VCLUnoHelper::GetWindow( xWindow );
5281 if ( pWindow && pWindow->IsVisible() )
5282 return sal_True;
5283 else
5284 return sal_False;
5285 }
5286 }
5287 }
5288 else if (( aElementType.equalsIgnoreAsciiCaseAscii( "progressbar" ) &&
5289 aElementName.equalsIgnoreAsciiCaseAscii( "progressbar" )))
5290 {
5291 if ( m_aProgressBarElement.m_xUIElement.is() )
5292 return m_aProgressBarElement.m_bVisible;
5293 }
5294 else if ( aElementType.equalsIgnoreAsciiCaseAscii( "toolbar" ))
5295 {
5296 UIElementVector::const_iterator pIter;
5297
5298 ReadGuard aReadLock( m_aLock );
5299 for ( pIter = m_aUIElements.begin(); pIter != m_aUIElements.end(); pIter++ )
5300 {
5301 if ( pIter->m_aName == aName && pIter->m_xUIElement.is() )
5302 {
5303 Reference< css::awt::XWindow > xWindow( pIter->m_xUIElement->getRealInterface(), UNO_QUERY );
5304 if ( xWindow.is() )
5305 {
5306 Window* pWindow = VCLUnoHelper::GetWindow( xWindow );
5307 return pWindow && pWindow->IsVisible();
5308 }
5309 }
5310 }
5311 }
5312 else if ( aElementType.equalsIgnoreAsciiCaseAscii( "dockingwindow" ))
5313 {
5314 ReadGuard aReadGuard( m_aLock );
5315 css::uno::Reference< css::frame::XFrame > xFrame( m_xFrame );
5316 aReadGuard.unlock();
5317
5318 return IsDockingWindowVisible( xFrame, aElementName );
5319 }
5320 }
5321
5322 return sal_False;
5323 }
5324
5325 sal_Bool SAL_CALL LayoutManager::isElementFloating( const ::rtl::OUString& aName )
5326 throw (RuntimeException)
5327 {
5328 UIElementVector::const_iterator pIter;
5329
5330 ReadGuard aReadLock( m_aLock );
5331 for ( pIter = m_aUIElements.begin(); pIter != m_aUIElements.end(); pIter++ )
5332 {
5333 if ( pIter->m_aName == aName && pIter->m_xUIElement.is() )
5334 {
5335 Reference< css::awt::XDockableWindow > xDockWindow( pIter->m_xUIElement->getRealInterface(), UNO_QUERY );
5336 return xDockWindow.is() && xDockWindow->isFloating();
5337 }
5338 }
5339
5340 return sal_False;
5341 }
5342
5343 sal_Bool SAL_CALL LayoutManager::isElementDocked( const ::rtl::OUString& aName )
5344 throw (RuntimeException)
5345 {
5346 UIElementVector::const_iterator pIter;
5347
5348 ReadGuard aReadLock( m_aLock );
5349 for ( pIter = m_aUIElements.begin(); pIter != m_aUIElements.end(); pIter++ )
5350 {
5351 if ( pIter->m_aName == aName && pIter->m_xUIElement.is() )
5352 {
5353 Reference< css::awt::XDockableWindow > xDockWindow( pIter->m_xUIElement->getRealInterface(), UNO_QUERY );
5354 return xDockWindow.is() && !xDockWindow->isFloating();
5355 }
5356 }
5357
5358 return sal_False;
5359 }
5360
5361 ::sal_Bool SAL_CALL LayoutManager::isElementLocked( const ::rtl::OUString& ResourceURL )
5362 throw (::com::sun::star::uno::RuntimeException)
5363 {
5364 UIElementVector::const_iterator pIter;
5365
5366 ReadGuard aReadLock( m_aLock );
5367 for ( pIter = m_aUIElements.begin(); pIter != m_aUIElements.end(); pIter++ )
5368 {
5369 if (( pIter->m_aName == ResourceURL ) && ( pIter->m_xUIElement.is() ))
5370 {
5371 Reference< css::awt::XDockableWindow > xDockWindow( pIter->m_xUIElement->getRealInterface(), UNO_QUERY );
5372 return xDockWindow.is() && !xDockWindow->isLocked();
5373 }
5374 }
5375
5376 return sal_False;
5377 }
5378
5379 css::awt::Size SAL_CALL LayoutManager::getElementSize( const ::rtl::OUString& aName )
5380 throw (RuntimeException)
5381 {
5382 ReadGuard aReadLock( m_aLock );
5383 UIElement aElementData;
5384 if ( implts_findElement( aName,aElementData ) && aElementData.m_xUIElement.is() )
5385 {
5386 Reference< css::awt::XWindow > xWindow( aElementData.m_xUIElement->getRealInterface(), UNO_QUERY );
5387 if ( xWindow.is() )
5388 {
5389 Window* pWindow = VCLUnoHelper::GetWindow( xWindow );
5390 if ( pWindow )
5391 {
5392 ::Size aSize = pWindow->GetSizePixel();
5393 css::awt::Size aElementSize;
5394 aElementSize.Width = aSize.Width();
5395 aElementSize.Height = aSize.Height();
5396 return aElementSize;
5397 } // if ( pWindow )
5398 }
5399 }
5400 return css::awt::Size();
5401 }
5402
5403 css::awt::Point SAL_CALL LayoutManager::getElementPos( const ::rtl::OUString& aName )
5404 throw (RuntimeException)
5405 {
5406 ReadGuard aReadLock( m_aLock );
5407 UIElement aElementData;
5408 if ( implts_findElement( aName,aElementData ) && aElementData.m_xUIElement.is() )
5409 {
5410 Reference< css::awt::XWindow > xWindow( aElementData.m_xUIElement->getRealInterface(), UNO_QUERY );
5411 Reference< css::awt::XDockableWindow > xDockWindow( xWindow, UNO_QUERY );
5412 if ( xDockWindow.is() )
5413 {
5414 css::awt::Point aPos;
5415 if ( aElementData.m_bFloating )
5416 {
5417 css::awt::Rectangle aRect = xWindow->getPosSize();
5418 aPos.X = aRect.X;
5419 aPos.Y = aRect.Y;
5420 }
5421 else
5422 {
5423 ::Point aVirtualPos = aElementData.m_aDockedData.m_aPos;
5424 aPos.X = aVirtualPos.X();
5425 aPos.Y = aVirtualPos.Y();
5426 }
5427
5428 return aPos;
5429 }
5430 }
5431
5432 return css::awt::Point();
5433 }
5434
5435 void SAL_CALL LayoutManager::lock()
5436 throw (RuntimeException)
5437 {
5438 implts_lock();
5439
5440 ReadGuard aReadLock( m_aLock );
5441 sal_Int32 nLockCount( m_nLockCount );
5442 aReadLock.unlock();
5443
5444 RTL_LOGFILE_TRACE1( "framework (cd100003) ::LayoutManager::lock lockCount=%d", nLockCount );
5445 #ifdef DBG_UTIL
5446 ByteString aStr("LayoutManager::lock ");
5447 aStr += ByteString::CreateFromInt32((long)this);
5448 aStr += " - ";
5449 aStr += ByteString::CreateFromInt32(nLockCount);
5450 DBG_TRACE( aStr.GetBuffer() );
5451 #endif
5452
5453 Any a( nLockCount );
5454 implts_notifyListeners( css::frame::LayoutManagerEvents::LOCK, a );
5455 }
5456
5457 void SAL_CALL LayoutManager::unlock()
5458 throw (RuntimeException)
5459 {
5460 sal_Bool bDoLayout( implts_unlock() );
5461
5462 ReadGuard aReadLock( m_aLock );
5463 sal_Int32 nLockCount( m_nLockCount );
5464 aReadLock.unlock();
5465
5466 RTL_LOGFILE_TRACE1( "framework (cd100003) ::LayoutManager::unlock lockCount=%d", nLockCount );
5467 #ifdef DBG_UTIL
5468 ByteString aStr("LayoutManager::unlock ");
5469 aStr += ByteString::CreateFromInt32((long)this);
5470 aStr += " - ";
5471 aStr += ByteString::CreateFromInt32(nLockCount);
5472 DBG_TRACE( aStr.GetBuffer() );
5473 #endif
5474 // conform to documentation: unlock with lock count == 0 means force a layout
5475
5476 WriteGuard aWriteLock( m_aLock );
5477 if ( bDoLayout )
5478 m_aAsyncLayoutTimer.Stop();
5479 aWriteLock.unlock();
5480
5481 Any a( nLockCount );
5482 implts_notifyListeners( css::frame::LayoutManagerEvents::UNLOCK, a );
5483
5484 if ( bDoLayout )
5485 doLayout();
5486 }
5487
5488 void SAL_CALL LayoutManager::doLayout()
5489 throw (RuntimeException)
5490 {
5491 sal_Bool bLayouted = implts_doLayout( sal_False );
5492
5493 if ( bLayouted )
5494 implts_notifyListeners( css::frame::LayoutManagerEvents::LAYOUT, Any() );
5495 }
5496
5497 sal_Bool LayoutManager::implts_doLayout( sal_Bool bForceRequestBorderSpace )
5498 {
5499 RTL_LOGFILE_CONTEXT( aLog, "framework (cd100003) ::LayoutManager::implts_doLayout" );
5500
5501 sal_Bool bNoLock( sal_False );
5502 css::awt::Rectangle aCurrBorderSpace;
5503 Reference< css::awt::XWindow > xContainerWindow;
5504 Reference< XDockingAreaAcceptor > xDockingAreaAcceptor;
5505
5506 /* SAFE AREA ----------------------------------------------------------------------------------------------- */
5507 ReadGuard aReadLock( m_aLock );
5508
5509 sal_Bool bMustDoLayout( m_bMustDoLayout );
5510 if ( !m_bParentWindowVisible )
5511 return sal_False;
5512
5513 bNoLock = ( m_nLockCount == 0 );
5514 xContainerWindow = m_xContainerWindow;
5515 xDockingAreaAcceptor = m_xDockingAreaAcceptor;
5516 aCurrBorderSpace = m_aDockingArea;
5517 aReadLock.unlock();
5518 /* SAFE AREA ----------------------------------------------------------------------------------------------- */
5519
5520 sal_Bool bLayouted( sal_False );
5521
5522 if ( bNoLock &&
5523 xDockingAreaAcceptor.is() &&
5524 xContainerWindow.is() )
5525 {
5526 bLayouted = sal_True;
5527
5528 /* SAFE AREA ----------------------------------------------------------------------------------------------- */
5529 WriteGuard aWriteGuard( m_aLock );
5530 m_bDoLayout = sal_True;
5531 aWriteGuard.unlock();
5532 /* SAFE AREA ----------------------------------------------------------------------------------------------- */
5533
5534 css::awt::Rectangle aBorderSpace = implts_calcDockingAreaSizes();
5535 sal_Bool bGotRequestedBorderSpace( sal_True );
5536 sal_Bool bEqual = implts_compareRectangles( aBorderSpace, aCurrBorderSpace );
5537
5538 if ( !bEqual || bForceRequestBorderSpace || bMustDoLayout )
5539 {
5540 bGotRequestedBorderSpace = xDockingAreaAcceptor->requestDockingAreaSpace( aBorderSpace );
5541 if ( bGotRequestedBorderSpace )
5542 {
5543 xDockingAreaAcceptor->setDockingAreaSpace( aBorderSpace );
5544
5545 /* SAFE AREA ----------------------------------------------------------------------------------------------- */
5546 aWriteGuard.lock();
5547 m_aDockingArea = aBorderSpace;
5548 m_bMustDoLayout = sal_False;
5549 aWriteGuard.unlock();
5550 /* SAFE AREA ----------------------------------------------------------------------------------------------- */
5551 }
5552 }
5553
5554 if ( bGotRequestedBorderSpace )
5555 {
5556 ::Size aContainerSize;
5557 ::Size aStatusBarSize;
5558
5559 aStatusBarSize = implts_getStatusBarSize();
5560 aBorderSpace.Height -= aStatusBarSize.Height();
5561 implts_setDockingAreaWindowSizes( aBorderSpace );
5562
5563 // Subtract status bar size from our container output size. Docking area windows
5564 // don't contain the status bar!
5565 aContainerSize = implts_getContainerWindowOutputSize();
5566 aContainerSize.Height() -= aStatusBarSize.Height();
5567
5568 // Retrieve row/column dependent data from all docked user-interface elements
5569 for ( sal_Int32 i = 0; i < DOCKINGAREAS_COUNT; i++ )
5570 {
5571 std::vector< SingleRowColumnWindowData > aRowColumnsWindowData;
5572
5573 implts_getDockingAreaElementInfos( (DockingArea)i, aRowColumnsWindowData );
5574
5575 sal_Int32 nOffset( 0 );
5576 const sal_uInt32 nCount = aRowColumnsWindowData.size();
5577 for ( sal_uInt32 j = 0; j < nCount; ++j )
5578 {
5579 implts_calcWindowPosSizeOnSingleRowColumn( i, nOffset, aRowColumnsWindowData[j], aContainerSize );
5580 nOffset += aRowColumnsWindowData[j].nStaticSize;
5581 }
5582 }
5583
5584 // Position the status bar
5585 if ( aStatusBarSize.Height() > 0 )
5586 {
5587 implts_setStatusBarPosSize( ::Point( 0, std::max(( aContainerSize.Height() ), long( 0 ))),
5588 ::Size( aContainerSize.Width(),aStatusBarSize.Height() ));
5589 }
5590
5591 /* SAFE AREA ----------------------------------------------------------------------------------------------- */
5592 aWriteGuard.lock();
5593 m_bDoLayout = sal_False;
5594 aWriteGuard.unlock();
5595 /* SAFE AREA ----------------------------------------------------------------------------------------------- */
5596 }
5597 }
5598
5599 return bLayouted;
5600 }
5601
5602 sal_Bool LayoutManager::implts_compareRectangles( const css::awt::Rectangle& rRect1,
5603 const css::awt::Rectangle& rRect2 )
5604 {
5605 return (( rRect1.X == rRect2.X ) &&
5606 ( rRect1.Y == rRect2.Y ) &&
5607 ( rRect1.Width == rRect2.Width ) &&
5608 ( rRect1.Height == rRect2.Height ));
5609 }
5610
5611 void SAL_CALL LayoutManager::setVisible( sal_Bool bVisible )
5612 throw (::com::sun::star::uno::RuntimeException)
5613 {
5614 sal_Bool bWasVisible( sal_True );
5615
5616 WriteGuard aWriteLock( m_aLock );
5617 bWasVisible = m_bVisible;
5618 m_bVisible = bVisible;
5619 aWriteLock.unlock();
5620
5621 if ( bWasVisible != bVisible )
5622 implts_setVisibleState( bVisible );
5623 }
5624
5625 sal_Bool SAL_CALL LayoutManager::isVisible()
5626 throw (::com::sun::star::uno::RuntimeException)
5627 {
5628 ReadGuard aReadLock( m_aLock );
5629 return m_bVisible;
5630 }
5631
5632 void LayoutManager::implts_calcWindowPosSizeOnSingleRowColumn( sal_Int32 nDockingArea,
5633 sal_Int32 nOffset,
5634 SingleRowColumnWindowData& rRowColumnWindowData,
5635 const ::Size& rContainerSize )
5636 {
5637 sal_Int32 nDiff( 0 );
5638 sal_Int32 nRCSpace( rRowColumnWindowData.nSpace );
5639 sal_Int32 nTopDockingAreaSize;
5640 sal_Int32 nBottomDockingAreaSize;
5641 sal_Int32 nContainerClientSize;
5642
5643 if ( rRowColumnWindowData.aRowColumnWindows.empty() )
5644 return;
5645
5646 if (( nDockingArea == DockingArea_DOCKINGAREA_TOP ) ||
5647 ( nDockingArea == DockingArea_DOCKINGAREA_BOTTOM ))
5648 {
5649 nContainerClientSize = rContainerSize.Width();
5650 nDiff = nContainerClientSize - rRowColumnWindowData.nVarSize;
5651 }
5652 else
5653 {
5654 nTopDockingAreaSize = implts_getTopBottomDockingAreaSizes().Width();
5655 nBottomDockingAreaSize = implts_getTopBottomDockingAreaSizes().Height();
5656 nContainerClientSize = ( rContainerSize.Height() - nTopDockingAreaSize - nBottomDockingAreaSize );
5657 nDiff = nContainerClientSize - rRowColumnWindowData.nVarSize;
5658 }
5659
5660 const sal_uInt32 nCount = rRowColumnWindowData.aRowColumnWindowSizes.size();
5661 if (( nDiff < 0 ) && ( nRCSpace > 0 ))
5662 {
5663 // First we try to reduce the size of blank space before/behind docked windows
5664 sal_Int32 i = nCount - 1;
5665 while ( i >= 0 )
5666 {
5667 sal_Int32 nSpace = rRowColumnWindowData.aRowColumnSpace[i];
5668 if ( nSpace >= -nDiff )
5669 {
5670
5671 if (( nDockingArea == DockingArea_DOCKINGAREA_TOP ) ||
5672 ( nDockingArea == DockingArea_DOCKINGAREA_BOTTOM ))
5673 {
5674 // Try to move this and all user elements behind with the calculated difference
5675 for ( sal_uInt32 j = i; j < nCount ; j++ )
5676 rRowColumnWindowData.aRowColumnWindowSizes[j].X += nDiff;
5677 }
5678 else
5679 {
5680 // Try to move this and all user elements behind with the calculated difference
5681 for ( sal_uInt32 j = i; j < nCount ; j++ )
5682 rRowColumnWindowData.aRowColumnWindowSizes[j].Y += nDiff;
5683 }
5684 nDiff = 0;
5685
5686 break;
5687 }
5688 else if ( nSpace > 0 )
5689 {
5690 if (( nDockingArea == DockingArea_DOCKINGAREA_TOP ) ||
5691 ( nDockingArea == DockingArea_DOCKINGAREA_BOTTOM ))
5692 {
5693 // Try to move this and all user elements behind with the calculated difference
5694 for ( sal_uInt32 j = i; j < nCount; j++ )
5695 rRowColumnWindowData.aRowColumnWindowSizes[j].X -= nSpace;
5696 }
5697 else
5698 {
5699 // Try to move this and all user elements behind with the calculated difference
5700 for ( sal_uInt32 j = i; j < nCount; j++ )
5701 rRowColumnWindowData.aRowColumnWindowSizes[j].Y -= nSpace;
5702 }
5703 nDiff += nSpace;
5704 }
5705 --i;
5706 }
5707 }
5708
5709 // Check if we have to reduce further
5710 if ( nDiff < 0 )
5711 {
5712 // Now we have to reduce the size of certain docked windows
5713 sal_Int32 i = sal_Int32( nCount - 1 );
5714 while ( i >= 0 )
5715 {
5716 css::awt::Rectangle& rWinRect = rRowColumnWindowData.aRowColumnWindowSizes[i];
5717 ::Size aMinSize;
5718
5719 vos::OGuard aGuard( Application::GetSolarMutex() );
5720 {
5721 Reference< css::awt::XWindow > xWindow = rRowColumnWindowData.aRowColumnWindows[i];
5722 Window* pWindow = VCLUnoHelper::GetWindow( xWindow );
5723 if ( pWindow && pWindow->GetType() == WINDOW_TOOLBOX )
5724 aMinSize = ((ToolBox *)pWindow)->CalcMinimumWindowSizePixel();
5725 }
5726
5727 if (( aMinSize.Width() > 0 ) && ( aMinSize.Height() > 0 ))
5728 {
5729 if (( nDockingArea == DockingArea_DOCKINGAREA_TOP ) ||
5730 ( nDockingArea == DockingArea_DOCKINGAREA_BOTTOM ))
5731 {
5732 sal_Int32 nMaxReducation = ( rWinRect.Width - aMinSize.Width() );
5733 if ( nMaxReducation >= -nDiff )
5734 {
5735 rWinRect.Width = rWinRect.Width + nDiff;
5736 nDiff = 0;
5737 }
5738 else
5739 {
5740 rWinRect.Width = aMinSize.Width();
5741 nDiff += nMaxReducation;
5742 }
5743
5744 // Try to move this and all user elements behind with the calculated difference
5745 for ( sal_uInt32 j = i; j < nCount; j++ )
5746 rRowColumnWindowData.aRowColumnWindowSizes[j].X += nDiff;
5747 }
5748 else
5749 {
5750 sal_Int32 nMaxReducation = ( rWinRect.Height - aMinSize.Height() );
5751 if ( nMaxReducation >= -nDiff )
5752 {
5753 rWinRect.Height = rWinRect.Height + nDiff;
5754 nDiff = 0;
5755 }
5756 else
5757 {
5758 rWinRect.Height = aMinSize.Height();
5759 nDiff += nMaxReducation;
5760 }
5761
5762 // Try to move this and all user elements behind with the calculated difference
5763 for ( sal_uInt32 j = i; j < nCount; j++ )
5764 rRowColumnWindowData.aRowColumnWindowSizes[j].Y += nDiff;
5765 }
5766 }
5767
5768 if ( nDiff >= 0 )
5769 break;
5770
5771 --i;
5772 }
5773 }
5774
5775 /* SAFE AREA ----------------------------------------------------------------------------------------------- */
5776 ReadGuard aReadLock( m_aLock );
5777 Window* pDockAreaWindow = VCLUnoHelper::GetWindow( m_xDockAreaWindows[nDockingArea] );
5778 aReadLock.unlock();
5779
5780 sal_Int32 nCurrPos( 0 );
5781 sal_Int32 nStartOffset( 0 );
5782
5783 if ( nDockingArea == DockingArea_DOCKINGAREA_RIGHT )
5784 nStartOffset = pDockAreaWindow->GetSizePixel().Width() - rRowColumnWindowData.nStaticSize;
5785 else if ( nDockingArea == DockingArea_DOCKINGAREA_BOTTOM )
5786 nStartOffset = pDockAreaWindow->GetSizePixel().Height() - rRowColumnWindowData.nStaticSize;
5787
5788 vos::OGuard aGuard( Application::GetSolarMutex() );
5789 for ( sal_uInt32 i = 0; i < nCount; i++ )
5790 {
5791 Reference< css::awt::XWindow > xWindow = rRowColumnWindowData.aRowColumnWindows[i];
5792 Window* pWindow = VCLUnoHelper::GetWindow( xWindow );
5793 Window* pOldParentWindow = pWindow->GetParent();
5794
5795 if ( pDockAreaWindow != pOldParentWindow )
5796 pWindow->SetParent( pDockAreaWindow );
5797
5798 css::awt::Rectangle aWinRect = rRowColumnWindowData.aRowColumnWindowSizes[i];
5799 if ( nDockingArea == DockingArea_DOCKINGAREA_TOP )
5800 {
5801 if ( aWinRect.X < nCurrPos )
5802 aWinRect.X = nCurrPos;
5803 pWindow->SetPosSizePixel( ::Point( aWinRect.X, nOffset ),
5804 ::Size( aWinRect.Width, rRowColumnWindowData.nStaticSize ));
5805 nCurrPos += ( aWinRect.X - nCurrPos ) + aWinRect.Width;
5806 }
5807 else if ( nDockingArea == DockingArea_DOCKINGAREA_BOTTOM )
5808 {
5809 if ( aWinRect.X < nCurrPos )
5810 aWinRect.X = nCurrPos;
5811 pWindow->SetPosSizePixel( ::Point( aWinRect.X, nStartOffset - nOffset ),
5812 ::Size( aWinRect.Width, rRowColumnWindowData.nStaticSize ));
5813 nCurrPos += ( aWinRect.X - nCurrPos ) + aWinRect.Width;
5814 }
5815 else if ( nDockingArea == DockingArea_DOCKINGAREA_LEFT )
5816 {
5817 if ( aWinRect.Y < nCurrPos )
5818 aWinRect.Y = nCurrPos;
5819 pWindow->SetPosSizePixel( ::Point( nOffset, aWinRect.Y ),
5820 ::Size( rRowColumnWindowData.nStaticSize, aWinRect.Height ));
5821 nCurrPos += ( aWinRect.Y - nCurrPos ) + aWinRect.Height;
5822 }
5823 else if ( nDockingArea == DockingArea_DOCKINGAREA_RIGHT )
5824 {
5825 if ( aWinRect.Y < nCurrPos )
5826 aWinRect.Y = nCurrPos;
5827 pWindow->SetPosSizePixel( ::Point( nStartOffset - nOffset, aWinRect.Y ),
5828 ::Size( rRowColumnWindowData.nStaticSize, aWinRect.Height ));
5829 nCurrPos += ( aWinRect.Y - nCurrPos ) + aWinRect.Height;
5830 }
5831 }
5832 }
5833
5834 ::Size LayoutManager::implts_getStatusBarSize()
5835 {
5836 ReadGuard aReadLock( m_aLock );
5837 sal_Bool bStatusBarVisible( isElementVisible( m_aStatusBarAlias ));
5838 sal_Bool bProgressBarVisible( isElementVisible( m_aProgressBarAlias ));
5839 sal_Bool bVisible = m_bVisible;
5840 Reference< XUIElement > xStatusBar = m_aStatusBarElement.m_xUIElement;
5841 Reference< XUIElement > xProgressBar = m_aProgressBarElement.m_xUIElement;
5842
5843 Reference< css::awt::XWindow > xWindow;
5844 if ( bStatusBarVisible && bVisible && xStatusBar.is() )
5845 xWindow = Reference< css::awt::XWindow >( xStatusBar->getRealInterface(), UNO_QUERY );
5846 else if ( xProgressBar.is() && !xStatusBar.is() && bProgressBarVisible )
5847 {
5848 ProgressBarWrapper* pWrapper = (ProgressBarWrapper*)xProgressBar.get();
5849 if ( pWrapper )
5850 xWindow = pWrapper->getStatusBar();
5851 }
5852 aReadLock.unlock();
5853
5854 if ( xWindow.is() )
5855 {
5856 css::awt::Rectangle aPosSize = xWindow->getPosSize();
5857 return ::Size( aPosSize.Width, aPosSize.Height );
5858 }
5859 else
5860 return ::Size();
5861 }
5862
5863 css::awt::Rectangle LayoutManager::implts_calcDockingAreaSizes()
5864 {
5865 Reference< css::awt::XWindow > xContainerWindow;
5866 Reference< XDockingAreaAcceptor > xDockingAreaAcceptor;
5867
5868 ReadGuard aReadLock( m_aLock );
5869 xContainerWindow = m_xContainerWindow;
5870 xDockingAreaAcceptor = m_xDockingAreaAcceptor;
5871 UIElementVector aWindowVector( m_aUIElements );
5872 aReadLock.unlock();
5873
5874 css::awt::Rectangle aBorderSpace;
5875 if ( xDockingAreaAcceptor.is() && xContainerWindow.is() )
5876 {
5877 sal_Int32 nCurrRowColumn( 0 );
5878 sal_Int32 nCurrPos( 0 );
5879 sal_Int32 nCurrDockingArea( DockingArea_DOCKINGAREA_TOP );
5880 std::vector< sal_Int32 > aRowColumnSizes[DOCKINGAREAS_COUNT];
5881 UIElementVector::const_iterator pConstIter;
5882
5883 aRowColumnSizes[nCurrDockingArea].clear();
5884 aRowColumnSizes[nCurrDockingArea].push_back( 0 );
5885
5886 for ( pConstIter = aWindowVector.begin(); pConstIter != aWindowVector.end(); pConstIter++ )
5887 {
5888 Reference< XUIElement > xUIElement( pConstIter->m_xUIElement, UNO_QUERY );
5889 if ( xUIElement.is() )
5890 {
5891 Reference< css::awt::XWindow > xWindow( xUIElement->getRealInterface(), UNO_QUERY );
5892 Reference< css::awt::XDockableWindow > xDockWindow( xWindow, UNO_QUERY );
5893 if ( xWindow.is() && xDockWindow.is() )
5894 {
5895 vos::OGuard aGuard( Application::GetSolarMutex() );
5896
5897 Window* pWindow = VCLUnoHelper::GetWindow( xWindow );
5898 if ( pWindow && pWindow->IsVisible() && !xDockWindow->isFloating() )
5899 {
5900 css::awt::Rectangle aPosSize = xWindow->getPosSize();
5901 if ( pConstIter->m_aDockedData.m_nDockedArea != nCurrDockingArea )
5902 {
5903 nCurrDockingArea = pConstIter->m_aDockedData.m_nDockedArea;
5904 nCurrRowColumn = 0;
5905 nCurrPos = 0;
5906 aRowColumnSizes[nCurrDockingArea].clear();
5907 aRowColumnSizes[nCurrDockingArea].push_back( 0 );
5908 }
5909
5910 if ( pConstIter->m_aDockedData.m_nDockedArea == nCurrDockingArea )
5911 {
5912 if (( pConstIter->m_aDockedData.m_nDockedArea == DockingArea_DOCKINGAREA_TOP ) ||
5913 ( pConstIter->m_aDockedData.m_nDockedArea == DockingArea_DOCKINGAREA_BOTTOM ))
5914 {
5915 if ( pConstIter->m_aDockedData.m_aPos.Y() > nCurrPos )
5916 {
5917 ++nCurrRowColumn;
5918 nCurrPos = pConstIter->m_aDockedData.m_aPos.Y();
5919 aRowColumnSizes[nCurrDockingArea].push_back( 0 );
5920 }
5921
5922 if ( aPosSize.Height > aRowColumnSizes[nCurrDockingArea][nCurrRowColumn] )
5923 aRowColumnSizes[nCurrDockingArea][nCurrRowColumn] = aPosSize.Height;
5924 }
5925 else
5926 {
5927 if ( pConstIter->m_aDockedData.m_aPos.X() > nCurrPos )
5928 {
5929 ++nCurrRowColumn;
5930 nCurrPos = pConstIter->m_aDockedData.m_aPos.X();
5931 aRowColumnSizes[nCurrDockingArea].push_back( 0 );
5932 }
5933
5934 if ( aPosSize.Width > aRowColumnSizes[nCurrDockingArea][nCurrRowColumn] )
5935 aRowColumnSizes[nCurrDockingArea][nCurrRowColumn] = aPosSize.Width;
5936 }
5937 }
5938 }
5939 }
5940 }
5941 }
5942
5943 // Sum up max heights from every row/column
5944 if ( !aWindowVector.empty() )
5945 {
5946 for ( sal_Int32 i = 0; i <= DockingArea_DOCKINGAREA_RIGHT; i++ )
5947 {
5948 sal_Int32 nSize( 0 );
5949 const sal_uInt32 nCount = aRowColumnSizes[i].size();
5950 for ( sal_uInt32 j = 0; j < nCount; j++ )
5951 nSize += aRowColumnSizes[i][j];
5952
5953 if ( i == DockingArea_DOCKINGAREA_TOP )
5954 aBorderSpace.Y = nSize;
5955 else if ( i == DockingArea_DOCKINGAREA_BOTTOM )
5956 aBorderSpace.Height = nSize;
5957 else if ( i == DockingArea_DOCKINGAREA_LEFT )
5958 aBorderSpace.X = nSize;
5959 else
5960 aBorderSpace.Width = nSize;
5961 }
5962 }
5963
5964 // We have to add the height of a possible status bar
5965 aBorderSpace.Height += implts_getStatusBarSize().Height();
5966 }
5967
5968 return aBorderSpace;
5969 }
5970
5971 void LayoutManager::implts_setDockingAreaWindowSizes( const css::awt::Rectangle& rBorderSpace )
5972 {
5973 Reference< css::awt::XWindow > xContainerWindow;
5974
5975 ReadGuard aReadLock( m_aLock );
5976 xContainerWindow = m_xContainerWindow;
5977 aReadLock.unlock();
5978
5979 css::uno::Reference< css::awt::XDevice > xDevice( xContainerWindow, css::uno::UNO_QUERY );
5980 // Convert relativ size to output size.
5981 css::awt::Rectangle aRectangle = xContainerWindow->getPosSize();
5982 css::awt::DeviceInfo aInfo = xDevice->getInfo();
5983 css::awt::Size aContainerClientSize = css::awt::Size( aRectangle.Width - aInfo.LeftInset - aInfo.RightInset ,
5984 aRectangle.Height - aInfo.TopInset - aInfo.BottomInset );
5985 ::Size aStatusBarSize = implts_getStatusBarSize();
5986
5987 sal_Int32 nLeftRightDockingAreaHeight( aContainerClientSize.Height );
5988 if ( rBorderSpace.Y >= 0 )
5989 {
5990 // Top docking area window
5991 aReadLock.lock();
5992 Reference< css::awt::XWindow > xDockAreaWindow( m_xDockAreaWindows[DockingArea_DOCKINGAREA_TOP] );
5993 aReadLock.unlock();
5994
5995 xDockAreaWindow->setPosSize( 0, 0, aContainerClientSize.Width, rBorderSpace.Y, css::awt::PosSize::POSSIZE );
5996 xDockAreaWindow->setVisible( sal_True );
5997 nLeftRightDockingAreaHeight -= rBorderSpace.Y;
5998 }
5999
6000 if ( rBorderSpace.Height >= 0 )
6001 {
6002 // Bottom docking area window
6003 sal_Int32 nBottomPos = std::max( sal_Int32( aContainerClientSize.Height - rBorderSpace.Height - aStatusBarSize.Height() ), sal_Int32( 0 ));
6004 sal_Int32 nHeight = ( nBottomPos == 0 ) ? 0 : rBorderSpace.Height;
6005
6006 aReadLock.lock();
6007 Reference< css::awt::XWindow > xDockAreaWindow( m_xDockAreaWindows[DockingArea_DOCKINGAREA_BOTTOM] );
6008 aReadLock.unlock();
6009
6010 xDockAreaWindow->setPosSize( 0, nBottomPos, aContainerClientSize.Width, nHeight, css::awt::PosSize::POSSIZE );
6011 xDockAreaWindow->setVisible( sal_True );
6012 nLeftRightDockingAreaHeight -= nHeight;
6013 }
6014
6015 nLeftRightDockingAreaHeight -= aStatusBarSize.Height();
6016 if ( rBorderSpace.X >= 0 || nLeftRightDockingAreaHeight > 0 )
6017 {
6018 // Left docking area window
6019 aReadLock.lock();
6020 Reference< css::awt::XWindow > xDockAreaWindow( m_xDockAreaWindows[DockingArea_DOCKINGAREA_LEFT] );
6021 aReadLock.unlock();
6022
6023 // We also have to change our right docking area window if the top or bottom area has changed. They have a higher priority!
6024 sal_Int32 nHeight = std::max( sal_Int32( 0 ), sal_Int32( nLeftRightDockingAreaHeight ));
6025
6026 xDockAreaWindow->setPosSize( 0, rBorderSpace.Y, rBorderSpace.X, nHeight, css::awt::PosSize::POSSIZE );
6027 xDockAreaWindow->setVisible( sal_True );
6028 }
6029 if ( rBorderSpace.Width >= 0 || nLeftRightDockingAreaHeight > 0 )
6030 {
6031 // Right docking area window
6032 aReadLock.lock();
6033 Reference< css::awt::XWindow > xDockAreaWindow( m_xDockAreaWindows[DockingArea_DOCKINGAREA_RIGHT] );
6034 aReadLock.unlock();
6035
6036 // We also have to change our right docking area window if the top or bottom area has changed. They have a higher priority!
6037 sal_Int32 nLeftPos = std::max( sal_Int32( 0 ), sal_Int32( aContainerClientSize.Width - rBorderSpace.Width ));
6038 sal_Int32 nHeight = std::max( sal_Int32( 0 ), sal_Int32( nLeftRightDockingAreaHeight ));
6039 sal_Int32 nWidth = ( nLeftPos == 0 ) ? 0 : rBorderSpace.Width;
6040
6041 xDockAreaWindow->setPosSize( nLeftPos, rBorderSpace.Y, nWidth, nHeight, css::awt::PosSize::POSSIZE );
6042 xDockAreaWindow->setVisible( sal_True );
6043 }
6044
6045 // Position the status bar
6046 if ( aStatusBarSize.Height() > 0 )
6047 {
6048 implts_setStatusBarPosSize( ::Point( 0, std::max(( aContainerClientSize.Height - aStatusBarSize.Height() ), long( 0 ))),
6049 ::Size( aContainerClientSize.Width, aStatusBarSize.Height() ));
6050 }
6051 }
6052
6053 //---------------------------------------------------------------------------------------------------------
6054 // XMenuCloser
6055 //---------------------------------------------------------------------------------------------------------
6056 void LayoutManager::implts_updateMenuBarClose()
6057 {
6058 /* SAFE AREA ----------------------------------------------------------------------------------------------- */
6059 WriteGuard aWriteLock( m_aLock );
6060 sal_Bool bShowCloser = m_bMenuBarCloser;
6061 Reference< css::awt::XWindow > xContainerWindow( m_xContainerWindow );
6062 aWriteLock.unlock();
6063
6064 if ( xContainerWindow.is() )
6065 {
6066 vos::OGuard aGuard( Application::GetSolarMutex() );
6067
6068 Window* pWindow = VCLUnoHelper::GetWindow( xContainerWindow );
6069 while ( pWindow && !pWindow->IsSystemWindow() )
6070 pWindow = pWindow->GetParent();
6071
6072 if ( pWindow )
6073 {
6074 SystemWindow* pSysWindow = (SystemWindow *)pWindow;
6075 MenuBar* pMenuBar = pSysWindow->GetMenuBar();
6076 if ( pMenuBar )
6077 {
6078 // TODO remove link on FALSE ?!
6079 if ( bShowCloser )
6080 {
6081 pMenuBar->ShowCloser( TRUE );
6082 pMenuBar->SetCloserHdl( LINK( this, LayoutManager, MenuBarClose ));
6083 }
6084 else
6085 {
6086 pMenuBar->ShowCloser( FALSE );
6087 pMenuBar->SetCloserHdl( LINK( this, LayoutManager, MenuBarClose ));
6088 }
6089 }
6090 }
6091 }
6092 }
6093
6094 sal_Bool LayoutManager::implts_resetMenuBar()
6095 {
6096 /* SAFE AREA ----------------------------------------------------------------------------------------------- */
6097 WriteGuard aWriteLock( m_aLock );
6098 sal_Bool bMenuVisible( m_bMenuVisible );
6099 Reference< css::awt::XWindow > xContainerWindow( m_xContainerWindow );
6100
6101 MenuBar* pSetMenuBar = 0;
6102 if ( m_xInplaceMenuBar.is() )
6103 pSetMenuBar = (MenuBar *)m_pInplaceMenuBar->GetMenuBar();
6104 else
6105 {
6106 MenuBarWrapper* pMenuBarWrapper = SAL_STATIC_CAST( MenuBarWrapper*, m_xMenuBar.get() );
6107 if ( pMenuBarWrapper )
6108 pSetMenuBar = (MenuBar *)pMenuBarWrapper->GetMenuBarManager()->GetMenuBar();
6109 }
6110 aWriteLock.unlock();
6111 /* SAFE AREA ----------------------------------------------------------------------------------------------- */
6112
6113 vos::OGuard aGuard( Application::GetSolarMutex() );
6114 Window* pWindow = VCLUnoHelper::GetWindow( m_xContainerWindow );
6115 while ( pWindow && !pWindow->IsSystemWindow() )
6116 pWindow = pWindow->GetParent();
6117
6118 if ( pWindow && bMenuVisible && pSetMenuBar )
6119 {
6120 ((SystemWindow *)pWindow)->SetMenuBar( pSetMenuBar );
6121 pSetMenuBar->SetDisplayable( sal_True );
6122 return sal_True;
6123 }
6124
6125 return sal_False;
6126 }
6127
6128 void LayoutManager::implts_setMenuBarCloser(sal_Bool bCloserState)
6129 {
6130 /* SAFE AREA ----------------------------------------------------------------------------------------------- */
6131 WriteGuard aWriteLock( m_aLock );
6132 m_bMenuBarCloser = bCloserState;
6133 aWriteLock.unlock();
6134
6135 implts_updateMenuBarClose();
6136 }
6137
6138 sal_Int16 LayoutManager::implts_getCurrentSymbolsSize()
6139 {
6140 sal_Int16 eOptSymbolsSize( 0 );
6141
6142 {
6143 ReadGuard aReadLock( m_aLock );
6144 vos::OGuard aGuard( Application::GetSolarMutex() );
6145 if ( m_pMiscOptions )
6146 eOptSymbolsSize = m_pMiscOptions->GetCurrentSymbolsSize();
6147 }
6148
6149 return eOptSymbolsSize;
6150 }
6151
6152 sal_Int16 LayoutManager::implts_getCurrentSymbolsStyle()
6153 {
6154 sal_Int16 eOptSymbolsStyle( 0 );
6155
6156 {
6157 ReadGuard aReadLock( m_aLock );
6158 vos::OGuard aGuard( Application::GetSolarMutex() );
6159 if ( m_pMiscOptions )
6160 eOptSymbolsStyle = m_pMiscOptions->GetCurrentSymbolsStyle();
6161 }
6162
6163 return eOptSymbolsStyle;
6164 }
6165
6166 IMPL_LINK( LayoutManager, MenuBarClose, MenuBar *, EMPTYARG )
6167 {
6168 ReadGuard aReadLock( m_aLock );
6169 css::uno::Reference< css::frame::XDispatchProvider > xProvider(m_xFrame, css::uno::UNO_QUERY);
6170 css::uno::Reference< css::lang::XMultiServiceFactory > xSMGR = m_xSMGR;
6171 aReadLock.unlock();
6172
6173 if (! xProvider.is())
6174 return 0;
6175
6176 css::uno::Reference< css::frame::XDispatchHelper > xDispatcher(
6177 xSMGR->createInstance(SERVICENAME_DISPATCHHELPER), css::uno::UNO_QUERY_THROW);
6178
6179 xDispatcher->executeDispatch(
6180 xProvider,
6181 ::rtl::OUString::createFromAscii(".uno:CloseWin"),
6182 ::rtl::OUString::createFromAscii("_self"),
6183 0,
6184 css::uno::Sequence< css::beans::PropertyValue >());
6185
6186 return 0;
6187 }
6188
6189 IMPL_LINK( LayoutManager, OptionsChanged, void*, EMPTYARG )
6190 {
6191 sal_Int16 eSymbolsSize( implts_getCurrentSymbolsSize() );
6192 sal_Int16 eSymbolsStyle( implts_getCurrentSymbolsStyle() );
6193
6194 ReadGuard aReadLock( m_aLock );
6195 sal_Int16 eOldSymbolsSize = m_eSymbolsSize;
6196 sal_Int16 eOldSymbolsStyle = m_eSymbolsStyle;
6197 aReadLock.unlock();
6198
6199 if ( eSymbolsSize != eOldSymbolsSize || eSymbolsStyle != eOldSymbolsStyle )
6200 {
6201 WriteGuard aWriteLock( m_aLock );
6202 m_eSymbolsSize = eSymbolsSize;
6203 m_eSymbolsStyle = eSymbolsStyle;
6204 aWriteLock.unlock();
6205
6206 std::vector< Reference< XUpdatable > > aToolBarVector;
6207
6208 aReadLock.lock();
6209 {
6210 UIElementVector::iterator pIter;
6211 for ( pIter = m_aUIElements.begin(); pIter != m_aUIElements.end(); pIter++ )
6212 {
6213 if ( pIter->m_xUIElement.is() )
6214 aToolBarVector.push_back( Reference< XUpdatable >( pIter->m_xUIElement, UNO_QUERY ));
6215 }
6216 }
6217 aReadLock.unlock();
6218
6219 lock();
6220 {
6221 std::vector< Reference< XUpdatable > >::iterator pIter;
6222 for ( pIter = aToolBarVector.begin(); pIter != aToolBarVector.end(); pIter++ )
6223 {
6224 if ( (*pIter).is() )
6225 (*pIter)->update();
6226 }
6227 }
6228 unlock();
6229 doLayout();
6230 }
6231
6232 return 1;
6233 }
6234
6235 IMPL_LINK( LayoutManager, SettingsChanged, void*, EMPTYARG )
6236 {
6237 return 1;
6238 }
6239
6240 //---------------------------------------------------------------------------------------------------------
6241 // XDockableWindowListener
6242 //---------------------------------------------------------------------------------------------------------
6243 void SAL_CALL LayoutManager::startDocking( const ::com::sun::star::awt::DockingEvent& e ) throw (::com::sun::star::uno::RuntimeException)
6244 {
6245 sal_Bool bWinFound( sal_False );
6246 UIElement aUIElement;
6247
6248 ReadGuard aReadGuard( m_aLock );
6249 Reference< css::awt::XWindow > xContainerWindow( m_xContainerWindow );
6250 Reference< css::awt::XWindow2 > xWindow( e.Source, UNO_QUERY );
6251 aReadGuard.unlock();
6252
6253 Window* pContainerWindow( 0 );
6254 Window* pWindow( 0 );
6255 ::Point aMousePos;
6256 {
6257 vos::OGuard aGuard( Application::GetSolarMutex() );
6258 pContainerWindow = VCLUnoHelper::GetWindow( xContainerWindow );
6259 aMousePos = pContainerWindow->ScreenToOutputPixel( ::Point( e.MousePos.X, e.MousePos.Y ));
6260 }
6261
6262 bWinFound = implts_findElement( e.Source, aUIElement );
6263
6264 if ( bWinFound && xWindow.is() )
6265 {
6266 css::awt::Rectangle aRect;
6267 Reference< css::awt::XDockableWindow > xDockWindow( xWindow, UNO_QUERY );
6268 if ( xDockWindow->isFloating() )
6269 {
6270 css::awt::Rectangle aPos = xWindow->getPosSize();
6271 css::awt::Size aSize = xWindow->getOutputSize();
6272
6273 aUIElement.m_aFloatingData.m_aPos = ::Point( aPos.X, aPos.Y );
6274 aUIElement.m_aFloatingData.m_aSize = ::Size( aSize.Width, aSize.Height );
6275
6276 vos::OGuard aGuard( Application::GetSolarMutex() );
6277 pWindow = VCLUnoHelper::GetWindow( xWindow );
6278 if ( pWindow && pWindow->GetType() == WINDOW_TOOLBOX )
6279 {
6280 ToolBox* pToolBox = (ToolBox *)pWindow;
6281 aUIElement.m_aFloatingData.m_nLines = pToolBox->GetFloatingLines();
6282 aUIElement.m_aFloatingData.m_bIsHorizontal = (( pToolBox->GetAlign() == WINDOWALIGN_TOP ) ||
6283 ( pToolBox->GetAlign() == WINDOWALIGN_BOTTOM ));
6284 }
6285 }
6286 }
6287
6288 WriteGuard aWriteLock( m_aLock );
6289 m_bDockingInProgress = bWinFound;
6290 m_aDockUIElement = aUIElement;
6291 m_aDockUIElement.m_bUserActive = sal_True;
6292 m_aStartDockMousePos = aMousePos;
6293 aWriteLock.unlock();
6294 }
6295
6296 ::Rectangle LayoutManager::implts_calcHotZoneRect( const ::Rectangle& rRect, sal_Int32 nHotZoneOffset )
6297 {
6298 ::Rectangle aRect( rRect );
6299
6300 aRect.Left() -= nHotZoneOffset;
6301 aRect.Top() -= nHotZoneOffset;
6302 aRect.Right() += nHotZoneOffset;
6303 aRect.Bottom() += nHotZoneOffset;
6304 return aRect;
6305 }
6306
6307 css::awt::DockingData SAL_CALL LayoutManager::docking( const ::com::sun::star::awt::DockingEvent& e )
6308 throw (::com::sun::star::uno::RuntimeException)
6309 {
6310 const sal_Int32 MAGNETIC_DISTANCE_UNDOCK = 25;
6311 const sal_Int32 MAGNETIC_DISTANCE_DOCK = 20;
6312
6313 css::awt::DockingData aDockingData;
6314 Reference< css::awt::XDockableWindow > xDockWindow( e.Source, UNO_QUERY );
6315 Reference< css::awt::XWindow > xWindow( e.Source, UNO_QUERY );
6316 Reference< css::awt::XWindow > xTopDockingWindow;
6317 Reference< css::awt::XWindow > xLeftDockingWindow;
6318 Reference< css::awt::XWindow > xRightDockingWindow;
6319 Reference< css::awt::XWindow > xBottomDockingWindow;
6320 Reference< css::awt::XWindow > xContainerWindow;
6321 UIElement aUIDockingElement;
6322 DockingOperation eDockingOperation( DOCKOP_ON_COLROW );
6323 ::Size aStatusBarSize;
6324
6325 aDockingData.TrackingRectangle = e.TrackingRectangle;
6326 sal_Bool bDockingInProgress;
6327
6328 {
6329 ReadGuard aReadLock( m_aLock );
6330 bDockingInProgress = m_bDockingInProgress;
6331 if ( bDockingInProgress )
6332 {
6333 xContainerWindow = m_xContainerWindow;
6334 xTopDockingWindow = m_xDockAreaWindows[DockingArea_DOCKINGAREA_TOP];
6335 xLeftDockingWindow = m_xDockAreaWindows[DockingArea_DOCKINGAREA_LEFT];
6336 xRightDockingWindow = m_xDockAreaWindows[DockingArea_DOCKINGAREA_RIGHT];
6337 xBottomDockingWindow = m_xDockAreaWindows[DockingArea_DOCKINGAREA_BOTTOM];
6338 aUIDockingElement = m_aDockUIElement;
6339 aStatusBarSize = implts_getStatusBarSize();
6340 }
6341 }
6342
6343 if ( bDockingInProgress &&
6344 xDockWindow.is() &&
6345 xWindow.is() )
6346 {
6347 try
6348 {
6349 vos::OGuard aGuard( Application::GetSolarMutex() );
6350
6351 sal_Int16 eDockingArea( -1 ); // none
6352 sal_Int32 nMagneticZone( aUIDockingElement.m_bFloating ? MAGNETIC_DISTANCE_DOCK : MAGNETIC_DISTANCE_UNDOCK );
6353 css::awt::Rectangle aNewTrackingRect;
6354 ::Rectangle aTrackingRect( e.TrackingRectangle.X,
6355 e.TrackingRectangle.Y,
6356 ( e.TrackingRectangle.X + e.TrackingRectangle.Width ),
6357 ( e.TrackingRectangle.Y + e.TrackingRectangle.Height ));
6358
6359 css::awt::Rectangle aTmpRect = xTopDockingWindow->getPosSize();
6360 ::Rectangle aTopDockRect( aTmpRect.X, aTmpRect.Y, aTmpRect.Width, aTmpRect.Height );
6361 ::Rectangle aHotZoneTopDockRect( implts_calcHotZoneRect( aTopDockRect, nMagneticZone ));
6362
6363 aTmpRect = xBottomDockingWindow->getPosSize();
6364 ::Rectangle aBottomDockRect( aTmpRect.X, aTmpRect.Y, ( aTmpRect.X + aTmpRect.Width), ( aTmpRect.Y + aTmpRect.Height ));
6365 ::Rectangle aHotZoneBottomDockRect( implts_calcHotZoneRect( aBottomDockRect, nMagneticZone ));
6366
6367 aTmpRect = xLeftDockingWindow->getPosSize();
6368 ::Rectangle aLeftDockRect( aTmpRect.X, aTmpRect.Y, ( aTmpRect.X + aTmpRect.Width ), ( aTmpRect.Y + aTmpRect.Height ));
6369 ::Rectangle aHotZoneLeftDockRect( implts_calcHotZoneRect( aLeftDockRect, nMagneticZone ));
6370
6371 aTmpRect = xRightDockingWindow->getPosSize();
6372 ::Rectangle aRightDockRect( aTmpRect.X, aTmpRect.Y, ( aTmpRect.X + aTmpRect.Width ), ( aTmpRect.Y + aTmpRect.Height ));
6373 ::Rectangle aHotZoneRightDockRect( implts_calcHotZoneRect( aRightDockRect, nMagneticZone ));
6374
6375 Window* pContainerWindow( VCLUnoHelper::GetWindow( xContainerWindow ) );
6376 Window* pDockingAreaWindow( 0 );
6377 ::Point aMousePos( pContainerWindow->ScreenToOutputPixel( ::Point( e.MousePos.X, e.MousePos.Y )));
6378
6379 if ( aHotZoneTopDockRect.IsInside( aMousePos ))
6380 eDockingArea = DockingArea_DOCKINGAREA_TOP;
6381 else if ( aHotZoneBottomDockRect.IsInside( aMousePos ))
6382 eDockingArea = DockingArea_DOCKINGAREA_BOTTOM;
6383 else if ( aHotZoneLeftDockRect.IsInside( aMousePos ))
6384 eDockingArea = DockingArea_DOCKINGAREA_LEFT;
6385 else if ( aHotZoneRightDockRect.IsInside( aMousePos ))
6386 eDockingArea = DockingArea_DOCKINGAREA_RIGHT;
6387
6388 // Higher priority for movements inside the real docking area
6389 if ( aTopDockRect.IsInside( aMousePos ))
6390 eDockingArea = DockingArea_DOCKINGAREA_TOP;
6391 else if ( aBottomDockRect.IsInside( aMousePos ))
6392 eDockingArea = DockingArea_DOCKINGAREA_BOTTOM;
6393 else if ( aLeftDockRect.IsInside( aMousePos ))
6394 eDockingArea = DockingArea_DOCKINGAREA_LEFT;
6395 else if ( aRightDockRect.IsInside( aMousePos ))
6396 eDockingArea = DockingArea_DOCKINGAREA_RIGHT;
6397
6398 // Determine if we have a toolbar and set alignment according to the docking area!
6399 Window* pWindow = VCLUnoHelper::GetWindow( xWindow );
6400 ToolBox* pToolBox = 0;
6401 if ( pWindow && pWindow->GetType() == WINDOW_TOOLBOX )
6402 pToolBox = (ToolBox *)pWindow;
6403
6404 if ( eDockingArea != -1 )
6405 {
6406 if ( eDockingArea == DockingArea_DOCKINGAREA_TOP )
6407 {
6408 aUIDockingElement.m_aDockedData.m_nDockedArea = DockingArea_DOCKINGAREA_TOP;
6409 aUIDockingElement.m_bFloating = sal_False;
6410 pDockingAreaWindow = VCLUnoHelper::GetWindow( xTopDockingWindow );
6411 }
6412 else if ( eDockingArea == DockingArea_DOCKINGAREA_BOTTOM )
6413 {
6414 aUIDockingElement.m_aDockedData.m_nDockedArea = DockingArea_DOCKINGAREA_BOTTOM;
6415 aUIDockingElement.m_bFloating = sal_False;
6416 pDockingAreaWindow = VCLUnoHelper::GetWindow( xBottomDockingWindow );
6417 }
6418 else if ( eDockingArea == DockingArea_DOCKINGAREA_LEFT )
6419 {
6420 aUIDockingElement.m_aDockedData.m_nDockedArea = DockingArea_DOCKINGAREA_LEFT;
6421 aUIDockingElement.m_bFloating = sal_False;
6422 pDockingAreaWindow = VCLUnoHelper::GetWindow( xLeftDockingWindow );
6423 }
6424 else if ( eDockingArea == DockingArea_DOCKINGAREA_RIGHT )
6425 {
6426 aUIDockingElement.m_aDockedData.m_nDockedArea = DockingArea_DOCKINGAREA_RIGHT;
6427 aUIDockingElement.m_bFloating = sal_False;
6428 pDockingAreaWindow = VCLUnoHelper::GetWindow( xRightDockingWindow );
6429 }
6430
6431 ::Point aOutputPos = pContainerWindow->ScreenToOutputPixel( aTrackingRect.TopLeft() );
6432 aTrackingRect.SetPos( aOutputPos );
6433
6434 ::Rectangle aNewDockingRect( aTrackingRect );
6435 implts_calcDockingPosSize( aUIDockingElement, eDockingOperation, aNewDockingRect, aMousePos );
6436
6437 ::Point aScreenPos = pContainerWindow->OutputToScreenPixel( aNewDockingRect.TopLeft() );
6438 aNewTrackingRect = css::awt::Rectangle( aScreenPos.X(),
6439 aScreenPos.Y(),
6440 aNewDockingRect.getWidth(),
6441 aNewDockingRect.getHeight() );
6442 aDockingData.TrackingRectangle = aNewTrackingRect;
6443 }
6444 else if ( pToolBox && bDockingInProgress )
6445 {
6446 sal_Bool bIsHorizontal = (( pToolBox->GetAlign() == WINDOWALIGN_TOP ) ||
6447 ( pToolBox->GetAlign() == WINDOWALIGN_BOTTOM ));
6448 ::Size aFloatSize = aUIDockingElement.m_aFloatingData.m_aSize;
6449 if ( aFloatSize.Width() > 0 && aFloatSize.Height() > 0 )
6450 {
6451 aUIDockingElement.m_aFloatingData.m_aPos = pContainerWindow->ScreenToOutputPixel(
6452 ::Point( e.MousePos.X, e.MousePos.Y ));
6453 aDockingData.TrackingRectangle.Height = aFloatSize.Height();
6454 aDockingData.TrackingRectangle.Width = aFloatSize.Width();
6455 }
6456 else
6457 {
6458 aFloatSize = pToolBox->CalcWindowSizePixel();
6459 if ( !bIsHorizontal )
6460 {
6461 // Floating toolbars are always horizontal aligned! We have to swap
6462 // width/height if we have a vertical aligned toolbar.
6463 sal_Int32 nTemp = aFloatSize.Height();
6464 aFloatSize.Height() = aFloatSize.Width();
6465 aFloatSize.Width() = nTemp;
6466 }
6467
6468 aDockingData.TrackingRectangle.Height = aFloatSize.Height();
6469 aDockingData.TrackingRectangle.Width = aFloatSize.Width();
6470
6471 // For the first time we don't have any data about the floating size of a toolbar.
6472 // We calculate it and store it for later use.
6473 aUIDockingElement.m_aFloatingData.m_aPos = pContainerWindow->ScreenToOutputPixel(
6474 ::Point( e.MousePos.X, e.MousePos.Y ));
6475 aUIDockingElement.m_aFloatingData.m_aSize = aFloatSize;
6476 aUIDockingElement.m_aFloatingData.m_nLines = pToolBox->GetFloatingLines();
6477 aUIDockingElement.m_aFloatingData.m_bIsHorizontal = (( pToolBox->GetAlign() == WINDOWALIGN_TOP ) ||
6478 ( pToolBox->GetAlign() == WINDOWALIGN_BOTTOM ));
6479 }
6480 aDockingData.TrackingRectangle.X = e.MousePos.X;
6481 aDockingData.TrackingRectangle.Y = e.MousePos.Y;
6482 }
6483
6484 aDockingData.bFloating = ( eDockingArea == -1 );
6485
6486 // Write current data to the member docking progress data
6487 WriteGuard aWriteLock( m_aLock );
6488 m_aDockUIElement.m_bFloating = aDockingData.bFloating;
6489 if ( !aDockingData.bFloating )
6490 {
6491 m_aDockUIElement.m_aDockedData = aUIDockingElement.m_aDockedData;
6492 m_eDockOperation = eDockingOperation;
6493 }
6494 else
6495 m_aDockUIElement.m_aFloatingData = aUIDockingElement.m_aFloatingData;
6496 aWriteLock.unlock();
6497 }
6498 catch ( Exception& )
6499 {
6500 }
6501 }
6502
6503 return aDockingData;
6504 }
6505
6506 void SAL_CALL LayoutManager::endDocking( const ::com::sun::star::awt::EndDockingEvent& e )
6507 throw (::com::sun::star::uno::RuntimeException)
6508 {
6509 sal_Bool bDockingInProgress( sal_False );
6510 sal_Bool bStartDockFloated( sal_False );
6511 sal_Bool bFloating( sal_False );
6512 UIElement aUIDockingElement;
6513
6514 WriteGuard aWriteLock( m_aLock );
6515 bDockingInProgress = m_bDockingInProgress;
6516 aUIDockingElement = m_aDockUIElement;
6517 bFloating = aUIDockingElement.m_bFloating;
6518
6519 UIElement& rUIElement = impl_findElement( aUIDockingElement.m_aName );
6520 if ( rUIElement.m_aName == aUIDockingElement.m_aName )
6521 {
6522 if ( aUIDockingElement.m_bFloating )
6523 {
6524 // Write last position into position data
6525 Reference< css::awt::XWindow > xWindow( aUIDockingElement.m_xUIElement->getRealInterface(), UNO_QUERY );
6526 rUIElement.m_aFloatingData = aUIDockingElement.m_aFloatingData;
6527 css::awt::Rectangle aTmpRect = xWindow->getPosSize();
6528 rUIElement.m_aFloatingData.m_aPos = ::Point( aTmpRect.X, aTmpRect.Y );
6529 // make changes also for our local data as we use it to make data persistent
6530 aUIDockingElement.m_aFloatingData = rUIElement.m_aFloatingData;
6531 }
6532 else
6533 {
6534 rUIElement.m_aDockedData = aUIDockingElement.m_aDockedData;
6535 rUIElement.m_aFloatingData.m_aSize = aUIDockingElement.m_aFloatingData.m_aSize;
6536
6537 if ( m_eDockOperation != DOCKOP_ON_COLROW )
6538 {
6539 // we have to renumber our row/column data to insert a new row/column
6540 implts_renumberRowColumnData( (::com::sun::star::ui::DockingArea)aUIDockingElement.m_aDockedData.m_nDockedArea,
6541 m_eDockOperation,
6542 aUIDockingElement );
6543 }
6544 }
6545
6546 bStartDockFloated = rUIElement.m_bFloating;
6547 rUIElement.m_bFloating = m_aDockUIElement.m_bFloating;
6548 rUIElement.m_bUserActive = sal_True;
6549 }
6550
6551 // reset member for next docking operation
6552 m_aDockUIElement.m_xUIElement.clear();
6553 m_eDockOperation = DOCKOP_ON_COLROW;
6554 aWriteLock.unlock();
6555
6556 implts_writeWindowStateData( aUIDockingElement.m_aName, aUIDockingElement );
6557
6558 if ( bDockingInProgress )
6559 {
6560 vos::OGuard aGuard( Application::GetSolarMutex() );
6561 Window* pWindow = VCLUnoHelper::GetWindow( Reference< css::awt::XWindow >( e.Source, UNO_QUERY ));
6562 ToolBox* pToolBox = 0;
6563 if ( pWindow && pWindow->GetType() == WINDOW_TOOLBOX )
6564 pToolBox = (ToolBox *)pWindow;
6565
6566 if ( pToolBox )
6567 {
6568 if( e.bFloating )
6569 {
6570 if ( aUIDockingElement.m_aFloatingData.m_bIsHorizontal )
6571 pToolBox->SetAlign( WINDOWALIGN_TOP );
6572 else
6573 pToolBox->SetAlign( WINDOWALIGN_LEFT );
6574 }
6575 else
6576 {
6577 ::Size aSize;
6578
6579 pToolBox->SetAlign( ImplConvertAlignment( aUIDockingElement.m_aDockedData.m_nDockedArea) );
6580
6581 // Docked toolbars have always one line
6582 aSize = pToolBox->CalcWindowSizePixel( 1 );
6583
6584 // Lock layouting updates as our listener would be called due to SetSizePixel
6585 pToolBox->SetOutputSizePixel( aSize );
6586 }
6587 }
6588 }
6589
6590 aWriteLock.lock();
6591 m_bDockingInProgress = sal_False;
6592 aWriteLock.unlock();
6593
6594 implts_sortUIElements();
6595 if ( !bStartDockFloated || !bFloating )
6596 {
6597 // Optimization: Don't layout if we started floating and now floating again.
6598 // This would not change anything for the docked user-interface elements.
6599 doLayout();
6600 }
6601 }
6602
6603 sal_Bool SAL_CALL LayoutManager::prepareToggleFloatingMode( const ::com::sun::star::lang::EventObject& e )
6604 throw (::com::sun::star::uno::RuntimeException)
6605 {
6606 sal_Bool bDockingInProgress( sal_False );
6607
6608 ReadGuard aReadLock( m_aLock );
6609 bDockingInProgress = m_bDockingInProgress;
6610 aReadLock.unlock();
6611
6612 UIElement aUIDockingElement;
6613 sal_Bool bWinFound( implts_findElement( e.Source, aUIDockingElement ) );
6614 Reference< css::awt::XWindow > xWindow( e.Source, UNO_QUERY );
6615
6616 if ( bWinFound && xWindow.is() )
6617 {
6618 if ( !bDockingInProgress )
6619 {
6620 css::awt::Rectangle aRect;
6621 Reference< css::awt::XDockableWindow > xDockWindow( xWindow, UNO_QUERY );
6622 if ( xDockWindow->isFloating() )
6623 {
6624 {
6625 vos::OGuard aGuard( Application::GetSolarMutex() );
6626 Window* pWindow = VCLUnoHelper::GetWindow( xWindow );
6627 if ( pWindow )
6628 {
6629 if ( pWindow->GetType() == WINDOW_TOOLBOX )
6630 {
6631 ToolBox* pToolBox = (ToolBox *)pWindow;
6632 aUIDockingElement.m_aFloatingData.m_aPos = pToolBox->GetPosPixel();
6633 aUIDockingElement.m_aFloatingData.m_aSize = pToolBox->GetOutputSizePixel();
6634 aUIDockingElement.m_aFloatingData.m_nLines = pToolBox->GetFloatingLines();
6635 aUIDockingElement.m_aFloatingData.m_bIsHorizontal = (( pToolBox->GetAlign() == WINDOWALIGN_TOP ) ||
6636 ( pToolBox->GetAlign() == WINDOWALIGN_BOTTOM ));
6637 }
6638 }
6639 }
6640
6641 WriteGuard aWriteLock( m_aLock );
6642 UIElement& rUIElement = LayoutManager::impl_findElement( aUIDockingElement.m_aName );
6643 if ( rUIElement.m_aName == aUIDockingElement.m_aName )
6644 rUIElement = aUIDockingElement;
6645 aWriteLock.unlock();
6646 }
6647 }
6648 }
6649
6650 return sal_True;
6651 }
6652
6653 void SAL_CALL LayoutManager::toggleFloatingMode( const ::com::sun::star::lang::EventObject& e )
6654 throw (::com::sun::star::uno::RuntimeException)
6655 {
6656 sal_Bool bDockingInProgress( sal_False );
6657 UIElement aUIDockingElement;
6658
6659 ReadGuard aReadLock( m_aLock );
6660 bDockingInProgress = m_bDockingInProgress;
6661 if ( bDockingInProgress )
6662 aUIDockingElement = m_aDockUIElement;
6663 aReadLock.unlock();
6664
6665 Window* pWindow( 0 );
6666 ToolBox* pToolBox( 0 );
6667 Reference< css::awt::XWindow2 > xWindow;
6668
6669 {
6670 vos::OGuard aGuard( Application::GetSolarMutex() );
6671 xWindow = Reference< css::awt::XWindow2 >( e.Source, UNO_QUERY );
6672 pWindow = VCLUnoHelper::GetWindow( xWindow );
6673
6674 if ( pWindow && pWindow->GetType() == WINDOW_TOOLBOX )
6675 pToolBox = (ToolBox *)pWindow;
6676 }
6677
6678 if ( !bDockingInProgress )
6679 {
6680 sal_Bool bWinFound( implts_findElement( e.Source, aUIDockingElement ) );
6681 if ( bWinFound && xWindow.is() )
6682 {
6683 aUIDockingElement.m_bFloating = !aUIDockingElement.m_bFloating;
6684 aUIDockingElement.m_bUserActive = sal_True;
6685
6686 WriteGuard aWriteLock( m_aLock );
6687 m_bDoLayout = sal_True;
6688 aWriteLock.unlock();
6689
6690 if ( aUIDockingElement.m_bFloating )
6691 {
6692 vos::OGuard aGuard( Application::GetSolarMutex() );
6693 if ( pToolBox )
6694 {
6695 pToolBox->SetLineCount( aUIDockingElement.m_aFloatingData.m_nLines );
6696 if ( aUIDockingElement.m_aFloatingData.m_bIsHorizontal )
6697 pToolBox->SetAlign( WINDOWALIGN_TOP );
6698 else
6699 pToolBox->SetAlign( WINDOWALIGN_LEFT );
6700 }
6701
6702 sal_Bool bUndefPos = ( aUIDockingElement.m_aFloatingData.m_aPos.X() == SAL_MAX_INT32 ||
6703 aUIDockingElement.m_aFloatingData.m_aPos.Y() == SAL_MAX_INT32 );
6704 sal_Bool bSetSize = ( aUIDockingElement.m_aFloatingData.m_aSize.Width() != 0 &&
6705 aUIDockingElement.m_aFloatingData.m_aSize.Height() != 0 );
6706
6707 if ( bUndefPos )
6708 aUIDockingElement.m_aFloatingData.m_aPos = implts_findNextCascadeFloatingPos();
6709
6710 if ( !bSetSize )
6711 {
6712 if ( pToolBox )
6713 aUIDockingElement.m_aFloatingData.m_aSize = pToolBox->CalcFloatingWindowSizePixel();
6714 else
6715 aUIDockingElement.m_aFloatingData.m_aSize = pWindow->GetOutputSizePixel();
6716 }
6717
6718 xWindow->setPosSize( aUIDockingElement.m_aFloatingData.m_aPos.X(),
6719 aUIDockingElement.m_aFloatingData.m_aPos.Y(),
6720 0, 0, css::awt::PosSize::POS );
6721 xWindow->setOutputSize( AWTSize( aUIDockingElement.m_aFloatingData.m_aSize ) );
6722 }
6723 else
6724 {
6725 if (( aUIDockingElement.m_aDockedData.m_aPos.X() == SAL_MAX_INT32 ) &&
6726 ( aUIDockingElement.m_aDockedData.m_aPos.Y() == SAL_MAX_INT32 ))
6727 {
6728 // Docking on its default position without a preset position -
6729 // we have to find a good place for it.
6730 ::Point aPixelPos;
6731 ::Point aDockPos;
6732 ::Size aSize;
6733
6734 {
6735 vos::OGuard aGuard( Application::GetSolarMutex() );
6736 if ( pToolBox )
6737 aSize = pToolBox->CalcWindowSizePixel( 1, ImplConvertAlignment( aUIDockingElement.m_aDockedData.m_nDockedArea ) );
6738 else
6739 aSize = pWindow->GetSizePixel();
6740 }
6741
6742 implts_findNextDockingPos( (::com::sun::star::ui::DockingArea)aUIDockingElement.m_aDockedData.m_nDockedArea,
6743 aSize,
6744 aDockPos,
6745 aPixelPos );
6746 aUIDockingElement.m_aDockedData.m_aPos = aDockPos;
6747 }
6748
6749 vos::OGuard aGuard( Application::GetSolarMutex() );
6750 if ( pToolBox )
6751 {
6752 pToolBox->SetAlign( ImplConvertAlignment( aUIDockingElement.m_aDockedData.m_nDockedArea) );
6753 ::Size aSize = pToolBox->CalcWindowSizePixel( 1 );
6754 css::awt::Rectangle aRect = xWindow->getPosSize();
6755 xWindow->setPosSize( aRect.X, aRect.Y, 0, 0, css::awt::PosSize::POS );
6756 xWindow->setOutputSize( AWTSize( aSize ) );
6757 }
6758 }
6759
6760 aWriteLock.lock();
6761 m_bDoLayout = sal_False;
6762 UIElement& rUIElement = LayoutManager::impl_findElement( aUIDockingElement.m_aName );
6763 if ( rUIElement.m_aName == aUIDockingElement.m_aName )
6764 rUIElement = aUIDockingElement;
6765 aWriteLock.unlock();
6766
6767 implts_writeWindowStateData( aUIDockingElement.m_aName, aUIDockingElement );
6768
6769 implts_sortUIElements();
6770 doLayout();
6771 }
6772 }
6773 else
6774 {
6775 vos::OGuard aGuard( Application::GetSolarMutex() );
6776 if ( pToolBox )
6777 {
6778 if ( aUIDockingElement.m_bFloating )
6779 {
6780 if ( aUIDockingElement.m_aFloatingData.m_bIsHorizontal )
6781 pToolBox->SetAlign( WINDOWALIGN_TOP );
6782 else
6783 pToolBox->SetAlign( WINDOWALIGN_LEFT );
6784 }
6785 else
6786 {
6787 pToolBox->SetAlign( ImplConvertAlignment( aUIDockingElement.m_aDockedData.m_nDockedArea) );
6788 }
6789 }
6790 }
6791 }
6792
6793 void SAL_CALL LayoutManager::closed( const ::com::sun::star::lang::EventObject& e )
6794 throw (::com::sun::star::uno::RuntimeException)
6795 {
6796 rtl::OUString aName;
6797 UIElement aUIElement;
6798 UIElementVector::iterator pIter;
6799
6800 WriteGuard aWriteLock( m_aLock );
6801 for ( pIter = m_aUIElements.begin(); pIter != m_aUIElements.end(); pIter++ )
6802 {
6803 Reference< XUIElement > xUIElement( pIter->m_xUIElement );
6804 if ( xUIElement.is() )
6805 {
6806 Reference< XInterface > xIfac( xUIElement->getRealInterface(), UNO_QUERY );
6807 if ( xIfac == e.Source )
6808 {
6809 aName = pIter->m_aName;
6810
6811 // user closes a toolbar =>
6812 // context sensitive toolbar: only destroy toolbar and store state.
6813 // context sensitive toolbar: make it invisible, store state and destroy it.
6814 if ( !pIter->m_bContextSensitive )
6815 pIter->m_bVisible = sal_False;
6816
6817 aUIElement = *pIter;
6818 break;
6819 }
6820 }
6821 }
6822 aWriteLock.unlock();
6823
6824
6825 // destroy element
6826 if ( aName.getLength() > 0 )
6827 {
6828 implts_writeWindowStateData( aName, aUIElement );
6829 destroyElement( aName );
6830 }
6831 }
6832
6833 void SAL_CALL LayoutManager::endPopupMode( const ::com::sun::star::awt::EndPopupModeEvent& )
6834 throw (::com::sun::star::uno::RuntimeException)
6835 {
6836
6837 }
6838
6839 //---------------------------------------------------------------------------------------------------------
6840 // XLayoutManagerEventBroadcaster
6841 //---------------------------------------------------------------------------------------------------------
6842 void SAL_CALL LayoutManager::addLayoutManagerEventListener( const ::com::sun::star::uno::Reference< ::com::sun::star::frame::XLayoutManagerListener >& xListener )
6843 throw (::com::sun::star::uno::RuntimeException)
6844 {
6845 m_aListenerContainer.addInterface( ::getCppuType( (const css::uno::Reference< css::frame::XLayoutManagerListener >*)NULL ), xListener );
6846 }
6847
6848 void SAL_CALL LayoutManager::removeLayoutManagerEventListener( const ::com::sun::star::uno::Reference< ::com::sun::star::frame::XLayoutManagerListener >& xListener )
6849 throw (::com::sun::star::uno::RuntimeException)
6850 {
6851 m_aListenerContainer.removeInterface( ::getCppuType( (const css::uno::Reference< css::frame::XLayoutManagerListener >*)NULL ), xListener );
6852 }
6853
6854 void LayoutManager::implts_notifyListeners( short nEvent, ::com::sun::star::uno::Any aInfoParam )
6855 {
6856 css::lang::EventObject aSource (static_cast< ::cppu::OWeakObject*>(this));
6857 ::cppu::OInterfaceContainerHelper* pContainer = m_aListenerContainer.getContainer( ::getCppuType( ( const css::uno::Reference< css::frame::XLayoutManagerListener >*) NULL ) );
6858 if (pContainer!=NULL)
6859 {
6860 ::cppu::OInterfaceIteratorHelper pIterator(*pContainer);
6861 while (pIterator.hasMoreElements())
6862 {
6863 try
6864 {
6865 ((css::frame::XLayoutManagerListener*)pIterator.next())->layoutEvent( aSource, nEvent, aInfoParam );
6866 }
6867 catch( css::uno::RuntimeException& )
6868 {
6869 pIterator.remove();
6870 }
6871 }
6872 }
6873 }
6874
6875 //---------------------------------------------------------------------------------------------------------
6876 // XWindowListener
6877 //---------------------------------------------------------------------------------------------------------
6878 void SAL_CALL LayoutManager::windowResized( const css::awt::WindowEvent& aEvent )
6879 throw( css::uno::RuntimeException )
6880 {
6881 /* SAFE AREA ----------------------------------------------------------------------------------------------- */
6882 WriteGuard aWriteLock( m_aLock );
6883
6884 if ( !m_xDockingAreaAcceptor.is() )
6885 return;
6886
6887 // Request to set docking area space again.
6888 css::awt::Rectangle aDockingArea( m_aDockingArea );
6889 Reference< XDockingAreaAcceptor > xDockingAreaAcceptor( m_xDockingAreaAcceptor );
6890 Reference< css::awt::XWindow > xContainerWindow( m_xContainerWindow );
6891
6892 Reference< XInterface > xIfac( xContainerWindow, UNO_QUERY );
6893 if ( xIfac == aEvent.Source && m_bVisible )
6894 {
6895 // We have to call our resize handler at least once synchronously, as some
6896 // application modules need this. So we have to check if this is the first
6897 // call after the async layout time expired.
6898 m_bMustDoLayout = sal_True;
6899 if ( !m_aAsyncLayoutTimer.IsActive() )
6900 {
6901 const Link& aLink = m_aAsyncLayoutTimer.GetTimeoutHdl();
6902 if ( aLink.IsSet() )
6903 aLink.Call( &m_aAsyncLayoutTimer );
6904 }
6905 if ( m_nLockCount == 0 )
6906 m_aAsyncLayoutTimer.Start();
6907 }
6908 else if ( m_xFrame.is() && aEvent.Source == m_xFrame->getContainerWindow() )
6909 {
6910 // the container window of my DockingAreaAcceptor is not the same as of my frame
6911 // I still have to resize my frames' window as nobody else will do it
6912 Reference< css::awt::XWindow > xComponentWindow( m_xFrame->getComponentWindow() );
6913 if( xComponentWindow.is() == sal_True )
6914 {
6915 css::uno::Reference< css::awt::XDevice > xDevice( m_xFrame->getContainerWindow(), css::uno::UNO_QUERY );
6916
6917 // Convert relativ size to output size.
6918 css::awt::Rectangle aRectangle = m_xFrame->getContainerWindow()->getPosSize();
6919 css::awt::DeviceInfo aInfo = xDevice->getInfo();
6920 css::awt::Size aSize ( aRectangle.Width - aInfo.LeftInset - aInfo.RightInset ,
6921 aRectangle.Height - aInfo.TopInset - aInfo.BottomInset );
6922
6923 // Resize our component window.
6924 xComponentWindow->setPosSize( 0, 0, aSize.Width, aSize.Height, css::awt::PosSize::POSSIZE );
6925 }
6926 }
6927 else
6928 {
6929 // resize event for one of the UIElements
6930 sal_Bool bLocked( m_bDockingInProgress );
6931 sal_Bool bDoLayout( m_bDoLayout );
6932 aWriteLock.unlock();
6933 /* SAFE AREA ----------------------------------------------------------------------------------------------- */
6934
6935 if ( !bLocked && !bDoLayout )
6936 {
6937 // Do not do anything if we are in the middle of a docking process. This would interfere all other
6938 // operations. We will store the new position and size in the docking handlers.
6939 // Do not do anything if we are in the middle of our layouting process. We will adapt the position
6940 // and size of the user interface elements.
6941 UIElement aUIElement;
6942 if ( implts_findElement( aEvent.Source, aUIElement ))
6943 {
6944 if ( aUIElement.m_bFloating )
6945 implts_writeNewStateData( aUIElement.m_aName,
6946 Reference< css::awt::XWindow >( aEvent.Source, UNO_QUERY ));
6947 else
6948 doLayout();
6949 }
6950 }
6951 }
6952 }
6953
6954 void SAL_CALL LayoutManager::windowMoved( const css::awt::WindowEvent& ) throw( css::uno::RuntimeException )
6955 {
6956 }
6957
6958 void SAL_CALL LayoutManager::windowShown( const css::lang::EventObject& aEvent ) throw( css::uno::RuntimeException )
6959 {
6960 /* SAFE AREA ----------------------------------------------------------------------------------------------- */
6961 ReadGuard aReadLock( m_aLock );
6962
6963 // Request to set docking area space again.
6964 Reference< css::awt::XWindow > xContainerWindow( m_xContainerWindow );
6965 bool bParentWindowVisible( m_bParentWindowVisible );
6966 aReadLock.unlock();
6967 /* SAFE AREA ----------------------------------------------------------------------------------------------- */
6968
6969 Reference< XInterface > xIfac( xContainerWindow, UNO_QUERY );
6970 if ( xIfac == aEvent.Source )
6971 {
6972 bool bSetVisible = false;
6973
6974 /* SAFE AREA ----------------------------------------------------------------------------------------------- */
6975 WriteGuard aWriteLock( m_aLock );
6976 m_bParentWindowVisible = true;
6977 bSetVisible = ( m_bParentWindowVisible != bParentWindowVisible );
6978 aWriteLock.unlock();
6979 /* SAFE AREA ----------------------------------------------------------------------------------------------- */
6980
6981 if ( bSetVisible )
6982 {
6983 implts_updateUIElementsVisibleState( sal_True );
6984 //implts_doLayout( sal_False );
6985 }
6986 }
6987 }
6988
6989 void SAL_CALL LayoutManager::windowHidden( const css::lang::EventObject& aEvent ) throw( css::uno::RuntimeException )
6990 {
6991 /* SAFE AREA ----------------------------------------------------------------------------------------------- */
6992 ReadGuard aReadLock( m_aLock );
6993
6994 // Request to set docking area space again.
6995 Reference< css::awt::XWindow > xContainerWindow( m_xContainerWindow );
6996 bool bParentWindowVisible( m_bParentWindowVisible );
6997 aReadLock.unlock();
6998 /* SAFE AREA ----------------------------------------------------------------------------------------------- */
6999
7000 Reference< XInterface > xIfac( xContainerWindow, UNO_QUERY );
7001 if ( xIfac == aEvent.Source )
7002 {
7003 bool bSetInvisible = false;
7004
7005 /* SAFE AREA ----------------------------------------------------------------------------------------------- */
7006 WriteGuard aWriteLock( m_aLock );
7007 m_bParentWindowVisible = false;
7008 bSetInvisible = ( m_bParentWindowVisible != bParentWindowVisible );
7009 aWriteLock.unlock();
7010 /* SAFE AREA ----------------------------------------------------------------------------------------------- */
7011
7012 if ( bSetInvisible )
7013 implts_updateUIElementsVisibleState( sal_False );
7014 }
7015 }
7016
7017 IMPL_LINK( LayoutManager, AsyncLayoutHdl, Timer *, EMPTYARG )
7018 {
7019 /* SAFE AREA ----------------------------------------------------------------------------------------------- */
7020 ReadGuard aReadLock( m_aLock );
7021
7022 // Request to set docking area space again.
7023 m_aAsyncLayoutTimer.Stop();
7024
7025 if( !m_xContainerWindow.is() )
7026 return 0;
7027
7028 css::awt::Rectangle aDockingArea( m_aDockingArea );
7029 ::Size aStatusBarSize( implts_getStatusBarSize() );
7030
7031 // Subtract status bar height
7032 aDockingArea.Height -= aStatusBarSize.Height();
7033 aReadLock.unlock();
7034
7035 implts_setDockingAreaWindowSizes( aDockingArea );
7036 implts_doLayout( sal_True );
7037
7038 return 0;
7039 }
7040
7041 void LayoutManager::implts_checkElementContainer()
7042 {
7043 #ifdef DBG_UTIL
7044 /* SAFE AREA ----------------------------------------------------------------------------------------------- */
7045 ReadGuard aReadLock( m_aLock );
7046
7047 BaseHash< sal_Int32 > aUIElementHash;
7048
7049 UIElementVector::iterator pIter;
7050 for ( pIter = m_aUIElements.begin(); pIter != m_aUIElements.end(); pIter++ )
7051 aUIElementHash[pIter->m_aName]++;
7052
7053
7054 BaseHash< sal_Int32 >::const_iterator pCheckIter = aUIElementHash.begin();
7055 for ( ; pCheckIter != aUIElementHash.end(); pCheckIter++ )
7056 {
7057 if ( pCheckIter->second > 1 )
7058 {
7059 ::rtl::OString aName = ::rtl::OUStringToOString( pCheckIter->first, RTL_TEXTENCODING_ASCII_US );
7060 DBG_ASSERT( "More than one element (%s) with the same name found!", aName.getStr() );
7061 }
7062 } // for ( ; pCheckIter != aUIElementHash.end(); pCheckIter++ )
7063 #endif
7064 }
7065
7066 //---------------------------------------------------------------------------------------------------------
7067 // XFrameActionListener
7068 //---------------------------------------------------------------------------------------------------------
7069 void SAL_CALL LayoutManager::frameAction( const FrameActionEvent& aEvent )
7070 throw ( RuntimeException )
7071 {
7072 if (( aEvent.Action == FrameAction_COMPONENT_ATTACHED ) ||
7073 ( aEvent.Action == FrameAction_COMPONENT_REATTACHED ))
7074 {
7075 RTL_LOGFILE_CONTEXT( aLog, "framework (cd100003) ::LayoutManager::frameAction (COMPONENT_ATTACHED|REATTACHED)" );
7076
7077 /* SAFE AREA ----------------------------------------------------------------------------------------------- */
7078 WriteGuard aWriteLock( m_aLock );
7079 m_bComponentAttached = sal_True;
7080 m_bMustDoLayout = sal_True;
7081 aWriteLock.unlock();
7082 /* SAFE AREA ----------------------------------------------------------------------------------------------- */
7083
7084 implts_reset( sal_True );
7085 implts_doLayout( sal_True );
7086 }
7087 else if (( aEvent.Action == FrameAction_FRAME_UI_ACTIVATED ) ||
7088 ( aEvent.Action == FrameAction_FRAME_UI_DEACTIVATING ))
7089 {
7090 RTL_LOGFILE_CONTEXT( aLog, "framework (cd100003) ::LayoutManager::frameAction (FRAME_UI_ACTIVATED|DEACTIVATING)" );
7091
7092 /* SAFE AREA ----------------------------------------------------------------------------------------------- */
7093 WriteGuard aWriteLock( m_aLock );
7094 m_bActive = ( aEvent.Action == FrameAction_FRAME_UI_ACTIVATED );
7095 aWriteLock.unlock();
7096 /* SAFE AREA ----------------------------------------------------------------------------------------------- */
7097
7098 implts_toggleFloatingUIElementsVisibility( aEvent.Action == FrameAction_FRAME_UI_ACTIVATED );
7099 // doLayout();
7100 }
7101 else if ( aEvent.Action == FrameAction_COMPONENT_DETACHING )
7102 {
7103 RTL_LOGFILE_CONTEXT( aLog, "framework (cd100003) ::LayoutManager::frameAction (COMPONENT_DETACHING)" );
7104
7105 // SAFE AREA -----------------------------------------------------------------------------------------------
7106 WriteGuard aWriteLock( m_aLock );
7107 m_bComponentAttached = sal_False;
7108 aWriteLock.unlock();
7109 // SAFE AREA -----------------------------------------------------------------------------------------------
7110
7111 implts_reset( sal_False );
7112
7113 }
7114 }
7115
7116 // ______________________________________________
7117
7118 void SAL_CALL LayoutManager::disposing( const css::lang::EventObject& rEvent )
7119 throw( RuntimeException )
7120 {
7121 sal_Bool bDisposeAndClear( sal_False );
7122
7123 /* SAFE AREA ----------------------------------------------------------------------------------------------- */
7124 WriteGuard aWriteLock( m_aLock );
7125
7126 if ( rEvent.Source == Reference< XInterface >( m_xFrame, UNO_QUERY ))
7127 {
7128 // Our frame gets disposed, release all our references that depends on a working
7129 // frame reference.
7130 Application::RemoveEventListener( LINK( this, LayoutManager, SettingsChanged ) );
7131 if ( m_pMiscOptions )
7132 {
7133 m_pMiscOptions->RemoveListener( LINK( this, LayoutManager, OptionsChanged ) );
7134 delete m_pMiscOptions;
7135 m_pMiscOptions = 0;
7136 }
7137
7138 delete m_pAddonOptions;
7139 m_pAddonOptions = 0;
7140
7141 // destroy all elements, it's possible that dettaching is NOT called!
7142 implts_destroyElements();
7143
7144 m_aUIElements.clear();
7145 impl_clearUpMenuBar();
7146 m_xMenuBar.clear();
7147 if ( m_xInplaceMenuBar.is() )
7148 {
7149 m_pInplaceMenuBar = 0;
7150 m_xInplaceMenuBar->dispose();
7151 }
7152 m_xInplaceMenuBar.clear();
7153 m_xContainerWindow.clear();
7154 implts_destroyDockingAreaWindows();
7155
7156 if ( m_xModuleCfgMgr.is() )
7157 {
7158 try
7159 {
7160 Reference< XUIConfiguration > xModuleCfgMgr( m_xModuleCfgMgr, UNO_QUERY );
7161 xModuleCfgMgr->removeConfigurationListener(
7162 Reference< XUIConfigurationListener >( static_cast< OWeakObject* >( this ), UNO_QUERY ));
7163 }
7164 catch ( Exception& )
7165 {
7166 }
7167 }
7168
7169 if ( m_xDocCfgMgr.is() )
7170 {
7171 try
7172 {
7173 Reference< XUIConfiguration > xDocCfgMgr( m_xDocCfgMgr, UNO_QUERY );
7174 xDocCfgMgr->removeConfigurationListener(
7175 Reference< XUIConfigurationListener >( static_cast< OWeakObject* >( this ), UNO_QUERY ));
7176 }
7177 catch ( Exception& )
7178 {
7179 }
7180 }
7181
7182 m_xDocCfgMgr.clear();
7183 m_xModuleCfgMgr.clear();
7184 m_xFrame.clear();
7185 delete m_pGlobalSettings;
7186 m_pGlobalSettings = 0;
7187 m_xDockingAreaAcceptor = Reference< ::com::sun::star::ui::XDockingAreaAcceptor >();
7188
7189 bDisposeAndClear = sal_True;
7190 }
7191 else if ( rEvent.Source == Reference< XInterface >( m_xContainerWindow, UNO_QUERY ))
7192 {
7193 // Our container window gets disposed. Remove all user interface elements.
7194 m_aUIElements.clear();
7195 impl_clearUpMenuBar();
7196 m_xMenuBar.clear();
7197 if ( m_xInplaceMenuBar.is() )
7198 {
7199 m_pInplaceMenuBar = 0;
7200 m_xInplaceMenuBar->dispose();
7201 }
7202 m_xInplaceMenuBar.clear();
7203 m_xContainerWindow.clear();
7204 }
7205 else if ( rEvent.Source == Reference< XInterface >( m_xDocCfgMgr, UNO_QUERY ))
7206 {
7207 m_xDocCfgMgr.clear();
7208 }
7209 else if ( rEvent.Source == Reference< XInterface >( m_xModuleCfgMgr , UNO_QUERY ))
7210 {
7211 m_xModuleCfgMgr.clear();
7212 }
7213
7214 aWriteLock.unlock();
7215 /* SAFE AREA ----------------------------------------------------------------------------------------------- */
7216
7217 // Send disposing to our listener when we have lost our frame.
7218 if ( bDisposeAndClear )
7219 {
7220 // Send message to all listener and forget her references.
7221 css::uno::Reference< css::frame::XLayoutManager > xThis( static_cast< ::cppu::OWeakObject* >(this), css::uno::UNO_QUERY );
7222 css::lang::EventObject aEvent( xThis );
7223 m_aListenerContainer.disposeAndClear( aEvent );
7224 }
7225 }
7226
7227 void SAL_CALL LayoutManager::elementInserted( const ::com::sun::star::ui::ConfigurationEvent& Event ) throw (::com::sun::star::uno::RuntimeException)
7228 {
7229 ReadGuard aReadLock( m_aLock );
7230
7231 ::rtl::OUString aElementType;
7232 ::rtl::OUString aElementName;
7233 Reference< XUIElement > xElement;
7234 Reference< XFrame > xFrame( m_xFrame );
7235
7236 if ( m_xFrame.is() )
7237 {
7238 implts_findElement( Event.ResourceURL, aElementType, aElementName, xElement );
7239
7240 Reference< XUIElementSettings > xElementSettings( xElement, UNO_QUERY );
7241 if ( xElementSettings.is() )
7242 {
7243 ::rtl::OUString aConfigSourcePropName( RTL_CONSTASCII_USTRINGPARAM( "ConfigurationSource" ));
7244 Reference< XPropertySet > xPropSet( xElementSettings, UNO_QUERY );
7245 if ( xPropSet.is() )
7246 {
7247 if ( Event.Source == Reference< XInterface >( m_xDocCfgMgr, UNO_QUERY ))
7248 xPropSet->setPropertyValue( aConfigSourcePropName, makeAny( m_xDocCfgMgr ));
7249 }
7250 xElementSettings->updateSettings();
7251 }
7252 else
7253 {
7254 if ( aElementType.equalsIgnoreAsciiCaseAscii( "toolbar" ) &&
7255 ( aElementName.indexOf( m_aCustomTbxPrefix ) != -1 ))
7256 {
7257 // custom toolbar must be directly created, shown and layouted!
7258 createElement( Event.ResourceURL );
7259 Reference< XUIElement > xUIElement = getElement( Event.ResourceURL );
7260 if ( xUIElement.is() )
7261 {
7262 Reference< XUIConfigurationManager > xCfgMgr;
7263 Reference< XPropertySet > xPropSet;
7264 ::rtl::OUString aUIName;
7265
7266 try
7267 {
7268 xCfgMgr = Reference< XUIConfigurationManager >( Event.Source, UNO_QUERY );
7269 xPropSet = Reference< XPropertySet >( xCfgMgr->getSettings( Event.ResourceURL, sal_False ), UNO_QUERY );
7270
7271 if ( xPropSet.is() )
7272 xPropSet->getPropertyValue( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "UIName" ))) >>= aUIName;
7273 }
7274 catch ( com::sun::star::container::NoSuchElementException& )
7275 {
7276 }
7277 catch ( com::sun::star::beans::UnknownPropertyException& )
7278 {
7279 }
7280 catch ( com::sun::star::lang::WrappedTargetException& )
7281 {
7282 }
7283
7284 {
7285 vos::OGuard aGuard( Application::GetSolarMutex() );
7286 Reference< css::awt::XWindow > xWindow( xUIElement->getRealInterface(), UNO_QUERY );
7287 Window* pWindow = VCLUnoHelper::GetWindow( xWindow );
7288 if ( pWindow )
7289 pWindow->SetText( aUIName );
7290 }
7291
7292 showElement( Event.ResourceURL );
7293 }
7294 }
7295 }
7296 }
7297 }
7298
7299 void SAL_CALL LayoutManager::elementRemoved( const ::com::sun::star::ui::ConfigurationEvent& Event ) throw (::com::sun::star::uno::RuntimeException)
7300 {
7301 /* SAFE AREA ----------------------------------------------------------------------------------------------- */
7302 WriteGuard aWriteLock( m_aLock );
7303
7304 ::rtl::OUString aElementType;
7305 ::rtl::OUString aElementName;
7306 Reference< XUIElement > xUIElement;
7307 Reference< XFrame > xFrame( m_xFrame );
7308
7309 if ( m_xFrame.is() )
7310 {
7311 implts_findElement( Event.ResourceURL, aElementType, aElementName, xUIElement );
7312
7313 Reference< XUIElementSettings > xElementSettings( xUIElement, UNO_QUERY );
7314 if ( xElementSettings.is() )
7315 {
7316 bool bNoSettings( false );
7317 ::rtl::OUString aConfigSourcePropName( RTL_CONSTASCII_USTRINGPARAM( "ConfigurationSource" ));
7318 Reference< XInterface > xElementCfgMgr;
7319 Reference< XPropertySet > xPropSet( xElementSettings, UNO_QUERY );
7320
7321 if ( xPropSet.is() )
7322 xPropSet->getPropertyValue( aConfigSourcePropName ) >>= xElementCfgMgr;
7323
7324 if ( !xElementCfgMgr.is() )
7325 return;
7326
7327 // Check if the same UI configuration manager has changed => check further
7328 if ( Event.Source == xElementCfgMgr )
7329 {
7330 // Same UI configuration manager where our element has its settings
7331 if ( Event.Source == Reference< XInterface >( m_xDocCfgMgr, UNO_QUERY ))
7332 {
7333 // document settings removed
7334 if ( m_xModuleCfgMgr->hasSettings( Event.ResourceURL ))
7335 {
7336 xPropSet->setPropertyValue( aConfigSourcePropName, makeAny( m_xModuleCfgMgr ));
7337 xElementSettings->updateSettings();
7338 return;
7339 }
7340 }
7341
7342 bNoSettings = true;
7343 }
7344
7345 // No settings anymore, element must be destroyed
7346 if ( m_xContainerWindow.is() && bNoSettings )
7347 {
7348 if ( aElementType.equalsIgnoreAsciiCaseAscii( "menubar" ) &&
7349 aElementName.equalsIgnoreAsciiCaseAscii( "menubar" ))
7350 {
7351 Window* pWindow = VCLUnoHelper::GetWindow( m_xContainerWindow );
7352 while ( pWindow && !pWindow->IsSystemWindow() )
7353 pWindow = pWindow->GetParent();
7354
7355 if ( pWindow && !m_bInplaceMenuSet )
7356 ((SystemWindow *)pWindow)->SetMenuBar( 0 );
7357
7358 Reference< XComponent > xComp( m_xMenuBar, UNO_QUERY );
7359 if ( xComp.is() )
7360 xComp->dispose();
7361 m_xMenuBar.clear();
7362 }
7363 else if ( aElementType.equalsIgnoreAsciiCaseAscii( "toolbar" ))
7364 {
7365 destroyElement( Event.ResourceURL );
7366 }
7367 }
7368 }
7369 }
7370 }
7371
7372 void SAL_CALL LayoutManager::elementReplaced( const ::com::sun::star::ui::ConfigurationEvent& Event ) throw (::com::sun::star::uno::RuntimeException)
7373 {
7374 ReadGuard aReadLock( m_aLock );
7375
7376 ::rtl::OUString aElementType;
7377 ::rtl::OUString aElementName;
7378 Reference< XUIElement > xUIElement;
7379 Reference< XFrame > xFrame( m_xFrame );
7380
7381 if ( m_xFrame.is() )
7382 {
7383 implts_findElement( Event.ResourceURL, aElementType, aElementName, xUIElement );
7384
7385 Reference< XUIElementSettings > xElementSettings( xUIElement, UNO_QUERY );
7386 if ( xElementSettings.is() )
7387 {
7388 ::rtl::OUString aConfigSourcePropName( RTL_CONSTASCII_USTRINGPARAM( "ConfigurationSource" ));
7389 Reference< XInterface > xElementCfgMgr;
7390 Reference< XPropertySet > xPropSet( xElementSettings, UNO_QUERY );
7391
7392 if ( xPropSet.is() )
7393 xPropSet->getPropertyValue( aConfigSourcePropName ) >>= xElementCfgMgr;
7394
7395 if ( !xElementCfgMgr.is() )
7396 return;
7397
7398 // Check if the same UI configuration manager has changed => update settings
7399 if ( Event.Source == xElementCfgMgr )
7400 {
7401 xElementSettings->updateSettings();
7402 if ( aElementType.equalsIgnoreAsciiCaseAscii( "toolbar" ))
7403 doLayout();
7404 }
7405 }
7406 }
7407 }
7408
7409 //---------------------------------------------------------------------------------------------------------
7410 // OPropertySetHelper
7411 //---------------------------------------------------------------------------------------------------------
7412 // XPropertySet helper
7413 sal_Bool SAL_CALL LayoutManager::convertFastPropertyValue( Any& aConvertedValue ,
7414 Any& aOldValue ,
7415 sal_Int32 nHandle ,
7416 const Any& aValue ) throw( com::sun::star::lang::IllegalArgumentException )
7417 {
7418 // Initialize state with FALSE !!!
7419 // (Handle can be invalid)
7420 sal_Bool bReturn = sal_False;
7421
7422 switch( nHandle )
7423 {
7424 case LAYOUTMANAGER_PROPHANDLE_MENUBARCLOSER :
7425 bReturn = PropHelper::willPropertyBeChanged(
7426 com::sun::star::uno::makeAny(m_bMenuBarCloser),
7427 aValue,
7428 aOldValue,
7429 aConvertedValue);
7430 break;
7431 case LAYOUTMANAGER_PROPHANDLE_AUTOMATICTOOLBARS:
7432 bReturn = PropHelper::willPropertyBeChanged(
7433 com::sun::star::uno::makeAny(m_bAutomaticToolbars),
7434 aValue,
7435 aOldValue,
7436 aConvertedValue);
7437 break;
7438 case LAYOUTMANAGER_PROPHANDLE_REFRESHVISIBILITY:
7439 bReturn = PropHelper::willPropertyBeChanged(
7440 com::sun::star::uno::makeAny(sal_False),
7441 aValue,
7442 aOldValue,
7443 aConvertedValue);
7444 break;
7445 case LAYOUTMANAGER_PROPHANDLE_HIDECURRENTUI:
7446 bReturn = PropHelper::willPropertyBeChanged(
7447 com::sun::star::uno::makeAny(m_bHideCurrentUI),
7448 aValue,
7449 aOldValue,
7450 aConvertedValue);
7451 break;
7452 }
7453
7454 // Return state of operation.
7455 return bReturn ;
7456 }
7457
7458 void SAL_CALL LayoutManager::setFastPropertyValue_NoBroadcast( sal_Int32 nHandle ,
7459 const com::sun::star::uno::Any& aValue ) throw( com::sun::star::uno::Exception )
7460 {
7461 switch( nHandle )
7462 {
7463 case LAYOUTMANAGER_PROPHANDLE_MENUBARCLOSER:
7464 {
7465 sal_Bool bCloserState = sal_False;
7466 aValue >>= bCloserState;
7467 implts_setMenuBarCloser( bCloserState );
7468 break;
7469 }
7470 case LAYOUTMANAGER_PROPHANDLE_AUTOMATICTOOLBARS:
7471 {
7472 sal_Bool bValue = sal_Bool();
7473 if ( aValue >>= bValue )
7474 m_bAutomaticToolbars = bValue;
7475 break;
7476 }
7477 case LAYOUTMANAGER_PROPHANDLE_REFRESHVISIBILITY:
7478 {
7479 sal_Bool bValue = sal_Bool();
7480 if (( aValue >>= bValue ) && bValue )
7481 implts_refreshContextToolbarsVisibility();
7482 break;
7483 }
7484 case LAYOUTMANAGER_PROPHANDLE_HIDECURRENTUI:
7485 {
7486 sal_Bool bValue = sal_Bool();
7487 if ( aValue >>= bValue )
7488 {
7489 m_bHideCurrentUI = bValue;
7490 implts_setCurrentUIVisibility( !bValue );
7491 }
7492 break;
7493 }
7494 }
7495 }
7496
7497 void SAL_CALL LayoutManager::getFastPropertyValue( com::sun::star::uno::Any& aValue ,
7498 sal_Int32 nHandle ) const
7499 {
7500 switch( nHandle )
7501 {
7502 case LAYOUTMANAGER_PROPHANDLE_MENUBARCLOSER:
7503 aValue <<= m_bMenuBarCloser;
7504 break;
7505 case LAYOUTMANAGER_PROPHANDLE_AUTOMATICTOOLBARS:
7506 aValue <<= m_bAutomaticToolbars;
7507 break;
7508 case LAYOUTMANAGER_PROPHANDLE_REFRESHVISIBILITY:
7509 aValue <<= sal_False;
7510 break;
7511 case LAYOUTMANAGER_PROPHANDLE_HIDECURRENTUI:
7512 aValue <<= m_bHideCurrentUI;
7513 break;
7514 case LAYOUTMANAGER_PROPHANDLE_LOCKCOUNT:
7515 aValue <<= m_nLockCount;
7516 break;
7517 }
7518 }
7519
7520 ::cppu::IPropertyArrayHelper& SAL_CALL LayoutManager::getInfoHelper()
7521 {
7522 // Optimize this method !
7523 // We initialize a static variable only one time. And we don't must use a mutex at every call!
7524 // For the first call; pInfoHelper is NULL - for the second call pInfoHelper is different from NULL!
7525 static ::cppu::OPropertyArrayHelper* pInfoHelper = NULL;
7526
7527 if( pInfoHelper == NULL )
7528 {
7529 // Ready for multithreading
7530 osl::MutexGuard aGuard( osl::Mutex::getGlobalMutex() ) ;
7531
7532 // Control this pointer again, another instance can be faster then these!
7533 if( pInfoHelper == NULL )
7534 {
7535 // Define static member to give structure of properties to baseclass "OPropertySetHelper".
7536 // "impl_getStaticPropertyDescriptor" is a non exported and static funtion, who will define a static propertytable.
7537 // "sal_True" say: Table is sorted by name.
7538 static ::cppu::OPropertyArrayHelper aInfoHelper( impl_getStaticPropertyDescriptor(), sal_True );
7539 pInfoHelper = &aInfoHelper;
7540 }
7541 }
7542
7543 return(*pInfoHelper);
7544 }
7545
7546 com::sun::star::uno::Reference< com::sun::star::beans::XPropertySetInfo > SAL_CALL LayoutManager::getPropertySetInfo() throw (::com::sun::star::uno::RuntimeException)
7547 {
7548 // Optimize this method !
7549 // We initialize a static variable only one time. And we don't must use a mutex at every call!
7550 // For the first call; pInfo is NULL - for the second call pInfo is different from NULL!
7551 static com::sun::star::uno::Reference< com::sun::star::beans::XPropertySetInfo >* pInfo = NULL;
7552
7553 if( pInfo == NULL )
7554 {
7555 // Ready for multithreading
7556 osl::MutexGuard aGuard( osl::Mutex::getGlobalMutex() ) ;
7557 // Control this pointer again, another instance can be faster then these!
7558 if( pInfo == NULL )
7559 {
7560 // Create structure of propertysetinfo for baseclass "OPropertySetHelper".
7561 // (Use method "getInfoHelper()".)
7562 static com::sun::star::uno::Reference< com::sun::star::beans::XPropertySetInfo > xInfo( createPropertySetInfo( getInfoHelper() ) );
7563 pInfo = &xInfo;
7564 }
7565 }
7566
7567 return (*pInfo);
7568 }
7569
7570 const com::sun::star::uno::Sequence< com::sun::star::beans::Property > LayoutManager::impl_getStaticPropertyDescriptor()
7571 {
7572 // Create a new static property array to initialize sequence!
7573 // Table of all predefined properties of this class. Its used from OPropertySetHelper-class!
7574 // Don't forget to change the defines (see begin of this file), if you add, change or delete a property in this list!!!
7575 // It's necessary for methods of OPropertySetHelper.
7576 // ATTENTION:
7577 // YOU MUST SORT FOLLOW TABLE BY NAME ALPHABETICAL !!!
7578
7579 static const com::sun::star::beans::Property pProperties[] =
7580 {
7581 com::sun::star::beans::Property( LAYOUTMANAGER_PROPNAME_AUTOMATICTOOLBARS, LAYOUTMANAGER_PROPHANDLE_AUTOMATICTOOLBARS, ::getCppuType((const sal_Bool*)NULL), com::sun::star::beans::PropertyAttribute::TRANSIENT ),
7582 com::sun::star::beans::Property( LAYOUTMANAGER_PROPNAME_HIDECURRENTUI, LAYOUTMANAGER_PROPHANDLE_HIDECURRENTUI, ::getCppuType((const sal_Bool*)NULL), com::sun::star::beans::PropertyAttribute::TRANSIENT ),
7583 com::sun::star::beans::Property( LAYOUTMANAGER_PROPNAME_LOCKCOUNT, LAYOUTMANAGER_PROPHANDLE_LOCKCOUNT, ::getCppuType((const sal_Int32*)NULL), com::sun::star::beans::PropertyAttribute::TRANSIENT|com::sun::star::beans::PropertyAttribute::READONLY ),
7584 com::sun::star::beans::Property( LAYOUTMANAGER_PROPNAME_MENUBARCLOSER, LAYOUTMANAGER_PROPHANDLE_MENUBARCLOSER, ::getCppuType((const sal_Bool*)NULL), com::sun::star::beans::PropertyAttribute::TRANSIENT ),
7585 com::sun::star::beans::Property( LAYOUTMANAGER_PROPNAME_REFRESHVISIBILITY, LAYOUTMANAGER_PROPHANDLE_REFRESHVISIBILITY, ::getCppuType((const sal_Bool*)NULL), com::sun::star::beans::PropertyAttribute::TRANSIENT )
7586 };
7587 // Use it to initialize sequence!
7588 static const com::sun::star::uno::Sequence< com::sun::star::beans::Property > lPropertyDescriptor( pProperties, LAYOUTMANAGER_PROPCOUNT );
7589 // Return static "PropertyDescriptor"
7590 return lPropertyDescriptor;
7591 }
7592
7593 } // namespace framework
7594
vba interoperability for OOo