Line data Source code
1 : /*
2 : * This file is part of the LibreOffice project.
3 : *
4 : * This Source Code Form is subject to the terms of the Mozilla Public
5 : * License, v. 2.0. If a copy of the MPL was not distributed with this
6 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
7 : *
8 : * This file incorporates work covered by the following license notice:
9 : *
10 : * Licensed to the Apache Software Foundation (ASF) under one or more
11 : * contributor license agreements. See the NOTICE file distributed
12 : * with this work for additional information regarding copyright
13 : * ownership. The ASF licenses this file to you under the Apache
14 : * License, Version 2.0 (the "License"); you may not use this file
15 : * except in compliance with the License. You may obtain a copy of
16 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
17 : */
18 :
19 : #include <uielement/toolbarmanager.hxx>
20 :
21 : #include <uielement/generictoolbarcontroller.hxx>
22 : #include "services.h"
23 : #include "general.h"
24 : #include "properties.h"
25 : #include <framework/imageproducer.hxx>
26 : #include <framework/sfxhelperfunctions.hxx>
27 : #include <classes/fwkresid.hxx>
28 : #include <classes/resource.hrc>
29 : #include <framework/addonsoptions.hxx>
30 : #include <uielement/toolbarmerger.hxx>
31 :
32 : #include <com/sun/star/ui/ItemType.hpp>
33 : #include <com/sun/star/frame/XDispatchProvider.hpp>
34 : #include <com/sun/star/frame/theUICommandDescription.hpp>
35 : #include <com/sun/star/beans/XPropertySet.hpp>
36 : #include <com/sun/star/awt/XDockableWindow.hpp>
37 : #include <com/sun/star/frame/XLayoutManager.hpp>
38 : #include <com/sun/star/ui/DockingArea.hpp>
39 : #include <com/sun/star/graphic/XGraphic.hpp>
40 : #include <com/sun/star/lang/XMultiComponentFactory.hpp>
41 : #include <com/sun/star/lang/XMultiServiceFactory.hpp>
42 : #include <com/sun/star/frame/ModuleManager.hpp>
43 : #include <com/sun/star/frame/theToolbarControllerFactory.hpp>
44 : #include <com/sun/star/ui/GlobalAcceleratorConfiguration.hpp>
45 : #include <com/sun/star/ui/XUIElementSettings.hpp>
46 : #include <com/sun/star/ui/XUIConfigurationPersistence.hpp>
47 : #include <com/sun/star/ui/theModuleUIConfigurationManagerSupplier.hpp>
48 : #include <com/sun/star/ui/XUIConfigurationManagerSupplier.hpp>
49 : #include <com/sun/star/ui/ImageType.hpp>
50 : #include <com/sun/star/ui/UIElementType.hpp>
51 : #include <comphelper/sequence.hxx>
52 : #include <com/sun/star/frame/status/Visibility.hpp>
53 : #include <com/sun/star/lang/DisposedException.hpp>
54 : #include <com/sun/star/util/URLTransformer.hpp>
55 :
56 : #include <svtools/imgdef.hxx>
57 : #include <svtools/toolboxcontroller.hxx>
58 : #include <unotools/cmdoptions.hxx>
59 : #include <toolkit/helper/vclunohelper.hxx>
60 : #include <unotools/mediadescriptor.hxx>
61 : #include <comphelper/processfactory.hxx>
62 : #include <svtools/miscopt.hxx>
63 : #include <svl/imageitm.hxx>
64 : #include <svtools/framestatuslistener.hxx>
65 : #include <vcl/svapp.hxx>
66 : #include <vcl/menu.hxx>
67 : #include <vcl/syswin.hxx>
68 : #include <vcl/taskpanelist.hxx>
69 : #include <vcl/toolbox.hxx>
70 : #include <vcl/settings.hxx>
71 :
72 : #include <svtools/menuoptions.hxx>
73 : #include <boost/bind.hpp>
74 : #include <svtools/acceleratorexecute.hxx>
75 :
76 : // namespaces
77 :
78 : using namespace ::com::sun::star::awt;
79 : using namespace ::com::sun::star::beans;
80 : using namespace ::com::sun::star::uno;
81 : using namespace ::com::sun::star::lang;
82 : using namespace ::com::sun::star::frame;
83 : using namespace ::com::sun::star::graphic;
84 : using namespace ::com::sun::star::util;
85 : using namespace ::com::sun::star::container;
86 : using namespace ::com::sun::star::ui;
87 : using namespace ::com::sun::star;
88 :
89 : namespace framework
90 : {
91 :
92 : static const char ITEM_DESCRIPTOR_COMMANDURL[] = "CommandURL";
93 : static const char ITEM_DESCRIPTOR_HELPURL[] = "HelpURL";
94 : static const char ITEM_DESCRIPTOR_TOOLTIP[] = "Tooltip";
95 : static const char ITEM_DESCRIPTOR_CONTAINER[] = "ItemDescriptorContainer";
96 : static const char ITEM_DESCRIPTOR_LABEL[] = "Label";
97 : static const char ITEM_DESCRIPTOR_TYPE[] = "Type";
98 : static const char ITEM_DESCRIPTOR_VISIBLE[] = "IsVisible";
99 : static const char ITEM_DESCRIPTOR_WIDTH[] = "Width";
100 : static const char ITEM_DESCRIPTOR_STYLE[] = "Style";
101 :
102 : static const char MENUPREFIX[] = "private:resource/menubar/";
103 :
104 : static const char HELPID_PREFIX_TESTTOOL[] = ".HelpId:";
105 :
106 : static const sal_uInt16 STARTID_CUSTOMIZE_POPUPMENU = 1000;
107 :
108 : class ImageOrientationListener : public svt::FrameStatusListener
109 : {
110 : public:
111 : ImageOrientationListener( const Reference< XStatusListener >& rReceiver,
112 : const Reference< XComponentContext >& rxContext,
113 : const Reference< XFrame >& rFrame );
114 : virtual ~ImageOrientationListener();
115 :
116 : virtual void SAL_CALL statusChanged( const ::com::sun::star::frame::FeatureStateEvent& Event ) throw ( ::com::sun::star::uno::RuntimeException, std::exception ) SAL_OVERRIDE;
117 :
118 : private:
119 : Reference< XStatusListener > m_xReceiver;
120 : };
121 :
122 1236 : ImageOrientationListener::ImageOrientationListener(
123 : const Reference< XStatusListener >& rReceiver,
124 : const Reference< XComponentContext >& rxContext,
125 : const Reference< XFrame >& rFrame ) :
126 : FrameStatusListener( rxContext, rFrame ),
127 1236 : m_xReceiver( rReceiver )
128 : {
129 1236 : }
130 :
131 2472 : ImageOrientationListener::~ImageOrientationListener()
132 : {
133 2472 : }
134 :
135 1913 : void SAL_CALL ImageOrientationListener::statusChanged( const FeatureStateEvent& Event )
136 : throw ( RuntimeException, std::exception )
137 : {
138 1913 : if ( m_xReceiver.is() )
139 1913 : m_xReceiver->statusChanged( Event );
140 1913 : }
141 :
142 1236 : static sal_Int16 getImageTypeFromBools( bool bBig )
143 : {
144 1236 : sal_Int16 n( 0 );
145 1236 : if ( bBig )
146 1 : n |= ::com::sun::star::ui::ImageType::SIZE_LARGE;
147 1236 : return n;
148 : }
149 :
150 0 : static ::com::sun::star::uno::Reference< ::com::sun::star::frame::XLayoutManager > getLayoutManagerFromFrame(
151 : ::com::sun::star::uno::Reference< ::com::sun::star::frame::XFrame >& rFrame )
152 : {
153 0 : ::com::sun::star::uno::Reference< ::com::sun::star::frame::XLayoutManager > xLayoutManager;
154 :
155 0 : Reference< XPropertySet > xPropSet( rFrame, UNO_QUERY );
156 0 : if ( xPropSet.is() )
157 : {
158 : try
159 : {
160 0 : xPropSet->getPropertyValue("LayoutManager") >>= xLayoutManager;
161 : }
162 0 : catch (const RuntimeException&)
163 : {
164 0 : throw;
165 : }
166 0 : catch (const Exception&)
167 : {
168 : }
169 : }
170 :
171 0 : return xLayoutManager;
172 : }
173 :
174 : // XInterface, XTypeProvider, XServiceInfo
175 :
176 9522 : ToolBarManager::ToolBarManager( const Reference< XComponentContext >& rxContext,
177 : const Reference< XFrame >& rFrame,
178 : const OUString& rResourceName,
179 : ToolBox* pToolBar ) :
180 : m_bDisposed( false ),
181 19044 : m_bSmallSymbols( !SvtMiscOptions().AreCurrentSymbolsLarge() ),
182 : m_bModuleIdentified( false ),
183 : m_bAddedToTaskPaneList( true ),
184 : m_bFrameActionRegistered( false ),
185 : m_bUpdateControllers( false ),
186 : m_bImageOrientationRegistered( false ),
187 : m_bImageMirrored( false ),
188 : m_lImageRotation( 0 ),
189 : m_pToolBar( pToolBar ),
190 : m_aResourceName( rResourceName ),
191 : m_xFrame( rFrame ),
192 : m_aListenerContainer( m_mutex ),
193 : m_xContext( rxContext ),
194 : m_sIconTheme( SvtMiscOptions().GetIconTheme() ),
195 28566 : m_bAcceleratorCfg( false )
196 : {
197 : OSL_ASSERT( m_xContext.is() );
198 :
199 9522 : vcl::Window* pWindow = m_pToolBar;
200 28584 : while ( pWindow && !pWindow->IsSystemWindow() )
201 9540 : pWindow = pWindow->GetParent();
202 :
203 9522 : if ( pWindow )
204 9522 : static_cast<SystemWindow *>(pWindow)->GetTaskPaneList()->AddWindow( m_pToolBar );
205 :
206 9522 : m_xToolbarControllerFactory = frame::theToolbarControllerFactory::get( m_xContext );
207 9522 : m_xURLTransformer = URLTransformer::create( m_xContext );
208 :
209 9522 : m_pToolBar->SetSelectHdl( LINK( this, ToolBarManager, Select) );
210 9522 : m_pToolBar->SetClickHdl( LINK( this, ToolBarManager, Click ) );
211 9522 : m_pToolBar->SetDropdownClickHdl( LINK( this, ToolBarManager, DropdownClick ) );
212 9522 : m_pToolBar->SetDoubleClickHdl( LINK( this, ToolBarManager, DoubleClick ) );
213 9522 : m_pToolBar->SetStateChangedHdl( LINK( this, ToolBarManager, StateChanged ) );
214 9522 : m_pToolBar->SetDataChangedHdl( LINK( this, ToolBarManager, DataChanged ) );
215 9522 : m_pToolBar->SetToolboxButtonSize( m_bSmallSymbols ? TOOLBOX_BUTTONSIZE_SMALL : TOOLBOX_BUTTONSIZE_LARGE );
216 :
217 : // enables a menu for clipped items and customization
218 9522 : SvtCommandOptions aCmdOptions;
219 9522 : sal_uInt16 nMenuType = TOOLBOX_MENUTYPE_CLIPPEDITEMS;
220 9522 : if ( !aCmdOptions.Lookup( SvtCommandOptions::CMDOPTION_DISABLED, OUString("CreateDialog")))
221 9522 : nMenuType |= TOOLBOX_MENUTYPE_CUSTOMIZE;
222 :
223 9522 : m_pToolBar->SetCommandHdl( LINK( this, ToolBarManager, Command ) );
224 9522 : m_pToolBar->SetMenuType( nMenuType );
225 9522 : m_pToolBar->SetMenuButtonHdl( LINK( this, ToolBarManager, MenuButton ) );
226 :
227 : // set name for testtool, the useful part is after the last '/'
228 9522 : sal_Int32 idx = rResourceName.lastIndexOf('/');
229 9522 : idx++; // will become 0 if '/' not found: use full string
230 19044 : OString aHelpIdAsString( HELPID_PREFIX_TESTTOOL );
231 19044 : OUString aToolbarName = rResourceName.copy( idx );
232 9522 : aHelpIdAsString += OUStringToOString( aToolbarName, RTL_TEXTENCODING_UTF8 );;
233 9522 : m_pToolBar->SetHelpId( aHelpIdAsString );
234 :
235 9522 : m_aAsyncUpdateControllersTimer.SetTimeout( 50 );
236 9522 : m_aAsyncUpdateControllersTimer.SetTimeoutHdl( LINK( this, ToolBarManager, AsyncUpdateControllersHdl ) );
237 :
238 19044 : SvtMiscOptions().AddListenerLink( LINK( this, ToolBarManager, MiscOptionsChanged ) );
239 9522 : }
240 :
241 16263 : ToolBarManager::~ToolBarManager()
242 : {
243 : assert(!m_aAsyncUpdateControllersTimer.IsActive());
244 : OSL_ASSERT( !m_pToolBar );
245 : OSL_ASSERT( !m_bAddedToTaskPaneList );
246 16263 : }
247 :
248 9509 : void ToolBarManager::Destroy()
249 : {
250 : OSL_ASSERT( m_pToolBar != nullptr );
251 9509 : SolarMutexGuard g;
252 9509 : if ( m_bAddedToTaskPaneList )
253 : {
254 9509 : vcl::Window* pWindow = m_pToolBar;
255 35196 : while ( pWindow && !pWindow->IsSystemWindow() )
256 16178 : pWindow = pWindow->GetParent();
257 :
258 9509 : if ( pWindow )
259 9509 : static_cast<SystemWindow *>(pWindow)->GetTaskPaneList()->RemoveWindow( m_pToolBar );
260 9509 : m_bAddedToTaskPaneList = false;
261 : }
262 :
263 : // Delete the additional add-ons data
264 105546 : for ( sal_uInt16 i = 0; i < m_pToolBar->GetItemCount(); i++ )
265 : {
266 96037 : sal_uInt16 nItemId = m_pToolBar->GetItemId( i );
267 96037 : if ( nItemId > 0 )
268 80893 : delete static_cast< AddonsParams* >( m_pToolBar->GetItemData( nItemId ));
269 : }
270 :
271 : // Hide toolbar as lazy delete can destroy the toolbar much later.
272 9509 : m_pToolBar->Hide();
273 : /* #i99167# removed change for i93173 since there is some weird crash */
274 : // #i93173# delete toolbar lazily as we can still be in one of its handlers
275 9509 : m_pToolBar->doLazyDelete();
276 :
277 9509 : m_pToolBar->SetSelectHdl( Link<ToolBox *, void>() );
278 9509 : m_pToolBar->SetActivateHdl( Link<ToolBox *, void>() );
279 9509 : m_pToolBar->SetDeactivateHdl( Link<ToolBox *, void>() );
280 9509 : m_pToolBar->SetClickHdl( Link<ToolBox *, void>() );
281 9509 : m_pToolBar->SetDropdownClickHdl( Link<ToolBox *, void>() );
282 9509 : m_pToolBar->SetDoubleClickHdl( Link<ToolBox *, void>() );
283 9509 : m_pToolBar->SetStateChangedHdl( Link<StateChangedType const *, void>() );
284 9509 : m_pToolBar->SetDataChangedHdl( Link<DataChangedEvent const *, void>() );
285 9509 : m_pToolBar->SetCommandHdl( Link<CommandEvent const *, void>() );
286 :
287 9509 : m_pToolBar.clear();
288 :
289 9509 : SvtMiscOptions().RemoveListenerLink( LINK( this, ToolBarManager, MiscOptionsChanged ) );
290 9509 : }
291 :
292 59091 : ToolBox* ToolBarManager::GetToolBar() const
293 : {
294 59091 : SolarMutexGuard g;
295 59091 : return m_pToolBar;
296 : }
297 :
298 0 : void ToolBarManager::CheckAndUpdateImages()
299 : {
300 0 : SolarMutexGuard g;
301 0 : bool bRefreshImages = false;
302 :
303 0 : SvtMiscOptions aMiscOptions;
304 0 : bool bCurrentSymbolsSmall = !aMiscOptions.AreCurrentSymbolsLarge();
305 0 : if ( m_bSmallSymbols != bCurrentSymbolsSmall )
306 : {
307 0 : bRefreshImages = true;
308 0 : m_bSmallSymbols = bCurrentSymbolsSmall;
309 : }
310 :
311 0 : const OUString& sCurrentIconTheme = aMiscOptions.GetIconTheme();
312 0 : if ( m_sIconTheme != sCurrentIconTheme )
313 : {
314 0 : bRefreshImages = true;
315 0 : m_sIconTheme = sCurrentIconTheme;
316 : }
317 :
318 : // Refresh images if requested
319 0 : if ( bRefreshImages )
320 0 : RefreshImages();
321 0 : }
322 :
323 0 : void ToolBarManager::RefreshImages()
324 : {
325 0 : SolarMutexGuard g;
326 :
327 0 : bool bBigImages( SvtMiscOptions().AreCurrentSymbolsLarge() );
328 0 : for ( sal_uInt16 nPos = 0; nPos < m_pToolBar->GetItemCount(); nPos++ )
329 : {
330 0 : sal_uInt16 nId( m_pToolBar->GetItemId( nPos ) );
331 :
332 0 : if ( nId > 0 )
333 : {
334 0 : OUString aCommandURL = m_pToolBar->GetItemCommand( nId );
335 0 : Image aImage = GetImageFromURL( m_xFrame, aCommandURL, bBigImages );
336 : // Try also to query for add-on images before giving up and use an
337 : // empty image.
338 0 : if ( !aImage )
339 0 : aImage = QueryAddonsImage( aCommandURL, bBigImages );
340 0 : m_pToolBar->SetItemImage( nId, aImage );
341 : }
342 : }
343 :
344 0 : m_pToolBar->SetToolboxButtonSize( bBigImages ? TOOLBOX_BUTTONSIZE_LARGE : TOOLBOX_BUTTONSIZE_SMALL );
345 0 : ::Size aSize = m_pToolBar->CalcWindowSizePixel();
346 0 : m_pToolBar->SetOutputSizePixel( aSize );
347 0 : }
348 :
349 1913 : void ToolBarManager::UpdateImageOrientation()
350 : {
351 1913 : SolarMutexGuard g;
352 :
353 1913 : if ( m_xUICommandLabels.is() )
354 : {
355 : sal_Int32 i;
356 1913 : Sequence< OUString > aSeqMirrorCmd;
357 3826 : Sequence< OUString > aSeqRotateCmd;
358 1913 : m_xUICommandLabels->getByName(
359 1913 : OUString( UICOMMANDDESCRIPTION_NAMEACCESS_COMMANDMIRRORIMAGELIST )) >>= aSeqMirrorCmd;
360 1913 : m_xUICommandLabels->getByName(
361 1913 : OUString( UICOMMANDDESCRIPTION_NAMEACCESS_COMMANDROTATEIMAGELIST )) >>= aSeqRotateCmd;
362 :
363 1913 : CommandToInfoMap::iterator pIter;
364 53564 : for ( i = 0; i < aSeqMirrorCmd.getLength(); i++ )
365 : {
366 51651 : OUString aMirrorCmd = aSeqMirrorCmd[i];
367 51651 : pIter = m_aCommandMap.find( aMirrorCmd );
368 51651 : if ( pIter != m_aCommandMap.end() )
369 5718 : pIter->second.bMirrored = true;
370 51651 : }
371 63129 : for ( i = 0; i < aSeqRotateCmd.getLength(); i++ )
372 : {
373 61216 : OUString aRotateCmd = aSeqRotateCmd[i];
374 61216 : pIter = m_aCommandMap.find( aRotateCmd );
375 61216 : if ( pIter != m_aCommandMap.end() )
376 10473 : pIter->second.bRotated = true;
377 63129 : }
378 : }
379 :
380 112763 : for ( sal_uInt16 nPos = 0; nPos < m_pToolBar->GetItemCount(); nPos++ )
381 : {
382 110850 : sal_uInt16 nId = m_pToolBar->GetItemId( nPos );
383 110850 : if ( nId > 0 )
384 : {
385 85064 : OUString aCmd = m_pToolBar->GetItemCommand( nId );
386 :
387 85064 : CommandToInfoMap::const_iterator pIter = m_aCommandMap.find( aCmd );
388 85064 : if ( pIter != m_aCommandMap.end() )
389 : {
390 85064 : if ( pIter->second.bRotated )
391 : {
392 10473 : m_pToolBar->SetItemImageMirrorMode( nId, false );
393 10473 : m_pToolBar->SetItemImageAngle( nId, m_lImageRotation );
394 : }
395 85064 : if ( pIter->second.bMirrored )
396 : {
397 5718 : m_pToolBar->SetItemImageMirrorMode( nId, m_bImageMirrored );
398 : }
399 85064 : }
400 : }
401 1913 : }
402 1913 : }
403 :
404 1344 : void ToolBarManager::UpdateControllers()
405 : {
406 :
407 1344 : if( SvtMiscOptions().DisableUICustomization() )
408 : {
409 0 : Any a;
410 0 : Reference< XLayoutManager > xLayoutManager;
411 0 : Reference< XPropertySet > xFramePropSet( m_xFrame, UNO_QUERY );
412 0 : if ( xFramePropSet.is() )
413 0 : a = xFramePropSet->getPropertyValue("LayoutManager");
414 0 : a >>= xLayoutManager;
415 0 : Reference< XDockableWindow > xDockable( VCLUnoHelper::GetInterface( m_pToolBar ), UNO_QUERY );
416 0 : if ( xLayoutManager.is() && xDockable.is() )
417 : {
418 0 : ::com::sun::star::awt::Point aPoint;
419 0 : aPoint.X = aPoint.Y = SAL_MAX_INT32;
420 0 : xLayoutManager->dockWindow( m_aResourceName, DockingArea_DOCKINGAREA_DEFAULT, aPoint );
421 0 : xLayoutManager->lockWindow( m_aResourceName );
422 0 : }
423 : }
424 :
425 1344 : if ( !m_bUpdateControllers )
426 : {
427 1344 : m_bUpdateControllers = true;
428 1344 : ToolBarControllerMap::iterator pIter = m_aControllerMap.begin();
429 :
430 55150 : while ( pIter != m_aControllerMap.end() )
431 : {
432 : try
433 : {
434 52462 : Reference< XUpdatable > xUpdatable( pIter->second, UNO_QUERY );
435 52462 : if ( xUpdatable.is() )
436 51882 : xUpdatable->update();
437 : }
438 0 : catch (const Exception&)
439 : {
440 : }
441 52462 : ++pIter;
442 : }
443 : }
444 1344 : m_bUpdateControllers = false;
445 1344 : }
446 :
447 : //for update toolbar controller via Support Visible
448 994 : void ToolBarManager::UpdateController( ::com::sun::star::uno::Reference< ::com::sun::star::frame::XToolbarController > xController)
449 : {
450 :
451 994 : if ( !m_bUpdateControllers )
452 : {
453 994 : m_bUpdateControllers = true;
454 : try
455 994 : { if(xController.is())
456 : {
457 994 : Reference< XUpdatable > xUpdatable( xController, UNO_QUERY );
458 994 : if ( xUpdatable.is() )
459 994 : xUpdatable->update();
460 : }
461 : }
462 0 : catch (const Exception&)
463 : {
464 : }
465 :
466 : }
467 994 : m_bUpdateControllers = false;
468 994 : }
469 :
470 6892 : void ToolBarManager::frameAction( const FrameActionEvent& Action )
471 : throw ( RuntimeException, std::exception )
472 : {
473 6892 : SolarMutexGuard g;
474 6892 : if ( Action.Action == FrameAction_CONTEXT_CHANGED )
475 : {
476 0 : m_aAsyncUpdateControllersTimer.Start();
477 6892 : }
478 6892 : }
479 :
480 1913 : void SAL_CALL ToolBarManager::statusChanged( const ::com::sun::star::frame::FeatureStateEvent& Event )
481 : throw ( ::com::sun::star::uno::RuntimeException, std::exception )
482 : {
483 1913 : SolarMutexGuard g;
484 1913 : if ( m_bDisposed )
485 1913 : return;
486 :
487 1913 : if ( Event.FeatureURL.Complete == ".uno:ImageOrientation" )
488 : {
489 1913 : SfxImageItem aItem( 1, 0 );
490 1913 : aItem.PutValue( Event.State );
491 :
492 1913 : m_lImageRotation = aItem.GetRotation();
493 1913 : m_bImageMirrored = aItem.IsMirrored();
494 1913 : UpdateImageOrientation();
495 1913 : }
496 : }
497 :
498 0 : void SAL_CALL ToolBarManager::disposing( const EventObject& Source ) throw ( RuntimeException, std::exception )
499 : {
500 : {
501 0 : SolarMutexGuard g;
502 0 : if ( m_bDisposed )
503 0 : return;
504 : }
505 :
506 0 : RemoveControllers();
507 :
508 : {
509 0 : SolarMutexGuard g;
510 0 : if ( m_xDocImageManager.is() )
511 : {
512 : try
513 : {
514 0 : m_xDocImageManager->removeConfigurationListener(
515 : Reference< XUIConfigurationListener >(
516 0 : static_cast< OWeakObject* >( this ), UNO_QUERY ));
517 : }
518 0 : catch (const Exception&)
519 : {
520 : }
521 : }
522 :
523 0 : if ( m_xModuleImageManager.is() )
524 : {
525 : try
526 : {
527 0 : m_xModuleImageManager->removeConfigurationListener(
528 : Reference< XUIConfigurationListener >(
529 0 : static_cast< OWeakObject* >( this ), UNO_QUERY ));
530 : }
531 0 : catch (const Exception&)
532 : {
533 : }
534 : }
535 :
536 0 : if ( m_xImageOrientationListener.is() )
537 : {
538 : ImageOrientationListener* pImageOrientation =
539 0 : static_cast<ImageOrientationListener*>(m_xImageOrientationListener.get());
540 0 : pImageOrientation->unbindListener();
541 0 : m_xImageOrientationListener.clear();
542 : }
543 :
544 0 : m_xDocImageManager.clear();
545 0 : m_xModuleImageManager.clear();
546 :
547 0 : if ( Source.Source == Reference< XInterface >( m_xFrame, UNO_QUERY ))
548 0 : m_xFrame.clear();
549 :
550 0 : m_xContext.clear();
551 : }
552 : }
553 :
554 : // XComponent
555 9509 : void SAL_CALL ToolBarManager::dispose() throw( RuntimeException, std::exception )
556 : {
557 9509 : Reference< XComponent > xThis( static_cast< OWeakObject* >(this), UNO_QUERY );
558 :
559 19018 : EventObject aEvent( xThis );
560 9509 : m_aListenerContainer.disposeAndClear( aEvent );
561 :
562 : {
563 9509 : SolarMutexGuard g;
564 :
565 9509 : RemoveControllers();
566 :
567 9509 : if ( m_xDocImageManager.is() )
568 : {
569 : try
570 : {
571 1184 : m_xDocImageManager->removeConfigurationListener(
572 : Reference< XUIConfigurationListener >(
573 1184 : static_cast< OWeakObject* >( this ), UNO_QUERY ));
574 : }
575 0 : catch (const Exception&)
576 : {
577 : }
578 : }
579 9509 : m_xDocImageManager.clear();
580 9509 : if ( m_xModuleImageManager.is() )
581 : {
582 : try
583 : {
584 1236 : m_xModuleImageManager->removeConfigurationListener(
585 : Reference< XUIConfigurationListener >(
586 1236 : static_cast< OWeakObject* >( this ), UNO_QUERY ));
587 : }
588 0 : catch (const Exception&)
589 : {
590 : }
591 : }
592 9509 : m_xModuleImageManager.clear();
593 :
594 9509 : ImplClearPopupMenu( m_pToolBar );
595 :
596 : // We have to destroy our toolbar instance now.
597 9509 : Destroy();
598 9509 : m_pToolBar.clear();
599 :
600 9509 : if ( m_bFrameActionRegistered && m_xFrame.is() )
601 : {
602 : try
603 : {
604 3991 : m_xFrame->removeFrameActionListener( Reference< XFrameActionListener >(
605 3991 : static_cast< ::cppu::OWeakObject *>( this ), UNO_QUERY ));
606 : }
607 0 : catch (const Exception&)
608 : {
609 : }
610 : }
611 :
612 9509 : if ( m_xImageOrientationListener.is() )
613 : {
614 : ImageOrientationListener* pImageOrientation =
615 1236 : static_cast<ImageOrientationListener*>(m_xImageOrientationListener.get());
616 1236 : pImageOrientation->unbindListener();
617 1236 : m_xImageOrientationListener.clear();
618 : }
619 :
620 9509 : m_xFrame.clear();
621 9509 : m_xContext.clear();
622 19018 : Reference< XComponent > xCompGAM( m_xGlobalAcceleratorManager, UNO_QUERY );
623 9509 : if ( xCompGAM.is() )
624 1236 : xCompGAM->dispose();
625 9509 : m_xGlobalAcceleratorManager.clear();
626 9509 : m_xModuleAcceleratorManager.clear();
627 9509 : m_xDocAcceleratorManager.clear();
628 :
629 : // stop timer to prevent timer events after dispose
630 : // do it last because other calls could restart timer in StateChanged()
631 9509 : m_aAsyncUpdateControllersTimer.Stop();
632 :
633 19018 : m_bDisposed = true;
634 9509 : }
635 9509 : }
636 :
637 0 : void SAL_CALL ToolBarManager::addEventListener( const Reference< XEventListener >& xListener ) throw( RuntimeException, std::exception )
638 : {
639 0 : SolarMutexGuard g;
640 :
641 : /* SAFE AREA ----------------------------------------------------------------------------------------------- */
642 0 : if ( m_bDisposed )
643 0 : throw DisposedException();
644 :
645 0 : m_aListenerContainer.addInterface( cppu::UnoType<XEventListener>::get(), xListener );
646 0 : }
647 :
648 0 : void SAL_CALL ToolBarManager::removeEventListener( const Reference< XEventListener >& xListener ) throw( RuntimeException, std::exception )
649 : {
650 0 : m_aListenerContainer.removeInterface( cppu::UnoType<XEventListener>::get(), xListener );
651 0 : }
652 :
653 : // XUIConfigurationListener
654 0 : void SAL_CALL ToolBarManager::elementInserted( const ::com::sun::star::ui::ConfigurationEvent& Event ) throw (::com::sun::star::uno::RuntimeException, std::exception)
655 : {
656 0 : impl_elementChanged(false,Event);
657 0 : }
658 :
659 0 : void SAL_CALL ToolBarManager::elementRemoved( const ::com::sun::star::ui::ConfigurationEvent& Event ) throw (::com::sun::star::uno::RuntimeException, std::exception)
660 : {
661 0 : impl_elementChanged(true,Event);
662 0 : }
663 0 : void ToolBarManager::impl_elementChanged(bool _bRemove,const ::com::sun::star::ui::ConfigurationEvent& Event )
664 : {
665 0 : SolarMutexGuard g;
666 :
667 : /* SAFE AREA ----------------------------------------------------------------------------------------------- */
668 0 : if ( m_bDisposed )
669 0 : return;
670 :
671 0 : Reference< XNameAccess > xNameAccess;
672 0 : sal_Int16 nImageType = sal_Int16();
673 : sal_Int16 nCurrentImageType = getImageTypeFromBools(
674 0 : SvtMiscOptions().AreCurrentSymbolsLarge()
675 0 : );
676 :
677 0 : if (( Event.aInfo >>= nImageType ) &&
678 0 : ( nImageType == nCurrentImageType ) &&
679 0 : ( Event.Element >>= xNameAccess ))
680 : {
681 0 : sal_Int16 nImageInfo( 1 );
682 0 : Reference< XInterface > xIfacDocImgMgr( m_xDocImageManager, UNO_QUERY );
683 0 : if ( xIfacDocImgMgr == Event.Source )
684 0 : nImageInfo = 0;
685 :
686 0 : Sequence< OUString > aSeq = xNameAccess->getElementNames();
687 0 : for ( sal_Int32 i = 0; i < aSeq.getLength(); i++ )
688 : {
689 0 : CommandToInfoMap::iterator pIter = m_aCommandMap.find( aSeq[i] );
690 0 : if ( pIter != m_aCommandMap.end() && ( pIter->second.nImageInfo >= nImageInfo ))
691 : {
692 0 : if ( _bRemove )
693 : {
694 0 : Image aImage;
695 0 : if (( pIter->second.nImageInfo == 0 ) && ( pIter->second.nImageInfo == nImageInfo ))
696 : {
697 : // Special case: An image from the document image manager has been removed.
698 : // It is possible that we have a image at our module image manager. Before
699 : // we can remove our image we have to ask our module image manager.
700 0 : Sequence< OUString > aCmdURLSeq( 1 );
701 0 : Sequence< Reference< XGraphic > > aGraphicSeq;
702 0 : aCmdURLSeq[0] = pIter->first;
703 0 : aGraphicSeq = m_xModuleImageManager->getImages( nImageType, aCmdURLSeq );
704 0 : aImage = Image( aGraphicSeq[0] );
705 : }
706 :
707 0 : setToolBarImage(aImage,pIter);
708 : } // if ( _bRemove )
709 : else
710 : {
711 0 : Reference< XGraphic > xGraphic;
712 0 : if ( xNameAccess->getByName( aSeq[i] ) >>= xGraphic )
713 : {
714 0 : Image aImage( xGraphic );
715 0 : setToolBarImage(aImage,pIter);
716 : }
717 0 : pIter->second.nImageInfo = nImageInfo;
718 : }
719 : }
720 0 : }
721 0 : }
722 : }
723 53343 : void ToolBarManager::setToolBarImage(const Image& _aImage,const CommandToInfoMap::const_iterator& _pIter)
724 : {
725 53343 : const ::std::vector< sal_uInt16 >& _rIDs = _pIter->second.aIds;
726 53343 : m_pToolBar->SetItemImage( _pIter->second.nId, _aImage );
727 53343 : ::std::for_each(_rIDs.begin(),_rIDs.end(),::boost::bind(&ToolBox::SetItemImage,m_pToolBar.get(),_1,_aImage));
728 53343 : }
729 :
730 0 : void SAL_CALL ToolBarManager::elementReplaced( const ::com::sun::star::ui::ConfigurationEvent& Event ) throw (::com::sun::star::uno::RuntimeException, std::exception)
731 : {
732 0 : impl_elementChanged(false,Event);
733 0 : }
734 :
735 13503 : void ToolBarManager::RemoveControllers()
736 : {
737 13503 : SolarMutexGuard g;
738 :
739 13503 : if ( m_bDisposed )
740 13503 : return;
741 :
742 13503 : m_aSubToolBarControllerMap.clear();
743 :
744 : // i90033
745 : // Remove item window pointers from the toolbar. They were
746 : // destroyed by the dispose() at the XComponent. This is needed
747 : // as VCL code later tries to access the item window data in certain
748 : // dtors where the item window is already invalid!
749 109540 : for ( sal_uInt16 i = 0; i < m_pToolBar->GetItemCount(); i++ )
750 : {
751 96037 : sal_uInt16 nItemId = m_pToolBar->GetItemId( i );
752 96037 : if ( nItemId > 0 )
753 : {
754 80893 : Reference< XComponent > xComponent( m_aControllerMap[ nItemId ], UNO_QUERY );
755 80893 : if ( xComponent.is() )
756 : {
757 : try
758 : {
759 80304 : xComponent->dispose();
760 : }
761 0 : catch (const Exception&)
762 : {
763 : }
764 : }
765 80893 : m_pToolBar->SetItemWindow(nItemId, 0);
766 : }
767 : }
768 13503 : m_aControllerMap.clear();
769 : }
770 :
771 93436 : uno::Sequence< beans::PropertyValue > ToolBarManager::GetPropsForCommand( const OUString& rCmdURL )
772 : {
773 93436 : Sequence< PropertyValue > aPropSeq;
774 :
775 : // Retrieve properties for command
776 : try
777 : {
778 93436 : if ( !m_bModuleIdentified )
779 : {
780 1236 : Reference< XModuleManager2 > xModuleManager = ModuleManager::create( m_xContext );
781 2472 : Reference< XInterface > xIfac( m_xFrame, UNO_QUERY );
782 :
783 1236 : m_bModuleIdentified = true;
784 1236 : m_aModuleIdentifier = xModuleManager->identify( xIfac );
785 :
786 1236 : if ( !m_aModuleIdentifier.isEmpty() )
787 : {
788 1236 : Reference< XNameAccess > xNameAccess = frame::theUICommandDescription::get( m_xContext );
789 1236 : xNameAccess->getByName( m_aModuleIdentifier ) >>= m_xUICommandLabels;
790 1236 : }
791 : }
792 :
793 93436 : if ( m_xUICommandLabels.is() )
794 : {
795 93436 : if ( !rCmdURL.isEmpty() )
796 93436 : m_xUICommandLabels->getByName( rCmdURL ) >>= aPropSeq;
797 : }
798 : }
799 0 : catch (const Exception&)
800 : {
801 : }
802 :
803 93436 : return aPropSeq;
804 : }
805 :
806 53343 : OUString ToolBarManager::RetrieveLabelFromCommand( const OUString& aCmdURL )
807 : {
808 53343 : OUString aLabel;
809 106686 : Sequence< PropertyValue > aPropSeq;
810 :
811 : // Retrieve popup menu labels
812 53343 : aPropSeq = GetPropsForCommand( aCmdURL );
813 106686 : for ( sal_Int32 i = 0; i < aPropSeq.getLength(); i++ )
814 : {
815 106686 : if ( aPropSeq[i].Name == "Name" )
816 : {
817 53343 : aPropSeq[i].Value >>= aLabel;
818 53343 : break;
819 : }
820 : }
821 106686 : return aLabel;
822 : }
823 :
824 40093 : sal_Int32 ToolBarManager::RetrievePropertiesFromCommand( const OUString& aCmdURL )
825 : {
826 40093 : sal_Int32 nProperties(0);
827 40093 : Sequence< PropertyValue > aPropSeq;
828 :
829 : // Retrieve popup menu labels
830 40093 : aPropSeq = GetPropsForCommand( aCmdURL );
831 160372 : for ( sal_Int32 i = 0; i < aPropSeq.getLength(); i++ )
832 : {
833 160372 : if ( aPropSeq[i].Name == "Properties" )
834 : {
835 40093 : aPropSeq[i].Value >>= nProperties;
836 40093 : break;
837 : }
838 : }
839 40093 : return nProperties;
840 : }
841 :
842 1236 : void ToolBarManager::CreateControllers()
843 : {
844 :
845 1236 : Reference< XWindow > xToolbarWindow = VCLUnoHelper::GetInterface( m_pToolBar );
846 :
847 2472 : css::util::URL aURL;
848 1236 : bool bHasDisabledEntries = SvtCommandOptions().HasEntries( SvtCommandOptions::CMDOPTION_DISABLED );
849 2472 : SvtCommandOptions aCmdOptions;
850 :
851 69723 : for ( sal_uInt16 i = 0; i < m_pToolBar->GetItemCount(); i++ )
852 : {
853 68487 : sal_uInt16 nId = m_pToolBar->GetItemId( i );
854 68487 : if ( nId == 0 )
855 30288 : continue;
856 :
857 53343 : OUString aLoadURL( ".uno:OpenUrl" );
858 106686 : OUString aCommandURL( m_pToolBar->GetItemCommand( nId ));
859 53343 : bool bInit( true );
860 53343 : bool bCreate( true );
861 106686 : Reference< XStatusListener > xController;
862 53343 : CommandToInfoMap::iterator pCommandIter = m_aCommandMap.find( aCommandURL );
863 53343 : sal_Int16 nWidth = ( pCommandIter != m_aCommandMap.end() ? pCommandIter->second.nWidth : 0 );
864 :
865 53343 : svt::ToolboxController* pController( 0 );
866 :
867 53343 : if ( bHasDisabledEntries )
868 : {
869 0 : aURL.Complete = aCommandURL;
870 0 : m_xURLTransformer->parseStrict( aURL );
871 0 : if ( aCmdOptions.Lookup( SvtCommandOptions::CMDOPTION_DISABLED, aURL.Path ))
872 : {
873 0 : m_aControllerMap[ nId ] = xController;
874 0 : m_pToolBar->HideItem( nId );
875 0 : continue;
876 : }
877 : }
878 :
879 106686 : if ( m_xToolbarControllerFactory.is() &&
880 53343 : m_xToolbarControllerFactory->hasController( aCommandURL, m_aModuleIdentifier ))
881 : {
882 2031 : PropertyValue aPropValue;
883 4062 : std::vector< Any > aPropertyVector;
884 :
885 2031 : aPropValue.Name = "ModuleIdentifier";
886 2031 : aPropValue.Value <<= m_aModuleIdentifier;
887 2031 : aPropertyVector.push_back( makeAny( aPropValue ));
888 2031 : aPropValue.Name = "Frame";
889 2031 : aPropValue.Value <<= m_xFrame;
890 2031 : aPropertyVector.push_back( makeAny( aPropValue ));
891 2031 : aPropValue.Name = "ServiceManager";
892 4062 : Reference<XMultiServiceFactory> xMSF(m_xContext->getServiceManager(), UNO_QUERY_THROW);
893 2031 : aPropValue.Value <<= xMSF;
894 2031 : aPropertyVector.push_back( makeAny( aPropValue ));
895 2031 : aPropValue.Name = "ParentWindow";
896 2031 : aPropValue.Value <<= xToolbarWindow;
897 2031 : aPropertyVector.push_back( makeAny( aPropValue ));
898 2031 : aPropValue.Name = "Identifier";
899 2031 : aPropValue.Value = uno::makeAny( nId );
900 2031 : aPropertyVector.push_back( uno::makeAny( aPropValue ) );
901 :
902 2031 : if ( nWidth > 0 )
903 : {
904 0 : aPropValue.Name = "Width";
905 0 : aPropValue.Value <<= nWidth;
906 0 : aPropertyVector.push_back( makeAny( aPropValue ));
907 : }
908 :
909 4062 : Sequence< Any > aArgs( comphelper::containerToSequence( aPropertyVector ));
910 6093 : xController = Reference< XStatusListener >( m_xToolbarControllerFactory->createInstanceWithArgumentsAndContext(
911 2031 : aCommandURL, aArgs, m_xContext ),
912 2031 : UNO_QUERY );
913 4062 : bInit = false; // Initialization is done through the factory service
914 : }
915 :
916 53343 : if (( aCommandURL == aLoadURL ) && ( !m_pToolBar->IsItemVisible(nId)))
917 589 : bCreate = false;
918 :
919 53343 : if ( !xController.is() && bCreate )
920 : {
921 50723 : pController = CreateToolBoxController( m_xFrame, m_pToolBar, nId, aCommandURL );
922 50723 : if ( !pController )
923 : {
924 40093 : if ( m_pToolBar->GetItemData( nId ) != 0 )
925 : {
926 : // retrieve additional parameters
927 0 : OUString aControlType = static_cast< AddonsParams* >( m_pToolBar->GetItemData( nId ))->aControlType;
928 :
929 : Reference< XStatusListener > xStatusListener(
930 : ToolBarMerger::CreateController( m_xContext,
931 : m_xFrame,
932 : m_pToolBar,
933 : aCommandURL,
934 : nId,
935 : nWidth,
936 0 : aControlType ), UNO_QUERY );
937 :
938 0 : xController = xStatusListener;
939 : }
940 : else
941 : {
942 40093 : MenuDescriptionMap::iterator it = m_aMenuMap.find( nId );
943 40093 : if ( it == m_aMenuMap.end() )
944 : {
945 80186 : xController = Reference< XStatusListener >(
946 80186 : new GenericToolbarController( m_xContext, m_xFrame, m_pToolBar, nId, aCommandURL ));
947 :
948 : // Accessibility support: Set toggle button role for specific commands
949 40093 : sal_Int32 nProps = RetrievePropertiesFromCommand( aCommandURL );
950 40093 : if ( nProps & UICOMMANDDESCRIPTION_PROPERTIES_TOGGLEBUTTON )
951 10643 : m_pToolBar->SetItemBits( nId, m_pToolBar->GetItemBits( nId ) | ToolBoxItemBits::CHECKABLE );
952 : }
953 : else
954 0 : xController = Reference< XStatusListener >(
955 0 : new MenuToolbarController( m_xContext, m_xFrame, m_pToolBar, nId, aCommandURL, m_aModuleIdentifier, m_aMenuMap[ nId ] ));
956 : }
957 : }
958 10630 : else if ( pController )
959 : {
960 10630 : xController = Reference< XStatusListener >( static_cast< ::cppu::OWeakObject *>( pController ), UNO_QUERY );
961 : }
962 : }
963 :
964 : // Associate ID and controller to be able to retrieve
965 : // the controller from the ID later.
966 53343 : m_aControllerMap[ nId ] = xController;
967 :
968 : // Fill sub-toolbars into our hash-map
969 106686 : Reference< XSubToolbarController > xSubToolBar( xController, UNO_QUERY );
970 53343 : if ( xSubToolBar.is() && xSubToolBar->opensSubToolbar() )
971 : {
972 974 : OUString aSubToolBarName = xSubToolBar->getSubToolbarName();
973 974 : if ( !aSubToolBarName.isEmpty() )
974 : {
975 : SubToolBarToSubToolBarControllerMap::iterator pIter =
976 974 : m_aSubToolBarControllerMap.find( aSubToolBarName );
977 974 : if ( pIter == m_aSubToolBarControllerMap.end() )
978 : {
979 974 : SubToolBarControllerVector aSubToolBarVector;
980 974 : aSubToolBarVector.push_back( xSubToolBar );
981 : m_aSubToolBarControllerMap.insert(
982 : SubToolBarToSubToolBarControllerMap::value_type(
983 974 : aSubToolBarName, aSubToolBarVector ));
984 : }
985 : else
986 0 : pIter->second.push_back( xSubToolBar );
987 974 : }
988 : }
989 :
990 106686 : Reference< XInitialization > xInit( xController, UNO_QUERY );
991 53343 : if ( xInit.is() )
992 : {
993 52754 : if ( bInit )
994 : {
995 50723 : PropertyValue aPropValue;
996 101446 : std::vector< Any > aPropertyVector;
997 :
998 50723 : aPropValue.Name = "Frame";
999 50723 : aPropValue.Value <<= m_xFrame;
1000 50723 : aPropertyVector.push_back( makeAny( aPropValue ));
1001 50723 : aPropValue.Name = "CommandURL";
1002 50723 : aPropValue.Value <<= aCommandURL;
1003 50723 : aPropertyVector.push_back( makeAny( aPropValue ));
1004 50723 : aPropValue.Name = "ServiceManager";
1005 101446 : Reference<XMultiServiceFactory> xMSF(m_xContext->getServiceManager(), UNO_QUERY_THROW);
1006 50723 : aPropValue.Value <<= xMSF;
1007 50723 : aPropertyVector.push_back( makeAny( aPropValue ));
1008 50723 : aPropValue.Name = "ParentWindow";
1009 50723 : aPropValue.Value <<= xToolbarWindow;
1010 50723 : aPropertyVector.push_back( makeAny( aPropValue ));
1011 50723 : aPropValue.Name = "ModuleIdentifier";
1012 50723 : aPropValue.Value <<= m_aModuleIdentifier;
1013 50723 : aPropertyVector.push_back( makeAny( aPropValue ));
1014 50723 : aPropValue.Name = "Identifier";
1015 50723 : aPropValue.Value = uno::makeAny( nId );
1016 50723 : aPropertyVector.push_back( uno::makeAny( aPropValue ) );
1017 :
1018 50723 : if ( nWidth > 0 )
1019 : {
1020 0 : aPropValue.Name = "Width";
1021 0 : aPropValue.Value <<= nWidth;
1022 0 : aPropertyVector.push_back( makeAny( aPropValue ));
1023 : }
1024 :
1025 101446 : Sequence< Any > aArgs( comphelper::containerToSequence( aPropertyVector ));
1026 50723 : xInit->initialize( aArgs );
1027 :
1028 50723 : if (pController)
1029 : {
1030 31890 : if(aCommandURL == ".uno:SwitchXFormsDesignMode" ||
1031 21260 : aCommandURL == ".uno:ViewDataSourceBrowser" ||
1032 31393 : aCommandURL == ".uno:ParaLeftToRight" ||
1033 10133 : aCommandURL == ".uno:ParaRightToLeft"
1034 : )
1035 994 : pController->setFastPropertyValue_NoBroadcast(1,makeAny(sal_True));
1036 50723 : }
1037 : }
1038 :
1039 : // Request a item window from the toolbar controller and set it at the VCL toolbar
1040 52754 : Reference< XToolbarController > xTbxController( xController, UNO_QUERY );
1041 52754 : if ( xTbxController.is() && xToolbarWindow.is() )
1042 : {
1043 52754 : Reference< XWindow > xWindow = xTbxController->createItemWindow( xToolbarWindow );
1044 52754 : if ( xWindow.is() )
1045 : {
1046 1566 : vcl::Window* pItemWin = VCLUnoHelper::GetWindow( xWindow );
1047 1566 : if ( pItemWin )
1048 : {
1049 1566 : WindowType nType = pItemWin->GetType();
1050 1566 : if ( nType == WINDOW_LISTBOX || nType == WINDOW_MULTILISTBOX || nType == WINDOW_COMBOBOX )
1051 1508 : pItemWin->SetAccessibleName( m_pToolBar->GetItemText( nId ) );
1052 1566 : m_pToolBar->SetItemWindow( nId, pItemWin );
1053 : }
1054 52754 : }
1055 52754 : }
1056 : }
1057 :
1058 : //for update Controller via support visiable state
1059 106686 : Reference< XPropertySet > xPropSet( xController, UNO_QUERY );
1060 53343 : if ( xPropSet.is() )
1061 : {
1062 : try
1063 : {
1064 52754 : bool bSupportVisible = true;
1065 52754 : Any a( xPropSet->getPropertyValue("SupportsVisible") );
1066 52754 : a >>= bSupportVisible;
1067 52754 : if (bSupportVisible)
1068 : {
1069 994 : Reference< XToolbarController > xTbxController( xController, UNO_QUERY );
1070 994 : UpdateController(xTbxController);
1071 52754 : }
1072 : }
1073 0 : catch (const RuntimeException&)
1074 : {
1075 0 : throw;
1076 : }
1077 0 : catch (const Exception&)
1078 : {
1079 : }
1080 : }
1081 53343 : }
1082 :
1083 1236 : AddFrameActionListener();
1084 2472 : AddImageOrientationListener();
1085 1236 : }
1086 :
1087 3994 : void ToolBarManager::AddFrameActionListener()
1088 : {
1089 3994 : if ( !m_bFrameActionRegistered && m_xFrame.is() )
1090 : {
1091 3994 : m_bFrameActionRegistered = true;
1092 3994 : m_xFrame->addFrameActionListener( Reference< XFrameActionListener >(
1093 3994 : static_cast< ::cppu::OWeakObject *>( this ), UNO_QUERY ));
1094 : }
1095 3994 : }
1096 :
1097 1236 : void ToolBarManager::AddImageOrientationListener()
1098 : {
1099 1236 : if ( !m_bImageOrientationRegistered && m_xFrame.is() )
1100 : {
1101 1236 : m_bImageOrientationRegistered = true;
1102 : ImageOrientationListener* pImageOrientation = new ImageOrientationListener(
1103 : Reference< XStatusListener >( static_cast< ::cppu::OWeakObject *>( this ), UNO_QUERY ),
1104 : m_xContext,
1105 1236 : m_xFrame );
1106 2472 : m_xImageOrientationListener = Reference< XComponent >( static_cast< ::cppu::OWeakObject *>(
1107 2472 : pImageOrientation ), UNO_QUERY );
1108 : pImageOrientation->addStatusListener(
1109 1236 : OUString( ".uno:ImageOrientation" ));
1110 1236 : pImageOrientation->bindListener();
1111 : }
1112 1236 : }
1113 :
1114 53343 : ToolBoxItemBits ToolBarManager::ConvertStyleToToolboxItemBits( sal_Int32 nStyle )
1115 : {
1116 53343 : ToolBoxItemBits nItemBits( ToolBoxItemBits::NONE );
1117 53343 : if ( nStyle & ::com::sun::star::ui::ItemStyle::RADIO_CHECK )
1118 4636 : nItemBits |= ToolBoxItemBits::RADIOCHECK;
1119 53343 : if ( nStyle & ::com::sun::star::ui::ItemStyle::ALIGN_LEFT )
1120 0 : nItemBits |= ToolBoxItemBits::LEFT;
1121 53343 : if ( nStyle & ::com::sun::star::ui::ItemStyle::AUTO_SIZE )
1122 0 : nItemBits |= ToolBoxItemBits::AUTOSIZE;
1123 53343 : if ( nStyle & ::com::sun::star::ui::ItemStyle::DROP_DOWN )
1124 2009 : nItemBits |= ToolBoxItemBits::DROPDOWN;
1125 53343 : if ( nStyle & ::com::sun::star::ui::ItemStyle::REPEAT )
1126 0 : nItemBits |= ToolBoxItemBits::REPEAT;
1127 53343 : if ( nStyle & ::com::sun::star::ui::ItemStyle::DROPDOWN_ONLY )
1128 11 : nItemBits |= ToolBoxItemBits::DROPDOWNONLY;
1129 53343 : if ( nStyle & ::com::sun::star::ui::ItemStyle::TEXT )
1130 0 : nItemBits |= ToolBoxItemBits::TEXT_ONLY;
1131 53343 : if ( nStyle & ::com::sun::star::ui::ItemStyle::ICON )
1132 0 : nItemBits |= ToolBoxItemBits::ICON_ONLY;
1133 :
1134 53343 : return nItemBits;
1135 : }
1136 :
1137 1236 : void ToolBarManager::FillToolbar( const Reference< XIndexAccess >& rItemContainer )
1138 : {
1139 1236 : OString aTbxName = OUStringToOString( m_aResourceName, RTL_TEXTENCODING_ASCII_US );
1140 : SAL_INFO( "fwk.uielement", "framework (cd100003) ::ToolBarManager::FillToolbar " << aTbxName.getStr() );
1141 :
1142 2472 : SolarMutexGuard g;
1143 :
1144 1236 : if ( m_bDisposed )
1145 1236 : return;
1146 :
1147 1236 : sal_uInt16 nId( 1 );
1148 :
1149 2472 : Reference< XModuleManager2 > xModuleManager = ModuleManager::create( m_xContext );
1150 1236 : if ( !m_xDocImageManager.is() )
1151 : {
1152 1236 : Reference< XModel > xModel( GetModelFromFrame() );
1153 1236 : if ( xModel.is() )
1154 : {
1155 1235 : Reference< XUIConfigurationManagerSupplier > xSupplier( xModel, UNO_QUERY );
1156 1235 : if ( xSupplier.is() )
1157 : {
1158 1184 : m_xDocUICfgMgr.set( xSupplier->getUIConfigurationManager(), UNO_QUERY );
1159 1184 : m_xDocImageManager = Reference< XImageManager >( m_xDocUICfgMgr->getImageManager(), UNO_QUERY );
1160 1184 : m_xDocImageManager->addConfigurationListener(
1161 : Reference< XUIConfigurationListener >(
1162 1184 : static_cast< OWeakObject* >( this ), UNO_QUERY ));
1163 1235 : }
1164 1236 : }
1165 : }
1166 :
1167 : try
1168 : {
1169 1236 : m_aModuleIdentifier = xModuleManager->identify( Reference< XInterface >( m_xFrame, UNO_QUERY ) );
1170 : }
1171 0 : catch (const Exception&)
1172 : {
1173 : }
1174 :
1175 1236 : if ( !m_xModuleImageManager.is() )
1176 : {
1177 : Reference< XModuleUIConfigurationManagerSupplier > xModuleCfgMgrSupplier =
1178 1236 : theModuleUIConfigurationManagerSupplier::get( m_xContext );
1179 1236 : m_xUICfgMgr = xModuleCfgMgrSupplier->getUIConfigurationManager( m_aModuleIdentifier );
1180 1236 : m_xModuleImageManager = Reference< XImageManager >( m_xUICfgMgr->getImageManager(), UNO_QUERY );
1181 1236 : m_xModuleImageManager->addConfigurationListener( Reference< XUIConfigurationListener >(
1182 1236 : static_cast< OWeakObject* >( this ), UNO_QUERY ));
1183 : }
1184 :
1185 1236 : RemoveControllers();
1186 :
1187 : // reset and fill command map
1188 1236 : m_pToolBar->Clear();
1189 1236 : m_aControllerMap.clear();
1190 1236 : m_aCommandMap.clear();
1191 :
1192 1236 : m_aMenuMap.clear();
1193 :
1194 2472 : CommandInfo aCmdInfo;
1195 69723 : for ( sal_Int32 n = 0; n < rItemContainer->getCount(); n++ )
1196 : {
1197 68487 : Sequence< PropertyValue > aProp;
1198 136974 : OUString aCommandURL;
1199 136974 : OUString aLabel;
1200 136974 : OUString aHelpURL;
1201 136974 : OUString aTooltip;
1202 68487 : sal_uInt16 nType( ::com::sun::star::ui::ItemType::DEFAULT );
1203 68487 : sal_uInt16 nWidth( 0 );
1204 68487 : sal_uInt32 nStyle( 0 );
1205 :
1206 136974 : Reference< XIndexAccess > aMenuDesc;
1207 : try
1208 : {
1209 68487 : if ( rItemContainer->getByIndex( n ) >>= aProp )
1210 : {
1211 68487 : bool bIsVisible( true );
1212 472176 : for ( int i = 0; i < aProp.getLength(); i++ )
1213 : {
1214 403689 : if ( aProp[i].Name == ITEM_DESCRIPTOR_COMMANDURL )
1215 : {
1216 68487 : aProp[i].Value >>= aCommandURL;
1217 68487 : if ( aCommandURL.startsWith(MENUPREFIX) )
1218 : {
1219 : try
1220 : {
1221 0 : Reference< XIndexAccess > xMenuContainer;
1222 0 : if ( m_xDocUICfgMgr.is() &&
1223 0 : m_xDocUICfgMgr->hasSettings( aCommandURL ) )
1224 0 : xMenuContainer = m_xDocUICfgMgr->getSettings( aCommandURL, sal_False );
1225 0 : if ( !xMenuContainer.is() &&
1226 0 : m_xUICfgMgr.is() &&
1227 0 : m_xUICfgMgr->hasSettings( aCommandURL ) )
1228 0 : xMenuContainer = m_xUICfgMgr->getSettings( aCommandURL, sal_False );
1229 0 : if ( xMenuContainer.is() && xMenuContainer->getCount() )
1230 : {
1231 0 : Sequence< PropertyValue > aProps;
1232 : // drop down menu info is currently
1233 : // the first ( and only ) menu
1234 : // in the menusettings container
1235 0 : xMenuContainer->getByIndex(0) >>= aProps;
1236 0 : for ( sal_Int32 index=0; index<aProps.getLength(); ++index )
1237 : {
1238 0 : if ( aProps[ index ].Name == ITEM_DESCRIPTOR_CONTAINER )
1239 :
1240 : {
1241 0 : aProps[ index ].Value >>= aMenuDesc;
1242 0 : break;
1243 : }
1244 0 : }
1245 0 : }
1246 : }
1247 0 : catch (const Exception&)
1248 : {
1249 : }
1250 : }
1251 : }
1252 335202 : else if ( aProp[i].Name == ITEM_DESCRIPTOR_HELPURL )
1253 53343 : aProp[i].Value >>= aHelpURL;
1254 281859 : else if ( aProp[i].Name == ITEM_DESCRIPTOR_TOOLTIP )
1255 53343 : aProp[i].Value >>= aTooltip;
1256 228516 : else if ( aProp[i].Name == ITEM_DESCRIPTOR_LABEL )
1257 53343 : aProp[i].Value >>= aLabel;
1258 175173 : else if ( aProp[i].Name == ITEM_DESCRIPTOR_TYPE )
1259 68487 : aProp[i].Value >>= nType;
1260 106686 : else if ( aProp[i].Name == ITEM_DESCRIPTOR_VISIBLE )
1261 53343 : aProp[i].Value >>= bIsVisible;
1262 53343 : else if ( aProp[i].Name == ITEM_DESCRIPTOR_WIDTH )
1263 0 : aProp[i].Value >>= nWidth;
1264 53343 : else if ( aProp[i].Name == ITEM_DESCRIPTOR_STYLE )
1265 53343 : aProp[i].Value >>= nStyle;
1266 : }
1267 :
1268 68487 : if (( nType == ::com::sun::star::ui::ItemType::DEFAULT ) && !aCommandURL.isEmpty() )
1269 : {
1270 53343 : OUString aString( RetrieveLabelFromCommand( aCommandURL ));
1271 :
1272 53343 : ToolBoxItemBits nItemBits = ConvertStyleToToolboxItemBits( nStyle );
1273 53343 : if ( aMenuDesc.is() )
1274 : {
1275 0 : m_aMenuMap[ nId ] = aMenuDesc;
1276 0 : nItemBits |= ToolBoxItemBits::DROPDOWNONLY;
1277 : }
1278 53343 : m_pToolBar->InsertItem( nId, aString, nItemBits );
1279 53343 : m_pToolBar->SetItemCommand( nId, aCommandURL );
1280 106686 : OUString sQuickHelp( aString );
1281 : // Use custom tooltip if available
1282 53343 : if ( !aTooltip.isEmpty() )
1283 0 : sQuickHelp = aTooltip;
1284 106686 : OUString sShortCut;
1285 53343 : if( RetrieveShortcut( aCommandURL, sShortCut ) )
1286 : {
1287 5 : sQuickHelp += " (";
1288 5 : sQuickHelp += sShortCut;
1289 5 : sQuickHelp += ")";
1290 : }
1291 53343 : m_pToolBar->SetQuickHelpText( nId, sQuickHelp );
1292 :
1293 53343 : if ( !aLabel.isEmpty() )
1294 : {
1295 2 : m_pToolBar->SetItemText( nId, aLabel );
1296 : }
1297 : else
1298 : {
1299 53341 : m_pToolBar->SetItemText( nId, aString );
1300 : }
1301 53343 : m_pToolBar->EnableItem( nId, true );
1302 53343 : m_pToolBar->SetItemState( nId, TRISTATE_FALSE );
1303 :
1304 : // Fill command map. It stores all our commands and from what
1305 : // image manager we got our image. So we can decide if we have to use an
1306 : // image from a notification message.
1307 53343 : CommandToInfoMap::iterator pIter = m_aCommandMap.find( aCommandURL );
1308 53343 : if ( pIter == m_aCommandMap.end())
1309 : {
1310 53343 : aCmdInfo.nId = nId;
1311 53343 : aCmdInfo.nWidth = nWidth;
1312 53343 : const CommandToInfoMap::value_type aValue( aCommandURL, aCmdInfo );
1313 53343 : m_aCommandMap.insert( aValue );
1314 : }
1315 : else
1316 : {
1317 0 : pIter->second.aIds.push_back( nId );
1318 : }
1319 :
1320 53343 : if ( !bIsVisible )
1321 18474 : m_pToolBar->HideItem( nId );
1322 :
1323 106686 : ++nId;
1324 : }
1325 15144 : else if ( nType == ::com::sun::star::ui::ItemType::SEPARATOR_LINE )
1326 : {
1327 15144 : m_pToolBar->InsertSeparator();
1328 : }
1329 0 : else if ( nType == ::com::sun::star::ui::ItemType::SEPARATOR_SPACE )
1330 : {
1331 0 : m_pToolBar->InsertSpace();
1332 : }
1333 0 : else if ( nType == ::com::sun::star::ui::ItemType::SEPARATOR_LINEBREAK )
1334 : {
1335 0 : m_pToolBar->InsertBreak();
1336 : }
1337 : }
1338 : }
1339 0 : catch (const ::com::sun::star::lang::IndexOutOfBoundsException&)
1340 : {
1341 0 : break;
1342 : }
1343 68487 : }
1344 :
1345 : // Support add-on toolbar merging here. Working directly on the toolbar object is much
1346 : // simpler and faster.
1347 1236 : const sal_uInt16 TOOLBAR_ITEM_STARTID = 1000;
1348 :
1349 2472 : MergeToolbarInstructionContainer aMergeInstructionContainer;
1350 :
1351 : // Retrieve the toolbar name from the resource name
1352 2472 : OUString aToolbarName( m_aResourceName );
1353 1236 : sal_Int32 nIndex = aToolbarName.lastIndexOf( '/' );
1354 1236 : if (( nIndex > 0 ) && ( nIndex < aToolbarName.getLength() ))
1355 1236 : aToolbarName = aToolbarName.copy( nIndex+1 );
1356 :
1357 1236 : AddonsOptions().GetMergeToolbarInstructions( aToolbarName, aMergeInstructionContainer );
1358 :
1359 1236 : if ( !aMergeInstructionContainer.empty() )
1360 : {
1361 0 : sal_uInt16 nItemId( TOOLBAR_ITEM_STARTID );
1362 0 : const sal_uInt32 nCount = aMergeInstructionContainer.size();
1363 0 : for ( sal_uInt32 i=0; i < nCount; i++ )
1364 : {
1365 0 : MergeToolbarInstruction& rInstruction = aMergeInstructionContainer[i];
1366 0 : if ( ToolBarMerger::IsCorrectContext( rInstruction.aMergeContext, m_aModuleIdentifier ))
1367 : {
1368 0 : ReferenceToolbarPathInfo aRefPoint = ToolBarMerger::FindReferencePoint( m_pToolBar, rInstruction.aMergePoint );
1369 :
1370 : // convert the sequence< sequence< propertyvalue > > structure to
1371 : // something we can better handle. A vector with item data
1372 0 : AddonToolbarItemContainer aItems;
1373 0 : ToolBarMerger::ConvertSeqSeqToVector( rInstruction.aMergeToolbarItems, aItems );
1374 :
1375 0 : if ( aRefPoint.bResult )
1376 : {
1377 : ToolBarMerger::ProcessMergeOperation( m_xFrame,
1378 : m_pToolBar,
1379 : aRefPoint.nPos,
1380 : nItemId,
1381 : m_aCommandMap,
1382 : m_aModuleIdentifier,
1383 : rInstruction.aMergeCommand,
1384 : rInstruction.aMergeCommandParameter,
1385 0 : aItems );
1386 : }
1387 : else
1388 : {
1389 : ToolBarMerger::ProcessMergeFallback( m_xFrame,
1390 : m_pToolBar,
1391 : aRefPoint.nPos,
1392 : nItemId,
1393 : m_aCommandMap,
1394 : m_aModuleIdentifier,
1395 : rInstruction.aMergeCommand,
1396 : rInstruction.aMergeFallback,
1397 0 : aItems );
1398 0 : }
1399 : }
1400 : }
1401 : }
1402 :
1403 : // Request images for all toolbar items. Must be done before CreateControllers as
1404 : // some controllers need access to the image.
1405 1236 : RequestImages();
1406 :
1407 : // Create controllers after we set the images. There are controllers which needs
1408 : // an image at the toolbar at creation time!
1409 1236 : CreateControllers();
1410 :
1411 : // Notify controllers that they are now correctly initialized and can start listening
1412 : // toolbars that will open in popup mode will be updated immediately to avoid flickering
1413 1236 : if( m_pToolBar->WillUsePopupMode() )
1414 0 : UpdateControllers();
1415 1236 : else if ( m_pToolBar->IsReallyVisible() )
1416 : {
1417 0 : m_aAsyncUpdateControllersTimer.Start();
1418 : }
1419 :
1420 : // Try to retrieve UIName from the container property set and set it as the title
1421 : // if it is not empty.
1422 2472 : Reference< XPropertySet > xPropSet( rItemContainer, UNO_QUERY );
1423 1236 : if ( xPropSet.is() )
1424 : {
1425 : try
1426 : {
1427 1236 : OUString aUIName;
1428 1236 : xPropSet->getPropertyValue("UIName") >>= aUIName;
1429 1236 : if ( !aUIName.isEmpty() )
1430 0 : m_pToolBar->SetText( aUIName );
1431 : }
1432 0 : catch (const Exception&)
1433 : {
1434 : }
1435 1236 : }
1436 : }
1437 :
1438 1236 : void ToolBarManager::RequestImages()
1439 : {
1440 :
1441 : // Request images from image manager
1442 1236 : Sequence< OUString > aCmdURLSeq( m_aCommandMap.size() );
1443 2472 : Sequence< Reference< XGraphic > > aDocGraphicSeq;
1444 2472 : Sequence< Reference< XGraphic > > aModGraphicSeq;
1445 :
1446 1236 : sal_uInt32 i = 0;
1447 1236 : CommandToInfoMap::iterator pIter = m_aCommandMap.begin();
1448 1236 : CommandToInfoMap::iterator pEnd = m_aCommandMap.end();
1449 55815 : while ( pIter != pEnd )
1450 : {
1451 53343 : aCmdURLSeq[i++] = pIter->first;
1452 53343 : ++pIter;
1453 : }
1454 :
1455 1236 : bool bBigImages( SvtMiscOptions().AreCurrentSymbolsLarge() );
1456 1236 : sal_Int16 p = getImageTypeFromBools( SvtMiscOptions().AreCurrentSymbolsLarge() );
1457 :
1458 1236 : if ( m_xDocImageManager.is() )
1459 1184 : aDocGraphicSeq = m_xDocImageManager->getImages( p, aCmdURLSeq );
1460 1236 : aModGraphicSeq = m_xModuleImageManager->getImages( p, aCmdURLSeq );
1461 :
1462 1236 : i = 0;
1463 1236 : pIter = m_aCommandMap.begin();
1464 55815 : while ( pIter != pEnd )
1465 : {
1466 53343 : Image aImage;
1467 53343 : if ( aDocGraphicSeq.getLength() > 0 )
1468 52541 : aImage = Image( aDocGraphicSeq[i] );
1469 53343 : if ( !aImage )
1470 : {
1471 53343 : aImage = Image( aModGraphicSeq[i] );
1472 : // Try also to query for add-on images before giving up and use an
1473 : // empty image.
1474 53343 : if ( !aImage )
1475 206 : aImage = QueryAddonsImage( aCmdURLSeq[i], bBigImages );
1476 :
1477 53343 : pIter->second.nImageInfo = 1; // mark image as module based
1478 : }
1479 : else
1480 : {
1481 0 : pIter->second.nImageInfo = 0; // mark image as document based
1482 : }
1483 53343 : setToolBarImage(aImage,pIter);
1484 53343 : ++pIter;
1485 53343 : ++i;
1486 54579 : }
1487 1236 : }
1488 :
1489 4 : void ToolBarManager::notifyRegisteredControllers( const OUString& aUIElementName, const OUString& aCommand )
1490 : {
1491 4 : SolarMutexClearableGuard aGuard;
1492 4 : if ( !m_aSubToolBarControllerMap.empty() )
1493 : {
1494 : SubToolBarToSubToolBarControllerMap::const_iterator pIter =
1495 2 : m_aSubToolBarControllerMap.find( aUIElementName );
1496 :
1497 2 : if ( pIter != m_aSubToolBarControllerMap.end() )
1498 : {
1499 0 : const SubToolBarControllerVector& rSubToolBarVector = pIter->second;
1500 0 : if ( !rSubToolBarVector.empty() )
1501 : {
1502 0 : SubToolBarControllerVector aNotifyVector = rSubToolBarVector;
1503 0 : aGuard.clear();
1504 :
1505 0 : const sal_uInt32 nCount = aNotifyVector.size();
1506 0 : for ( sal_uInt32 i=0; i < nCount; i++ )
1507 : {
1508 : try
1509 : {
1510 0 : Reference< XSubToolbarController > xController = aNotifyVector[i];
1511 0 : if ( xController.is() )
1512 0 : xController->functionSelected( aCommand );
1513 : }
1514 0 : catch (const RuntimeException&)
1515 : {
1516 0 : throw;
1517 : }
1518 0 : catch (const Exception&)
1519 : {
1520 : }
1521 0 : }
1522 : }
1523 : }
1524 4 : }
1525 4 : }
1526 2 : long ToolBarManager::HandleClick(void ( SAL_CALL XToolbarController::*_pClick )())
1527 : {
1528 2 : SolarMutexGuard g;
1529 :
1530 2 : if ( m_bDisposed )
1531 0 : return 1;
1532 :
1533 2 : sal_uInt16 nId( m_pToolBar->GetCurItemId() );
1534 2 : ToolBarControllerMap::const_iterator pIter = m_aControllerMap.find( nId );
1535 2 : if ( pIter != m_aControllerMap.end() )
1536 : {
1537 2 : Reference< XToolbarController > xController( pIter->second, UNO_QUERY );
1538 :
1539 2 : if ( xController.is() )
1540 2 : (xController.get()->*_pClick)( );
1541 : } // if ( pIter != m_aControllerMap.end() )
1542 2 : return 1;
1543 : }
1544 :
1545 4 : IMPL_LINK_NOARG_TYPED(ToolBarManager, Click, ToolBox *, void)
1546 : {
1547 2 : HandleClick(&XToolbarController::click);
1548 2 : }
1549 :
1550 0 : IMPL_LINK_NOARG_TYPED(ToolBarManager, DropdownClick, ToolBox *, void)
1551 : {
1552 0 : SolarMutexGuard g;
1553 :
1554 0 : if ( m_bDisposed )
1555 0 : return;
1556 :
1557 0 : sal_uInt16 nId( m_pToolBar->GetCurItemId() );
1558 0 : ToolBarControllerMap::const_iterator pIter = m_aControllerMap.find( nId );
1559 0 : if ( pIter != m_aControllerMap.end() )
1560 : {
1561 0 : Reference< XToolbarController > xController( pIter->second, UNO_QUERY );
1562 :
1563 0 : if ( xController.is() )
1564 : {
1565 0 : Reference< XWindow > xWin = xController->createPopupWindow();
1566 0 : if ( xWin.is() )
1567 0 : xWin->setFocus();
1568 0 : }
1569 0 : }
1570 : }
1571 :
1572 0 : IMPL_LINK_NOARG_TYPED(ToolBarManager, DoubleClick, ToolBox *, void)
1573 : {
1574 0 : HandleClick(&XToolbarController::doubleClick);
1575 0 : }
1576 :
1577 9509 : void ToolBarManager::ImplClearPopupMenu( ToolBox *pToolBar )
1578 : {
1579 9509 : if ( m_bDisposed )
1580 9509 : return;
1581 :
1582 9509 : ::PopupMenu *pMenu = pToolBar->GetMenu();
1583 :
1584 : // remove config entries from menu, so we have a clean menu to start with
1585 : // remove submenu first
1586 9509 : ::PopupMenu* pItemMenu = pMenu->GetPopupMenu( 1 );
1587 9509 : if( pItemMenu )
1588 : {
1589 0 : pItemMenu->Clear();
1590 0 : delete pItemMenu;
1591 0 : pItemMenu = NULL;
1592 0 : pMenu->SetPopupMenu( 1, pItemMenu );
1593 : }
1594 :
1595 : // remove all items that were not added by the toolbar itself
1596 : sal_uInt16 i;
1597 19018 : for( i=0; i<pMenu->GetItemCount(); )
1598 : {
1599 0 : if( pMenu->GetItemId( i ) < TOOLBOX_MENUITEM_START
1600 0 : && pMenu->GetItemId( i ) != 0 ) // Don't remove separators (Id == 0)
1601 0 : pMenu->RemoveItem( i );
1602 : else
1603 0 : i++;
1604 : }
1605 : }
1606 :
1607 0 : IMPL_LINK_TYPED( ToolBarManager, MenuDeactivate, Menu*, pMenu, bool )
1608 : {
1609 0 : SolarMutexGuard g;
1610 :
1611 0 : if ( m_bDisposed )
1612 0 : return true;
1613 :
1614 0 : if( pMenu != m_pToolBar->GetMenu() )
1615 0 : return true;
1616 :
1617 0 : ImplClearPopupMenu( m_pToolBar );
1618 :
1619 0 : return false;
1620 : }
1621 :
1622 1236 : Reference< XModel > ToolBarManager::GetModelFromFrame() const
1623 : {
1624 1236 : Reference< XController > xController = m_xFrame->getController();
1625 1236 : Reference< XModel > xModel;
1626 1236 : if ( xController.is() )
1627 1236 : xModel = xController->getModel();
1628 :
1629 1236 : return xModel;
1630 : }
1631 :
1632 0 : bool ToolBarManager::IsPluginMode() const
1633 : {
1634 0 : bool bPluginMode( false );
1635 :
1636 0 : if ( m_xFrame.is() )
1637 : {
1638 0 : Reference< XModel > xModel = GetModelFromFrame();
1639 0 : if ( xModel.is() )
1640 : {
1641 0 : Sequence< PropertyValue > aSeq = xModel->getArgs();
1642 0 : utl::MediaDescriptor aMediaDescriptor( aSeq );
1643 : bPluginMode = aMediaDescriptor.getUnpackedValueOrDefault(
1644 0 : utl::MediaDescriptor::PROP_VIEWONLY(), false );
1645 0 : }
1646 : }
1647 :
1648 0 : return bPluginMode;
1649 : }
1650 :
1651 0 : bool ToolBarManager::MenuItemAllowed( sal_uInt16 ) const
1652 : {
1653 0 : return true;
1654 : }
1655 :
1656 0 : ::PopupMenu * ToolBarManager::GetToolBarCustomMenu(ToolBox* pToolBar)
1657 : {
1658 : // update the list of hidden tool items first
1659 0 : pToolBar->UpdateCustomMenu();
1660 :
1661 0 : ::PopupMenu *pMenu = pToolBar->GetMenu();
1662 : // remove all entries before inserting new ones
1663 0 : ImplClearPopupMenu( pToolBar );
1664 : // No config menu entries if command ".uno:ConfigureDialog" is not enabled
1665 0 : Reference< XDispatch > xDisp;
1666 0 : com::sun::star::util::URL aURL;
1667 0 : if ( m_xFrame.is() )
1668 : {
1669 0 : Reference< XDispatchProvider > xProv( m_xFrame, UNO_QUERY );
1670 0 : aURL.Complete = ".uno:ConfigureDialog";
1671 0 : m_xURLTransformer->parseStrict( aURL );
1672 0 : if ( xProv.is() )
1673 0 : xDisp = xProv->queryDispatch( aURL, OUString(), 0 );
1674 :
1675 0 : if ( !xDisp.is() || IsPluginMode() )
1676 0 : return 0;
1677 : }
1678 :
1679 : // popup menu for quick customization
1680 0 : bool bHideDisabledEntries = !SvtMenuOptions().IsEntryHidingEnabled();
1681 0 : ::PopupMenu aPopupMenu( FwkResId( POPUPMENU_TOOLBAR_QUICKCUSTOMIZATION ));
1682 :
1683 0 : if ( m_pToolBar->IsCustomize() )
1684 : {
1685 0 : sal_uInt16 nPos( 0 );
1686 0 : ::PopupMenu* pItemMenu( aPopupMenu.GetPopupMenu( 1 ));
1687 :
1688 0 : bool bIsFloating( false );
1689 :
1690 0 : DockingManager* pDockMgr = vcl::Window::GetDockingManager();
1691 0 : if ( pDockMgr )
1692 0 : bIsFloating = pDockMgr->IsFloating( m_pToolBar );
1693 :
1694 0 : if ( !bIsFloating )
1695 : {
1696 0 : aPopupMenu.EnableItem( MENUITEM_TOOLBAR_DOCKTOOLBAR, false );
1697 0 : aPopupMenu.EnableItem( MENUITEM_TOOLBAR_DOCKALLTOOLBAR, false );
1698 0 : Reference< XDockableWindow > xDockable( VCLUnoHelper::GetInterface( m_pToolBar ), UNO_QUERY );
1699 0 : if( xDockable.is() )
1700 0 : aPopupMenu.CheckItem( MENUITEM_TOOLBAR_LOCKTOOLBARPOSITION, xDockable->isLocked() );
1701 : }
1702 : else
1703 0 : aPopupMenu.EnableItem( MENUITEM_TOOLBAR_LOCKTOOLBARPOSITION, false );
1704 :
1705 0 : if ( SvtMiscOptions().DisableUICustomization() )
1706 : {
1707 0 : aPopupMenu.EnableItem( MENUITEM_TOOLBAR_VISIBLEBUTTON, false );
1708 0 : aPopupMenu.EnableItem( MENUITEM_TOOLBAR_CUSTOMIZETOOLBAR, false );
1709 0 : aPopupMenu.EnableItem( MENUITEM_TOOLBAR_LOCKTOOLBARPOSITION, false );
1710 : }
1711 :
1712 : // Disable menu item CLOSE if the toolbar has no closer
1713 0 : if( !(pToolBar->GetFloatStyle() & WB_CLOSEABLE) )
1714 0 : aPopupMenu.EnableItem(MENUITEM_TOOLBAR_CLOSE, false);
1715 :
1716 0 : for ( nPos = 0; nPos < m_pToolBar->GetItemCount(); ++nPos )
1717 : {
1718 0 : if ( m_pToolBar->GetItemType(nPos) == ToolBoxItemType::BUTTON )
1719 : {
1720 0 : sal_uInt16 nId = m_pToolBar->GetItemId(nPos);
1721 0 : OUString aCommandURL = m_pToolBar->GetItemCommand( nId );
1722 0 : pItemMenu->InsertItem( STARTID_CUSTOMIZE_POPUPMENU+nPos, m_pToolBar->GetItemText( nId ), MenuItemBits::CHECKABLE );
1723 0 : pItemMenu->CheckItem( STARTID_CUSTOMIZE_POPUPMENU+nPos, m_pToolBar->IsItemVisible( nId ) );
1724 0 : pItemMenu->SetItemCommand( STARTID_CUSTOMIZE_POPUPMENU+nPos, aCommandURL );
1725 : pItemMenu->SetItemImage( STARTID_CUSTOMIZE_POPUPMENU+nPos,
1726 : GetImageFromURL( m_xFrame, aCommandURL, false )
1727 0 : );
1728 : }
1729 : else
1730 : {
1731 0 : pItemMenu->InsertSeparator();
1732 : }
1733 : }
1734 : }
1735 : else
1736 : {
1737 0 : sal_uInt16 nPos = aPopupMenu.GetItemPos( MENUITEM_TOOLBAR_CUSTOMIZETOOLBAR );
1738 0 : if ( nPos != MENU_ITEM_NOTFOUND )
1739 0 : aPopupMenu.RemoveItem( nPos );
1740 : }
1741 :
1742 : // copy all menu items to the toolbar menu
1743 0 : if( pMenu->GetItemCount() )
1744 0 : pMenu->InsertSeparator();
1745 :
1746 : sal_uInt16 i;
1747 0 : for( i=0; i< aPopupMenu.GetItemCount(); i++)
1748 : {
1749 0 : sal_uInt16 nId = aPopupMenu.GetItemId( i );
1750 0 : if ( MenuItemAllowed( nId ))
1751 0 : pMenu->CopyItem( aPopupMenu, i, MENU_APPEND );
1752 : }
1753 :
1754 : // set submenu to toolbar menu
1755 0 : if( aPopupMenu.GetPopupMenu( 1 ) )
1756 : {
1757 : // create an own submenu to avoid auto-delete when resource menu is deleted
1758 0 : ::PopupMenu *pItemMenu = new ::PopupMenu();
1759 :
1760 0 : for( i=0; i< aPopupMenu.GetPopupMenu( 1 )->GetItemCount(); i++)
1761 0 : pItemMenu->CopyItem( *aPopupMenu.GetPopupMenu( 1 ), i, MENU_APPEND );
1762 :
1763 0 : pMenu->SetPopupMenu( 1, pItemMenu );
1764 : }
1765 :
1766 : // Set the title of the menu
1767 0 : pMenu->SetText( pToolBar->GetText() );
1768 :
1769 0 : if ( bHideDisabledEntries )
1770 0 : pMenu->RemoveDisabledEntries();
1771 :
1772 0 : return pMenu;
1773 : }
1774 :
1775 0 : IMPL_LINK_TYPED( ToolBarManager, Command, CommandEvent const *, pCmdEvt, void )
1776 : {
1777 0 : SolarMutexGuard g;
1778 :
1779 0 : if ( m_bDisposed )
1780 0 : return;
1781 0 : if ( pCmdEvt->GetCommand() != CommandEventId::ContextMenu )
1782 0 : return;
1783 :
1784 0 : ::PopupMenu * pMenu = GetToolBarCustomMenu(m_pToolBar);
1785 0 : if (pMenu)
1786 : {
1787 : // We only want to handle events for the context menu, but not events
1788 : // on the toolbars overflow menu, hence we should only receive events
1789 : // from the toolbox menu when we are actually showing it as our context
1790 : // menu (the same menu retrieved with GetMenu() is reused for both the
1791 : // overflow and context menus). If we set these Hdls permanently rather
1792 : // than just when the context menu is showing, then events are duplicated
1793 : // when the menu is being used as an overflow menu.
1794 0 : Menu *pManagerMenu = m_pToolBar->GetMenu();
1795 0 : pManagerMenu->SetSelectHdl( LINK( this, ToolBarManager, MenuSelect ) );
1796 0 : pManagerMenu->SetDeactivateHdl( LINK( this, ToolBarManager, MenuDeactivate ) );
1797 :
1798 : // make sure all disabled entries will be shown
1799 0 : pMenu->SetMenuFlags( pMenu->GetMenuFlags() | MenuFlags::AlwaysShowDisabledEntries );
1800 0 : ::Point aPoint( pCmdEvt->GetMousePosPixel() );
1801 0 : pMenu->Execute( m_pToolBar, aPoint );
1802 :
1803 : //fdo#86820 We may have been disposed and so have a NULL m_pToolBar by
1804 : //executing a menu entry, e.g. inserting a chart replaces the toolbars
1805 0 : pManagerMenu = m_bDisposed ? NULL : m_pToolBar->GetMenu();
1806 0 : if (pManagerMenu)
1807 : {
1808 : // Unlink our listeners again -- see above for why.
1809 0 : pManagerMenu->SetSelectHdl( Link<>() );
1810 0 : pManagerMenu->SetDeactivateHdl( Link<Menu *, bool>() );
1811 : }
1812 0 : }
1813 : }
1814 :
1815 0 : IMPL_LINK_TYPED( ToolBarManager, MenuButton, ToolBox*, pToolBar, void )
1816 : {
1817 0 : SolarMutexGuard g;
1818 :
1819 0 : if ( m_bDisposed )
1820 0 : return;
1821 :
1822 0 : pToolBar->UpdateCustomMenu();
1823 : // remove all entries that do not come from the toolbar itself (fdo#38276)
1824 0 : ImplClearPopupMenu( pToolBar );
1825 : }
1826 :
1827 0 : IMPL_LINK( ToolBarManager, MenuSelect, Menu*, pMenu )
1828 : {
1829 : // We have to hold a reference to ourself as it is possible that we will be disposed and
1830 : // our refcount could be zero (destruction) otherwise.
1831 0 : Reference< XInterface > xInterface( static_cast< OWeakObject* >( this ), UNO_QUERY );
1832 :
1833 : {
1834 : // The guard must be in its own context as the we can get destroyed when our
1835 : // own xInterface reference get destroyed!
1836 0 : SolarMutexGuard g;
1837 :
1838 0 : if ( m_bDisposed )
1839 0 : return 1;
1840 :
1841 0 : switch ( pMenu->GetCurItemId() )
1842 : {
1843 : case MENUITEM_TOOLBAR_CUSTOMIZETOOLBAR:
1844 : {
1845 0 : Reference< XDispatch > xDisp;
1846 0 : com::sun::star::util::URL aURL;
1847 0 : if ( m_xFrame.is() )
1848 : {
1849 0 : Reference< XDispatchProvider > xProv( m_xFrame, UNO_QUERY );
1850 0 : aURL.Complete = ".uno:ConfigureDialog";
1851 0 : m_xURLTransformer->parseStrict( aURL );
1852 0 : if ( xProv.is() )
1853 0 : xDisp = xProv->queryDispatch( aURL, OUString(), 0 );
1854 : }
1855 :
1856 0 : if ( xDisp.is() )
1857 : {
1858 0 : Sequence< PropertyValue > aPropSeq( 1 );
1859 :
1860 0 : aPropSeq[ 0 ].Name = "ResourceURL";
1861 0 : aPropSeq[ 0 ].Value <<= m_aResourceName;
1862 :
1863 0 : xDisp->dispatch( aURL, aPropSeq );
1864 : }
1865 0 : break;
1866 : }
1867 :
1868 : case MENUITEM_TOOLBAR_DOCKTOOLBAR:
1869 : {
1870 0 : ExecuteInfo* pExecuteInfo = new ExecuteInfo;
1871 :
1872 0 : pExecuteInfo->aToolbarResName = m_aResourceName;
1873 0 : pExecuteInfo->nCmd = EXEC_CMD_DOCKTOOLBAR;
1874 0 : pExecuteInfo->xLayoutManager = getLayoutManagerFromFrame( m_xFrame );
1875 :
1876 0 : Application::PostUserEvent( LINK(0, ToolBarManager, ExecuteHdl_Impl), pExecuteInfo );
1877 0 : break;
1878 : }
1879 :
1880 : case MENUITEM_TOOLBAR_DOCKALLTOOLBAR:
1881 : {
1882 0 : ExecuteInfo* pExecuteInfo = new ExecuteInfo;
1883 :
1884 0 : pExecuteInfo->aToolbarResName = m_aResourceName;
1885 0 : pExecuteInfo->nCmd = EXEC_CMD_DOCKALLTOOLBARS;
1886 0 : pExecuteInfo->xLayoutManager = getLayoutManagerFromFrame( m_xFrame );
1887 :
1888 0 : Application::PostUserEvent( LINK(0, ToolBarManager, ExecuteHdl_Impl), pExecuteInfo );
1889 0 : break;
1890 : }
1891 :
1892 : case MENUITEM_TOOLBAR_LOCKTOOLBARPOSITION:
1893 : {
1894 0 : Reference< XLayoutManager > xLayoutManager = getLayoutManagerFromFrame( m_xFrame );
1895 0 : if ( xLayoutManager.is() )
1896 : {
1897 0 : Reference< XDockableWindow > xDockable( VCLUnoHelper::GetInterface( m_pToolBar ), UNO_QUERY );
1898 :
1899 0 : if( xDockable->isLocked() )
1900 0 : xLayoutManager->unlockWindow( m_aResourceName );
1901 : else
1902 0 : xLayoutManager->lockWindow( m_aResourceName );
1903 : }
1904 0 : break;
1905 : }
1906 :
1907 : case MENUITEM_TOOLBAR_CLOSE:
1908 : {
1909 0 : ExecuteInfo* pExecuteInfo = new ExecuteInfo;
1910 :
1911 0 : pExecuteInfo->aToolbarResName = m_aResourceName;
1912 0 : pExecuteInfo->nCmd = EXEC_CMD_CLOSETOOLBAR;
1913 0 : pExecuteInfo->xLayoutManager = getLayoutManagerFromFrame( m_xFrame );
1914 0 : pExecuteInfo->xWindow = VCLUnoHelper::GetInterface( m_pToolBar );
1915 :
1916 0 : Application::PostUserEvent( LINK(0, ToolBarManager, ExecuteHdl_Impl), pExecuteInfo );
1917 0 : break;
1918 : }
1919 :
1920 : default:
1921 : {
1922 0 : sal_uInt16 nId = pMenu->GetCurItemId();
1923 0 : if(( nId > 0 ) && ( nId < TOOLBOX_MENUITEM_START ))
1924 : // Items in the "enable/disable" sub-menu
1925 : {
1926 : // toggle toolbar button visibility
1927 0 : OUString aCommand = pMenu->GetItemCommand( nId );
1928 :
1929 0 : Reference< XLayoutManager > xLayoutManager = getLayoutManagerFromFrame( m_xFrame );
1930 0 : if ( xLayoutManager.is() )
1931 : {
1932 0 : Reference< XUIElementSettings > xUIElementSettings( xLayoutManager->getElement( m_aResourceName ), UNO_QUERY );
1933 0 : if ( xUIElementSettings.is() )
1934 : {
1935 0 : Reference< XIndexContainer > xItemContainer( xUIElementSettings->getSettings( sal_True ), UNO_QUERY );
1936 0 : sal_Int32 nCount = xItemContainer->getCount();
1937 0 : for ( sal_Int32 i = 0; i < nCount; i++ )
1938 : {
1939 0 : Sequence< PropertyValue > aProp;
1940 0 : sal_Int32 nVisibleIndex( -1 );
1941 0 : OUString aCommandURL;
1942 0 : bool bVisible( false );
1943 :
1944 0 : if ( xItemContainer->getByIndex( i ) >>= aProp )
1945 : {
1946 0 : for ( sal_Int32 j = 0; j < aProp.getLength(); j++ )
1947 : {
1948 0 : if ( aProp[j].Name == ITEM_DESCRIPTOR_COMMANDURL )
1949 : {
1950 0 : aProp[j].Value >>= aCommandURL;
1951 : }
1952 0 : else if ( aProp[j].Name == ITEM_DESCRIPTOR_VISIBLE )
1953 : {
1954 0 : aProp[j].Value >>= bVisible;
1955 0 : nVisibleIndex = j;
1956 : }
1957 : }
1958 :
1959 0 : if (( aCommandURL == aCommand ) && ( nVisibleIndex >= 0 ))
1960 : {
1961 : // We have found the requested item, toggle the visible flag
1962 : // and write back the configuration settings to the toolbar
1963 0 : aProp[nVisibleIndex].Value = makeAny( !bVisible );
1964 : try
1965 : {
1966 0 : xItemContainer->replaceByIndex( i, makeAny( aProp ));
1967 0 : xUIElementSettings->setSettings( xItemContainer );
1968 0 : Reference< XPropertySet > xPropSet( xUIElementSettings, UNO_QUERY );
1969 0 : if ( xPropSet.is() )
1970 : {
1971 0 : Reference< XUIConfigurationPersistence > xUICfgMgr;
1972 0 : if (( xPropSet->getPropertyValue("ConfigurationSource") >>= xUICfgMgr ) && ( xUICfgMgr.is() ))
1973 0 : xUICfgMgr->store();
1974 0 : }
1975 : }
1976 0 : catch (const Exception&)
1977 : {
1978 : }
1979 :
1980 0 : break;
1981 : }
1982 : }
1983 0 : }
1984 0 : }
1985 0 : }
1986 : }
1987 : else
1988 : // The list of "hidden items", i.e. items which are disabled on
1989 : // the toolbar hence shown in the context menu for easier access,
1990 : // which are managed by the owning toolbar.
1991 : {
1992 0 : m_pToolBar->TriggerItem( pMenu->GetCurItemId()
1993 0 : - TOOLBOX_MENUITEM_START );
1994 : }
1995 0 : break;
1996 : }
1997 : }
1998 :
1999 : // remove all entries - deactivate is not reliable
2000 : // The method checks if we are already disposed and in that case does nothing!
2001 0 : ImplClearPopupMenu( m_pToolBar );
2002 : }
2003 :
2004 0 : return 1;
2005 : }
2006 :
2007 4 : IMPL_LINK_NOARG_TYPED(ToolBarManager, Select, ToolBox *, void)
2008 : {
2009 2 : if ( m_bDisposed )
2010 2 : return;
2011 :
2012 2 : sal_Int16 nKeyModifier( (sal_Int16)m_pToolBar->GetModifier() );
2013 2 : sal_uInt16 nId( m_pToolBar->GetCurItemId() );
2014 :
2015 2 : ToolBarControllerMap::const_iterator pIter = m_aControllerMap.find( nId );
2016 2 : if ( pIter != m_aControllerMap.end() )
2017 : {
2018 2 : Reference< XToolbarController > xController( pIter->second, UNO_QUERY );
2019 :
2020 2 : if ( xController.is() )
2021 2 : xController->execute( nKeyModifier );
2022 : }
2023 : }
2024 :
2025 59220 : IMPL_LINK_TYPED( ToolBarManager, StateChanged, StateChangedType const *, pStateChangedType, void )
2026 : {
2027 29610 : if ( m_bDisposed )
2028 29610 : return;
2029 :
2030 29610 : if ( *pStateChangedType == StateChangedType::ControlBackground )
2031 : {
2032 0 : CheckAndUpdateImages();
2033 : }
2034 29610 : else if ( *pStateChangedType == StateChangedType::Visible )
2035 : {
2036 13350 : if ( m_pToolBar->IsReallyVisible() )
2037 : {
2038 6668 : m_aAsyncUpdateControllersTimer.Start();
2039 : }
2040 : }
2041 16260 : else if ( *pStateChangedType == StateChangedType::InitShow )
2042 : {
2043 6678 : m_aAsyncUpdateControllersTimer.Start();
2044 : }
2045 : }
2046 :
2047 12 : IMPL_LINK_TYPED( ToolBarManager, DataChanged, DataChangedEvent const *, pDataChangedEvent, void )
2048 : {
2049 18 : if ((( pDataChangedEvent->GetType() == DataChangedEventType::SETTINGS ) ||
2050 24 : ( pDataChangedEvent->GetType() == DataChangedEventType::DISPLAY )) &&
2051 24 : ( pDataChangedEvent->GetFlags() & AllSettingsFlags::STYLE ))
2052 : {
2053 0 : CheckAndUpdateImages();
2054 : }
2055 :
2056 6 : for ( sal_uInt16 nPos = 0; nPos < m_pToolBar->GetItemCount(); ++nPos )
2057 : {
2058 0 : const sal_uInt16 nId = m_pToolBar->GetItemId(nPos);
2059 0 : vcl::Window* pWindow = m_pToolBar->GetItemWindow( nId );
2060 0 : if ( pWindow )
2061 : {
2062 0 : const DataChangedEvent& rDCEvt( *pDataChangedEvent );
2063 0 : pWindow->DataChanged( rDCEvt );
2064 : }
2065 : }
2066 :
2067 12 : if ( !m_pToolBar->IsFloatingMode() &&
2068 6 : m_pToolBar->IsVisible() )
2069 : {
2070 : // Resize toolbar, layout manager is resize listener and will calc
2071 : // the layout automatically.
2072 6 : ::Size aSize( m_pToolBar->CalcWindowSizePixel() );
2073 6 : m_pToolBar->SetOutputSizePixel( aSize );
2074 : }
2075 6 : }
2076 :
2077 0 : IMPL_LINK_NOARG(ToolBarManager, MiscOptionsChanged)
2078 : {
2079 0 : CheckAndUpdateImages();
2080 0 : return 0;
2081 : }
2082 :
2083 2688 : IMPL_LINK_NOARG_TYPED(ToolBarManager, AsyncUpdateControllersHdl, Timer *, void)
2084 : {
2085 : // The guard must be in its own context as the we can get destroyed when our
2086 : // own xInterface reference get destroyed!
2087 1344 : Reference< XComponent > xThis( static_cast< OWeakObject* >(this), UNO_QUERY );
2088 :
2089 2688 : SolarMutexGuard g;
2090 :
2091 1344 : if ( m_bDisposed )
2092 1344 : return;
2093 :
2094 : // Request to update our controllers
2095 1344 : m_aAsyncUpdateControllersTimer.Stop();
2096 2688 : UpdateControllers();
2097 : }
2098 :
2099 0 : IMPL_STATIC_LINK( ToolBarManager, ExecuteHdl_Impl, ExecuteInfo*, pExecuteInfo )
2100 : {
2101 : try
2102 : {
2103 : // Asynchronous execution as this can lead to our own destruction!
2104 0 : if (( pExecuteInfo->nCmd == EXEC_CMD_CLOSETOOLBAR ) &&
2105 0 : ( pExecuteInfo->xLayoutManager.is() ) &&
2106 0 : ( pExecuteInfo->xWindow.is() ))
2107 : {
2108 : // Use docking window close to close the toolbar. The toolbar layout manager is
2109 : // listener and will react correctly according to the context sensitive
2110 : // flag of our toolbar.
2111 0 : vcl::Window* pWin = VCLUnoHelper::GetWindow( pExecuteInfo->xWindow );
2112 0 : DockingWindow* pDockWin = dynamic_cast< DockingWindow* >( pWin );
2113 0 : if ( pDockWin )
2114 0 : pDockWin->Close();
2115 : }
2116 0 : else if (( pExecuteInfo->nCmd == EXEC_CMD_DOCKTOOLBAR ) &&
2117 0 : ( pExecuteInfo->xLayoutManager.is() ))
2118 : {
2119 0 : ::com::sun::star::awt::Point aPoint;
2120 0 : aPoint.X = aPoint.Y = SAL_MAX_INT32;
2121 0 : pExecuteInfo->xLayoutManager->dockWindow( pExecuteInfo->aToolbarResName,
2122 : DockingArea_DOCKINGAREA_DEFAULT,
2123 0 : aPoint );
2124 : }
2125 0 : else if (( pExecuteInfo->nCmd == EXEC_CMD_DOCKALLTOOLBARS ) &&
2126 0 : ( pExecuteInfo->xLayoutManager.is() ))
2127 : {
2128 0 : pExecuteInfo->xLayoutManager->dockAllWindows( UIElementType::TOOLBAR );
2129 : }
2130 : }
2131 0 : catch (const Exception&)
2132 : {
2133 : }
2134 :
2135 0 : delete pExecuteInfo;
2136 0 : return 0;
2137 : }
2138 :
2139 206 : Image ToolBarManager::QueryAddonsImage( const OUString& aCommandURL, bool bBigImages )
2140 : {
2141 206 : Image aImage = framework::AddonsOptions().GetImageFromURL( aCommandURL, bBigImages );
2142 206 : return aImage;
2143 : }
2144 :
2145 159217 : bool ToolBarManager::impl_RetrieveShortcutsFromConfiguration(
2146 : const Reference< XAcceleratorConfiguration >& rAccelCfg,
2147 : const OUString& rCommand,
2148 : OUString& rShortCut )
2149 : {
2150 159217 : if ( rAccelCfg.is() )
2151 : {
2152 : try
2153 : {
2154 159217 : com::sun::star::awt::KeyEvent aKeyEvent;
2155 318429 : Sequence< OUString > aCommands(1);
2156 159217 : aCommands[0] = rCommand;
2157 :
2158 318429 : Sequence< Any > aSeqKeyCode( rAccelCfg->getPreferredKeyEventsForCommandList( aCommands ) );
2159 159217 : if( aSeqKeyCode.getLength() == 1 )
2160 : {
2161 159217 : if ( aSeqKeyCode[0] >>= aKeyEvent )
2162 : {
2163 5 : rShortCut = svt::AcceleratorExecute::st_AWTKey2VCLKey( aKeyEvent ).GetName();
2164 5 : return true;
2165 : }
2166 159212 : }
2167 : }
2168 0 : catch (const IllegalArgumentException&)
2169 : {
2170 : }
2171 : }
2172 :
2173 159212 : return false;
2174 : }
2175 :
2176 53343 : bool ToolBarManager::RetrieveShortcut( const OUString& rCommandURL, OUString& rShortCut )
2177 : {
2178 53343 : if ( m_bModuleIdentified )
2179 : {
2180 53343 : Reference< XAcceleratorConfiguration > xDocAccelCfg( m_xDocAcceleratorManager );
2181 106681 : Reference< XAcceleratorConfiguration > xModuleAccelCfg( m_xModuleAcceleratorManager );
2182 106681 : Reference< XAcceleratorConfiguration > xGlobalAccelCfg( m_xGlobalAcceleratorManager );
2183 :
2184 53343 : if ( !m_bAcceleratorCfg )
2185 : {
2186 : // Retrieve references on demand
2187 1236 : m_bAcceleratorCfg = true;
2188 1236 : if ( !xDocAccelCfg.is() )
2189 : {
2190 1236 : Reference< XController > xController = m_xFrame->getController();
2191 2472 : Reference< XModel > xModel;
2192 1236 : if ( xController.is() )
2193 : {
2194 1236 : xModel = xController->getModel();
2195 1236 : if ( xModel.is() )
2196 : {
2197 1235 : Reference< XUIConfigurationManagerSupplier > xSupplier( xModel, UNO_QUERY );
2198 1235 : if ( xSupplier.is() )
2199 : {
2200 1184 : Reference< XUIConfigurationManager > xDocUICfgMgr( xSupplier->getUIConfigurationManager(), UNO_QUERY );
2201 1184 : if ( xDocUICfgMgr.is() )
2202 : {
2203 1184 : xDocAccelCfg = xDocUICfgMgr->getShortCutManager();
2204 1184 : m_xDocAcceleratorManager = xDocAccelCfg;
2205 1184 : }
2206 1235 : }
2207 : }
2208 1236 : }
2209 : }
2210 :
2211 1236 : if ( !xModuleAccelCfg.is() )
2212 : {
2213 : Reference< XModuleUIConfigurationManagerSupplier > xModuleCfgMgrSupplier =
2214 1236 : theModuleUIConfigurationManagerSupplier::get( m_xContext );
2215 : try
2216 : {
2217 1236 : Reference< XUIConfigurationManager > xUICfgMgr = xModuleCfgMgrSupplier->getUIConfigurationManager( m_aModuleIdentifier );
2218 1236 : if ( xUICfgMgr.is() )
2219 : {
2220 1236 : xModuleAccelCfg = xUICfgMgr->getShortCutManager();
2221 1236 : m_xModuleAcceleratorManager = xModuleAccelCfg;
2222 1236 : }
2223 : }
2224 0 : catch (const RuntimeException&)
2225 : {
2226 0 : throw;
2227 : }
2228 0 : catch (const Exception&)
2229 : {
2230 1236 : }
2231 : }
2232 :
2233 1236 : if ( !xGlobalAccelCfg.is() ) try
2234 : {
2235 1236 : xGlobalAccelCfg = GlobalAcceleratorConfiguration::create( m_xContext );
2236 1236 : m_xGlobalAcceleratorManager = xGlobalAccelCfg;
2237 : }
2238 0 : catch ( const css::uno::DeploymentException& )
2239 : {
2240 : SAL_WARN("fwk.uielement", "GlobalAcceleratorConfiguration"
2241 : " not available. This should happen only on mobile platforms.");
2242 : }
2243 : }
2244 :
2245 53343 : bool bFound = false;
2246 :
2247 53343 : if ( m_xGlobalAcceleratorManager.is() )
2248 53343 : bFound = impl_RetrieveShortcutsFromConfiguration( xGlobalAccelCfg, rCommandURL, rShortCut );
2249 53343 : if ( !bFound && m_xModuleAcceleratorManager.is() )
2250 53338 : bFound = impl_RetrieveShortcutsFromConfiguration( xModuleAccelCfg, rCommandURL, rShortCut );
2251 53343 : if ( !bFound && m_xDocAcceleratorManager.is() )
2252 52536 : impl_RetrieveShortcutsFromConfiguration( xGlobalAccelCfg, rCommandURL, rShortCut );
2253 :
2254 53343 : if( bFound )
2255 53343 : return true;
2256 : }
2257 53338 : return false;
2258 : }
2259 :
2260 648 : }
2261 :
2262 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
