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