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