?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
merge the formfield patch from ooo-build
[ooovba.git] / framework / source / uielement / menubarmanager.cxx
blob6e71139a2e17be1be288b8bfd15e3c45915be990
1 /*************************************************************************
2 *
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * Copyright 2008 by Sun Microsystems, Inc.
6 *
7 * OpenOffice.org - a multi-platform office productivity suite
8 *
9 * $RCSfile: menubarmanager.cxx,v $
10 * $Revision: 1.52.40.1 $
11 *
12 * This file is part of OpenOffice.org.
13 *
14 * OpenOffice.org is free software: you can redistribute it and/or modify
15 * it under the terms of the GNU Lesser General Public License version 3
16 * only, as published by the Free Software Foundation.
17 *
18 * OpenOffice.org is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 * GNU Lesser General Public License version 3 for more details
22 * (a copy is included in the LICENSE file that accompanied this code).
23 *
24 * You should have received a copy of the GNU Lesser General Public License
25 * version 3 along with OpenOffice.org. If not, see
26 * <http://www.openoffice.org/license.html>
27 * for a copy of the LGPLv3 License.
28 *
29 ************************************************************************/
30
31 // MARKER(update_precomp.py): autogen include statement, do not remove
32 #include "precompiled_framework.hxx"
33
34
35 //_________________________________________________________________________________________________________________
36 // my own includes
37 //_________________________________________________________________________________________________________________
38 #include <uielement/menubarmanager.hxx>
39 #include <xml/menuconfiguration.hxx>
40 #include <classes/bmkmenu.hxx>
41 #include <classes/addonmenu.hxx>
42 #include <helper/imageproducer.hxx>
43 #include <threadhelp/resetableguard.hxx>
44 #include "classes/addonsoptions.hxx"
45 #include <classes/fwkresid.hxx>
46 #include <classes/menumanager.hxx>
47 #include <helper/acceleratorinfo.hxx>
48 #include <helper/mischelper.hxx>
49 #include <classes/menuextensionsupplier.hxx>
50 #include <classes/resource.hrc>
51 #include <services.h>
52
53 //_________________________________________________________________________________________________________________
54 // interface includes
55 //_________________________________________________________________________________________________________________
56 #include <com/sun/star/frame/XDispatch.hpp>
57 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
58 #include <com/sun/star/lang/DisposedException.hpp>
59 #include <com/sun/star/beans/XPropertySet.hpp>
60 #include <com/sun/star/frame/XFramesSupplier.hpp>
61 #include <com/sun/star/frame/XDesktop.hpp>
62 #include <com/sun/star/container/XEnumeration.hpp>
63 #include <com/sun/star/util/XStringWidth.hpp>
64 #include <com/sun/star/uno/XComponentContext.hpp>
65 #include <com/sun/star/lang/XMultiComponentFactory.hpp>
66 #include <com/sun/star/frame/XPopupMenuController.hpp>
67 #include <com/sun/star/frame/XUIControllerRegistration.hpp>
68 #ifndef _COM_SUN_STAR_LANG_XSYSTEMDEPENDENT_HPP_
69 #include <com/sun/star/lang/SystemDependent.hpp>
70 #endif
71 #include <com/sun/star/ui/ItemType.hpp>
72 #include <com/sun/star/ui/ImageType.hpp>
73 #include <com/sun/star/container/XNameAccess.hpp>
74 #include <com/sun/star/frame/XModuleManager.hpp>
75 #include <com/sun/star/ui/XModuleUIConfigurationManagerSupplier.hpp>
76 #include <com/sun/star/ui/XUIConfigurationManagerSupplier.hpp>
77 #include <com/sun/star/ui/ItemStyle.hpp>
78 #include <com/sun/star/frame/status/Visibility.hpp>
79
80 //_________________________________________________________________________________________________________________
81 // includes of other projects
82 //_________________________________________________________________________________________________________________
83 #include <comphelper/processfactory.hxx>
84 #include <comphelper/extract.hxx>
85 #include <svtools/menuoptions.hxx>
86 #include <svtools/historyoptions.hxx>
87 #include <svtools/pathoptions.hxx>
88 #include <svtools/cmdoptions.hxx>
89 #include <unotools/localfilehelper.hxx>
90 #ifndef _TOOLKIT_HELPER_VCLUNOHELPER_HXX_
91 #include <toolkit/unohlp.hxx>
92 #endif
93 #include <tools/urlobj.hxx>
94 #include <vcl/svapp.hxx>
95 #include <vcl/window.hxx>
96 #include <vos/mutex.hxx>
97 #include <vcl/svapp.hxx>
98 #include <osl/file.hxx>
99 #include <cppuhelper/implbase1.hxx>
100 #include <svtools/acceleratorexecute.hxx>
101 #include <rtl/logfile.hxx>
102 #include "svtools/miscopt.hxx"
103 #include <classes/addonmenu.hxx>
104 #include <uielement/menubarmerger.hxx>
105 #include <dispatch/uieventloghelper.hxx>
106
107 // Be careful removing this "bad" construct. There are serious problems
108 // with #define STRICT and including windows.h. Changing this needs some
109 // redesign on other projects, too. Especially sal/main.h which defines
110 // HINSTANCE depending on STRCIT!!!!!!!!!!!!!!!
111 struct SystemMenuData
112 {
113 unsigned long nSize;
114 long hMenu;
115 };
116
117 //_________________________________________________________________________________________________________________
118 // namespace
119 //_________________________________________________________________________________________________________________
120
121 using namespace ::cppu;
122 using namespace ::vos;
123 using namespace ::com::sun::star;
124 using namespace ::com::sun::star::uno;
125 using namespace ::com::sun::star::util;
126 using namespace ::com::sun::star::beans;
127 using namespace ::com::sun::star::frame;
128 using namespace ::com::sun::star::container;
129 using namespace ::com::sun::star::lang;
130 using namespace ::com::sun::star::frame;
131 using namespace ::com::sun::star::ui;
132
133 static const char ITEM_DESCRIPTOR_COMMANDURL[] = "CommandURL";
134 static const char ITEM_DESCRIPTOR_HELPURL[] = "HelpURL";
135 static const char ITEM_DESCRIPTOR_CONTAINER[] = "ItemDescriptorContainer";
136 static const char ITEM_DESCRIPTOR_LABEL[] = "Label";
137 static const char ITEM_DESCRIPTOR_TYPE[] = "Type";
138 static const char ITEM_DESCRIPTOR_MODULEIDENTIFIER[] = "ModuleIdentifier";
139 static const char ITEM_DESCRIPTOR_DISPATCHPROVIDER[] = "DispatchProvider";
140 static const char ITEM_DESCRIPTOR_STYLE[] = "Style";
141
142 const sal_Int32 LEN_DESCRIPTOR_COMMANDURL = 10;
143 const sal_Int32 LEN_DESCRIPTOR_HELPURL = 7;
144 const sal_Int32 LEN_DESCRIPTOR_CONTAINER = 23;
145 const sal_Int32 LEN_DESCRIPTOR_LABEL = 5;
146 const sal_Int32 LEN_DESCRIPTOR_TYPE = 4;
147 const sal_Int32 LEN_DESCRIPTOR_MODULEIDENTIFIER = 16;
148 const sal_Int32 LEN_DESCRIPTOR_DISPATCHPROVIDER = 16;
149 static const sal_Int32 ITEM_DESCRIPTOR_STYLE_LEN = 5;
150
151 const sal_uInt16 ADDONMENU_MERGE_ITEMID_START = 1500;
152
153 class StringLength : public ::cppu::WeakImplHelper1< ::com::sun::star::util::XStringWidth >
154 {
155 public:
156 StringLength() {}
157 virtual ~StringLength() {}
158
159 // XStringWidth
160 sal_Int32 SAL_CALL queryStringWidth( const ::rtl::OUString& aString )
161 throw (RuntimeException)
162 {
163 return aString.getLength();
164 }
165 };
166
167 namespace framework
168 {
169
170 // special menu ids/command ids for dynamic popup menus
171 #define SID_SFX_START 5000
172 #define SID_NEWDOCDIRECT (SID_SFX_START + 537)
173 #define SID_AUTOPILOTMENU (SID_SFX_START + 1381)
174 #define SID_PICKLIST (SID_SFX_START + 510)
175 #define SID_MDIWINDOWLIST (SID_SFX_START + 610)
176 #define SID_ADDONLIST (SID_SFX_START + 1677)
177 #define SID_HELPMENU (SID_SFX_START + 410)
178
179 #define SFX_REFERER_USER "private:user"
180
181 const ::rtl::OUString aCmdHelpIndex( RTL_CONSTASCII_USTRINGPARAM( ".uno:HelpIndex" ));
182 const ::rtl::OUString aCmdToolsMenu( RTL_CONSTASCII_USTRINGPARAM( ".uno:ToolsMenu" ));
183 const ::rtl::OUString aCmdHelpMenu( RTL_CONSTASCII_USTRINGPARAM( ".uno:HelpMenu" ));
184 const ::rtl::OUString aSlotHelpMenu( RTL_CONSTASCII_USTRINGPARAM( "slot:5410" ));
185
186 const ::rtl::OUString aSpecialFileMenu( RTL_CONSTASCII_USTRINGPARAM( "file" ));
187 const ::rtl::OUString aSpecialWindowMenu( RTL_CONSTASCII_USTRINGPARAM( "window" ));
188 const ::rtl::OUString aSlotSpecialFileMenu( RTL_CONSTASCII_USTRINGPARAM( "slot:5510" ));
189 const ::rtl::OUString aSlotSpecialWindowMenu( RTL_CONSTASCII_USTRINGPARAM( "slot:5610" ));
190 const ::rtl::OUString aSlotSpecialToolsMenu( RTL_CONSTASCII_USTRINGPARAM( "slot:6677" ));
191
192 // special uno commands for picklist and window list
193 const ::rtl::OUString aSpecialFileCommand( RTL_CONSTASCII_USTRINGPARAM( ".uno:PickList" ));
194 const ::rtl::OUString aSpecialWindowCommand( RTL_CONSTASCII_USTRINGPARAM( ".uno:WindowList" ));
195
196 const ::rtl::OUString UNO_COMMAND( RTL_CONSTASCII_USTRINGPARAM( ".uno:" ));
197
198 static sal_Int16 getImageTypeFromBools( sal_Bool bBig, sal_Bool bHighContrast )
199 {
200 sal_Int16 n( 0 );
201 if ( bBig )
202 n |= ::com::sun::star::ui::ImageType::SIZE_LARGE;
203 if ( bHighContrast )
204 n |= ::com::sun::star::ui::ImageType::COLOR_HIGHCONTRAST;
205 return n;
206 }
207
208 // #110897#
209 MenuBarManager::MenuBarManager(
210 const Reference< XMultiServiceFactory >& xServiceFactory,
211 const Reference< XFrame >& rFrame,
212 const Reference< XURLTransformer >& _xURLTransformer,
213 const Reference< XDispatchProvider >& rDispatchProvider,
214 const rtl::OUString& rModuleIdentifier,
215 Menu* pMenu, sal_Bool bDelete, sal_Bool bDeleteChildren )
216 : ThreadHelpBase( &Application::GetSolarMutex() ), OWeakObject()
217 , m_bDisposed( sal_False )
218 , m_bRetrieveImages( sal_False )
219 , m_bAcceleratorCfg( sal_False )
220 , m_bModuleIdentified( sal_False )
221 , m_aListenerContainer( m_aLock.getShareableOslMutex() )
222 , mxServiceFactory(xServiceFactory)
223 , m_xURLTransformer(_xURLTransformer)
224 , m_nSymbolsStyle( SvtMiscOptions().GetCurrentSymbolsStyle() )
225 {
226 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "framework", "Ocke.Janssen@sun.com", "MenuBarManager::MenuBarManager" );
227 m_xPopupMenuControllerRegistration = Reference< ::com::sun::star::frame::XUIControllerRegistration >(
228 getServiceFactory()->createInstance( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.frame.PopupMenuControllerFactory" ))),
229 UNO_QUERY );
230 FillMenuManager( pMenu, rFrame, rDispatchProvider, rModuleIdentifier, bDelete, bDeleteChildren );
231 }
232
233 // #110897#
234 MenuBarManager::MenuBarManager(
235 const Reference< XMultiServiceFactory >& xServiceFactory,
236 const Reference< XFrame >& rFrame,
237 const Reference< XURLTransformer >& _xURLTransformer,
238 AddonMenu* pAddonMenu,
239 sal_Bool bDelete,
240 sal_Bool bDeleteChildren )
241 : ThreadHelpBase( &Application::GetSolarMutex() )
242 , OWeakObject()
243 , m_bDisposed( sal_False )
244 , m_bRetrieveImages( sal_True )
245 , m_bAcceleratorCfg( sal_False )
246 , m_bModuleIdentified( sal_False )
247 , m_aListenerContainer( m_aLock.getShareableOslMutex() )
248 , mxServiceFactory(xServiceFactory)
249 , m_xURLTransformer(_xURLTransformer)
250 , m_nSymbolsStyle( SvtMiscOptions().GetCurrentSymbolsStyle() )
251 {
252 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "framework", "Ocke.Janssen@sun.com", "MenuBarManager::MenuBarManager" );
253 Init(rFrame,pAddonMenu,bDelete,bDeleteChildren);
254 }
255
256 // #110897#
257 MenuBarManager::MenuBarManager(
258 const Reference< XMultiServiceFactory >& xServiceFactory,
259 const Reference< XFrame >& rFrame,
260 const Reference< XURLTransformer >& _xURLTransformer,
261 AddonPopupMenu* pAddonPopupMenu,
262 sal_Bool bDelete,
263 sal_Bool bDeleteChildren )
264 : ThreadHelpBase( &Application::GetSolarMutex() )
265 , OWeakObject()
266 , m_bDisposed( sal_False )
267 , m_bRetrieveImages( sal_True )
268 , m_bAcceleratorCfg( sal_False )
269 , m_bModuleIdentified( sal_False )
270 , m_aListenerContainer( m_aLock.getShareableOslMutex() )
271 , mxServiceFactory(xServiceFactory)
272 , m_xURLTransformer(_xURLTransformer)
273 , m_nSymbolsStyle( SvtMiscOptions().GetCurrentSymbolsStyle() )
274 {
275 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "framework", "Ocke.Janssen@sun.com", "MenuBarManager::MenuBarManager" );
276 Init(rFrame,pAddonPopupMenu,bDelete,bDeleteChildren,true);
277 }
278
279 Any SAL_CALL MenuBarManager::queryInterface( const Type & rType ) throw ( RuntimeException )
280 {
281 Any a = ::cppu::queryInterface(
282 rType ,
283 SAL_STATIC_CAST( ::com::sun::star::frame::XStatusListener*, this ),
284 SAL_STATIC_CAST( ::com::sun::star::frame::XFrameActionListener*, this ),
285 SAL_STATIC_CAST( ::com::sun::star::ui::XUIConfigurationListener*, this ),
286 SAL_STATIC_CAST( XEventListener*, (XStatusListener *)this ),
287 SAL_STATIC_CAST( XComponent*, this ),
288 SAL_STATIC_CAST( ::com::sun::star::awt::XSystemDependentMenuPeer*, this ));
289
290 if ( a.hasValue() )
291 return a;
292
293 return OWeakObject::queryInterface( rType );
294 }
295
296
297 void SAL_CALL MenuBarManager::acquire() throw()
298 {
299 OWeakObject::acquire();
300 }
301
302
303 void SAL_CALL MenuBarManager::release() throw()
304 {
305 OWeakObject::release();
306 }
307
308
309 Any SAL_CALL MenuBarManager::getMenuHandle( const Sequence< sal_Int8 >& /*ProcessId*/, sal_Int16 SystemType ) throw (RuntimeException)
310 {
311 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "framework", "Ocke.Janssen@sun.com", "MenuBarManager::getMenuHandle" );
312 ResetableGuard aGuard( m_aLock );
313
314 if ( m_bDisposed )
315 throw com::sun::star::lang::DisposedException();
316
317 Any a;
318
319 if ( m_pVCLMenu )
320 {
321 OGuard aSolarGuard( Application::GetSolarMutex() );
322
323 SystemMenuData aSystemMenuData;
324 aSystemMenuData.nSize = sizeof( SystemMenuData );
325
326 m_pVCLMenu->GetSystemMenuData( &aSystemMenuData );
327 #ifdef QUARTZ
328 if( SystemType == SystemDependent::SYSTEM_MAC )
329 {
330 }
331 #elif (defined WNT)
332 if( SystemType == SystemDependent::SYSTEM_WIN32 )
333 {
334 a <<= (long) aSystemMenuData.hMenu;
335 }
336 #elif (defined UNX)
337 if( SystemType == SystemDependent::SYSTEM_XWINDOW )
338 {
339 }
340 #endif
341 }
342
343 return a;
344 }
345
346 MenuBarManager::~MenuBarManager()
347 {
348 // stop asynchronous settings timer
349 m_xDeferedItemContainer.clear();
350 m_aAsyncSettingsTimer.Stop();
351
352 DBG_ASSERT( OWeakObject::m_refCount == 0, "Who wants to delete an object with refcount > 0!" );
353 }
354
355 void MenuBarManager::Destroy()
356 {
357 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "framework", "Ocke.Janssen@sun.com", "MenuBarManager::Destroy" );
358 OGuard aGuard( Application::GetSolarMutex() );
359
360 if ( !m_bDisposed )
361 {
362 // stop asynchronous settings timer and
363 // release defered item container reference
364 m_aAsyncSettingsTimer.Stop();
365 m_xDeferedItemContainer.clear();
366 RemoveListener();
367
368 std::vector< MenuItemHandler* >::iterator p;
369 for ( p = m_aMenuItemHandlerVector.begin(); p != m_aMenuItemHandlerVector.end(); p++ )
370 {
371 MenuItemHandler* pItemHandler = *p;
372 pItemHandler->xMenuItemDispatch.clear();
373 pItemHandler->xSubMenuManager.clear();
374 pItemHandler->xPopupMenu.clear();
375 delete pItemHandler;
376 }
377 m_aMenuItemHandlerVector.clear();
378
379 if ( m_bDeleteMenu )
380 {
381 delete m_pVCLMenu;
382 m_pVCLMenu = 0;
383 }
384 }
385 }
386
387 // XComponent
388 void SAL_CALL MenuBarManager::dispose() throw( RuntimeException )
389 {
390 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "framework", "Ocke.Janssen@sun.com", "MenuBarManager::dispose" );
391 Reference< XComponent > xThis( static_cast< OWeakObject* >(this), UNO_QUERY );
392
393 EventObject aEvent( xThis );
394 m_aListenerContainer.disposeAndClear( aEvent );
395
396 {
397 ResetableGuard aGuard( m_aLock );
398 // RemoveListener();
399 Destroy();
400 m_bDisposed = sal_True;
401
402 if ( m_xDocImageManager.is() )
403 {
404 try
405 {
406 m_xDocImageManager->removeConfigurationListener(
407 Reference< XUIConfigurationListener >(
408 static_cast< OWeakObject* >( this ), UNO_QUERY ));
409 }
410 catch ( Exception& )
411 {
412 }
413 }
414 if ( m_xModuleImageManager.is() )
415 {
416 try
417 {
418 m_xModuleImageManager->removeConfigurationListener(
419 Reference< XUIConfigurationListener >(
420 static_cast< OWeakObject* >( this ), UNO_QUERY ));
421 }
422 catch ( Exception& )
423 {
424 }
425 }
426 m_xDocImageManager.clear();
427 m_xModuleImageManager.clear();
428 m_xGlobalAcceleratorManager.clear();
429 m_xModuleAcceleratorManager.clear();
430 m_xDocAcceleratorManager.clear();
431 m_xUICommandLabels.clear();
432 m_xPopupMenuControllerRegistration.clear();
433 mxServiceFactory.clear();
434 }
435 }
436
437 void SAL_CALL MenuBarManager::addEventListener( const Reference< XEventListener >& xListener ) throw( RuntimeException )
438 {
439 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "framework", "Ocke.Janssen@sun.com", "MenuBarManager::addEventListener" );
440 ResetableGuard aGuard( m_aLock );
441
442 /* SAFE AREA ----------------------------------------------------------------------------------------------- */
443 if ( m_bDisposed )
444 throw DisposedException();
445
446 m_aListenerContainer.addInterface( ::getCppuType( ( const Reference< XEventListener >* ) NULL ), xListener );
447 }
448
449 void SAL_CALL MenuBarManager::removeEventListener( const Reference< XEventListener >& xListener ) throw( RuntimeException )
450 {
451 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "framework", "Ocke.Janssen@sun.com", "MenuBarManager::removeEventListener" );
452 ResetableGuard aGuard( m_aLock );
453 /* SAFE AREA ----------------------------------------------------------------------------------------------- */
454 m_aListenerContainer.removeInterface( ::getCppuType( ( const Reference< XEventListener >* ) NULL ), xListener );
455 }
456
457 void SAL_CALL MenuBarManager::elementInserted( const ::com::sun::star::ui::ConfigurationEvent& Event )
458 throw (RuntimeException)
459 {
460 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "framework", "Ocke.Janssen@sun.com", "MenuBarManager::elementInserted" );
461 ResetableGuard aGuard( m_aLock );
462
463 /* SAFE AREA ----------------------------------------------------------------------------------------------- */
464 if ( m_bDisposed )
465 return;
466
467 sal_Int16 nImageType = sal_Int16();
468 sal_Int16 nCurrentImageType = getImageTypeFromBools( sal_False, m_bWasHiContrast );
469 if (( Event.aInfo >>= nImageType ) &&
470 ( nImageType == nCurrentImageType ))
471 RequestImages();
472 }
473
474 void SAL_CALL MenuBarManager::elementRemoved( const ::com::sun::star::ui::ConfigurationEvent& Event )
475 throw (RuntimeException)
476 {
477 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "framework", "Ocke.Janssen@sun.com", "MenuBarManager::elementRemoved" );
478 elementInserted(Event);
479 }
480
481 void SAL_CALL MenuBarManager::elementReplaced( const ::com::sun::star::ui::ConfigurationEvent& Event )
482 throw (RuntimeException)
483 {
484 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "framework", "Ocke.Janssen@sun.com", "MenuBarManager::elementReplaced" );
485 elementInserted(Event);
486 }
487
488 // XFrameActionListener
489 void SAL_CALL MenuBarManager::frameAction( const FrameActionEvent& Action )
490 throw ( RuntimeException )
491 {
492 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "framework", "Ocke.Janssen@sun.com", "MenuBarManager::frameAction" );
493 ResetableGuard aGuard( m_aLock );
494
495 if ( m_bDisposed )
496 throw com::sun::star::lang::DisposedException();
497
498 if ( Action.Action == FrameAction_CONTEXT_CHANGED )
499 {
500 std::vector< MenuItemHandler* >::iterator p;
501 for ( p = m_aMenuItemHandlerVector.begin(); p != m_aMenuItemHandlerVector.end(); p++ )
502 {
503 // Clear dispatch reference as we will requery it later o
504 MenuItemHandler* pItemHandler = *p;
505 pItemHandler->xMenuItemDispatch.clear();
506 }
507 }
508 }
509
510 // XStatusListener
511 void SAL_CALL MenuBarManager::statusChanged( const FeatureStateEvent& Event )
512 throw ( RuntimeException )
513 {
514 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "framework", "Ocke.Janssen@sun.com", "MenuBarManager::statusChanged" );
515 ::rtl::OUString aFeatureURL = Event.FeatureURL.Complete;
516
517 OGuard aSolarGuard( Application::GetSolarMutex() );
518 {
519 ResetableGuard aGuard( m_aLock );
520
521 if ( m_bDisposed )
522 return;
523
524 // We have to check all menu entries as there can be identical entries in a popup menu.
525 std::vector< MenuItemHandler* >::iterator p;
526 for ( p = m_aMenuItemHandlerVector.begin(); p != m_aMenuItemHandlerVector.end(); p++ )
527 {
528 MenuItemHandler* pMenuItemHandler = *p;
529 if ( pMenuItemHandler->aMenuItemURL == aFeatureURL )
530 {
531 sal_Bool bCheckmark( sal_False );
532 sal_Bool bMenuItemEnabled( m_pVCLMenu->IsItemEnabled( pMenuItemHandler->nItemId ));
533 sal_Bool bEnabledItem( Event.IsEnabled );
534 rtl::OUString aItemText;
535 status::Visibility aVisibilityStatus;
536
537 #ifdef UNIX
538 // #b6673979# enable some slots hardly, because UNIX clipboard does not notify all changes
539 // Can be removed if follow up task will be fixed directly within applications.
540 if (
541 ( pMenuItemHandler->aMenuItemURL.equalsAscii (".uno:Paste" ) ) ||
542 ( pMenuItemHandler->aMenuItemURL.equalsAscii (".uno:PasteSpecial" ) ) ||
543 ( pMenuItemHandler->aMenuItemURL.equalsAscii (".uno:PasteClipboard") ) // special for draw/impress
544 )
545 bEnabledItem = sal_True;
546 #endif
547
548 // Enable/disable item
549 if ( bEnabledItem != bMenuItemEnabled )
550 m_pVCLMenu->EnableItem( pMenuItemHandler->nItemId, bEnabledItem );
551
552 if ( Event.State >>= bCheckmark )
553 {
554 // Checkmark
555 m_pVCLMenu->ShowItem( pMenuItemHandler->nItemId, TRUE );
556 m_pVCLMenu->CheckItem( pMenuItemHandler->nItemId, bCheckmark );
557 m_pVCLMenu->SetItemBits( pMenuItemHandler->nItemId,
558 m_pVCLMenu->GetItemBits( pMenuItemHandler->nItemId ) | MIB_CHECKABLE );
559 }
560 else if ( Event.State >>= aItemText )
561 {
562 // Replacement for place holders
563 if ( aItemText.matchAsciiL( "($1)", 4 ))
564 {
565 String aResStr = String( FwkResId( STR_UPDATEDOC ));
566 rtl::OUString aTmp( aResStr );
567 aTmp += rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( " " ));
568 aTmp += aItemText.copy( 4 );
569 aItemText = aTmp;
570 }
571 else if ( aItemText.matchAsciiL( "($2)", 4 ))
572 {
573 String aResStr = String( FwkResId( STR_CLOSEDOC_ANDRETURN ));
574 rtl::OUString aTmp( aResStr );
575 aTmp += aItemText.copy( 4 );
576 aItemText = aTmp;
577 }
578 else if ( aItemText.matchAsciiL( "($3)", 4 ))
579 {
580 String aResStr = String( FwkResId( STR_SAVECOPYDOC ));
581 rtl::OUString aTmp( aResStr );
582 aTmp += aItemText.copy( 4 );
583 aItemText = aTmp;
584 }
585
586 m_pVCLMenu->ShowItem( pMenuItemHandler->nItemId, TRUE );
587 m_pVCLMenu->SetItemText( pMenuItemHandler->nItemId, aItemText );
588 }
589 else if ( Event.State >>= aVisibilityStatus )
590 {
591 // Visibility
592 m_pVCLMenu->ShowItem( pMenuItemHandler->nItemId, aVisibilityStatus.bVisible );
593 }
594 else
595 m_pVCLMenu->ShowItem( pMenuItemHandler->nItemId, TRUE );
596 }
597
598 if ( Event.Requery )
599 {
600 // Release dispatch object - will be requeried on the next activate!
601 pMenuItemHandler->xMenuItemDispatch.clear();
602 }
603 }
604 }
605 }
606
607 // Helper to retrieve own structure from item ID
608 MenuBarManager::MenuItemHandler* MenuBarManager::GetMenuItemHandler( USHORT nItemId )
609 {
610 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "framework", "Ocke.Janssen@sun.com", "MenuBarManager::GetMenuItemHandler" );
611 ResetableGuard aGuard( m_aLock );
612
613 std::vector< MenuItemHandler* >::iterator p;
614 for ( p = m_aMenuItemHandlerVector.begin(); p != m_aMenuItemHandlerVector.end(); p++ )
615 {
616 MenuItemHandler* pItemHandler = *p;
617 if ( pItemHandler->nItemId == nItemId )
618 return pItemHandler;
619 }
620
621 return 0;
622 }
623
624 // Helper to set request images flag
625 void MenuBarManager::RequestImages()
626 {
627 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "framework", "Ocke.Janssen@sun.com", "MenuBarManager::RequestImages" );
628 // must be locked from callee
629 // ResetableGuard aGuard( m_aLock );
630
631 m_bRetrieveImages = sal_True;
632 const sal_uInt32 nCount = m_aMenuItemHandlerVector.size();
633 for ( sal_uInt32 i = 0; i < nCount; ++i )
634 {
635 MenuItemHandler* pItemHandler = m_aMenuItemHandlerVector[i];
636 if ( pItemHandler->xSubMenuManager.is() )
637 {
638 MenuBarManager* pMenuBarManager = (MenuBarManager*)(pItemHandler->xSubMenuManager.get());
639 pMenuBarManager->RequestImages();
640 }
641 }
642 }
643
644 // Helper to reset objects to prepare shutdown
645 void MenuBarManager::RemoveListener()
646 {
647 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "framework", "Ocke.Janssen@sun.com", "MenuBarManager::RemoveListener" );
648 ResetableGuard aGuard( m_aLock );
649
650 // Check service manager reference. Remove listener can be called due
651 // to a disposing call from the frame and therefore we already removed
652 // our listeners and release the service manager reference!
653 Reference< XMultiServiceFactory > xServiceManager = getServiceFactory();
654 if ( xServiceManager.is() )
655 {
656 std::vector< MenuItemHandler* >::iterator p;
657 for ( p = m_aMenuItemHandlerVector.begin(); p != m_aMenuItemHandlerVector.end(); p++ )
658 {
659 MenuItemHandler* pItemHandler = *p;
660 if ( pItemHandler->xMenuItemDispatch.is() )
661 {
662 URL aTargetURL;
663 aTargetURL.Complete = pItemHandler->aMenuItemURL;
664 m_xURLTransformer->parseStrict( aTargetURL );
665
666 pItemHandler->xMenuItemDispatch->removeStatusListener(
667 static_cast< XStatusListener* >( this ), aTargetURL );
668 }
669
670 pItemHandler->xMenuItemDispatch.clear();
671 if ( pItemHandler->xPopupMenu.is() )
672 {
673 {
674 // Remove popup menu from menu structure
675 OGuard aGuard2( Application::GetSolarMutex() );
676 m_pVCLMenu->SetPopupMenu( pItemHandler->nItemId, 0 );
677 }
678
679 Reference< com::sun::star::lang::XEventListener > xEventListener( pItemHandler->xPopupMenuController, UNO_QUERY );
680 if ( xEventListener.is() )
681 {
682 EventObject aEventObject;
683 aEventObject.Source = (OWeakObject *)this;
684 xEventListener->disposing( aEventObject );
685 }
686
687 // We now provide a popup menu controller to external code.
688 // Therefore the life-time must be explicitly handled via
689 // dispose!!
690 try
691 {
692 Reference< XComponent > xComponent( pItemHandler->xPopupMenuController, UNO_QUERY );
693 if ( xComponent.is() )
694 xComponent->dispose();
695 }
696 catch ( RuntimeException& )
697 {
698 throw;
699 }
700 catch ( Exception& )
701 {
702 }
703
704 // Release references to controller and popup menu
705 pItemHandler->xPopupMenuController.clear();
706 pItemHandler->xPopupMenu.clear();
707 }
708
709 Reference< XComponent > xComponent( pItemHandler->xSubMenuManager, UNO_QUERY );
710 if ( xComponent.is() )
711 xComponent->dispose();
712 }
713 }
714
715 try
716 {
717 if ( m_xFrame.is() )
718 m_xFrame->removeFrameActionListener( Reference< XFrameActionListener >(
719 static_cast< OWeakObject* >( this ), UNO_QUERY ));
720 }
721 catch ( Exception& )
722 {
723 }
724
725 m_xFrame = 0;
726 }
727
728 void SAL_CALL MenuBarManager::disposing( const EventObject& Source ) throw ( RuntimeException )
729 {
730 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "framework", "Ocke.Janssen@sun.com", "MenuBarManager::disposing(evt)" );
731 MenuItemHandler* pMenuItemDisposing = NULL;
732
733 ResetableGuard aGuard( m_aLock );
734
735 std::vector< MenuItemHandler* >::iterator p;
736 for ( p = m_aMenuItemHandlerVector.begin(); p != m_aMenuItemHandlerVector.end(); p++ )
737 {
738 MenuItemHandler* pMenuItemHandler = *p;
739 if ( pMenuItemHandler->xMenuItemDispatch.is() &&
740 pMenuItemHandler->xMenuItemDispatch == Source.Source )
741 {
742 // disposing called from menu item dispatcher, remove listener
743 pMenuItemDisposing = pMenuItemHandler;
744 break;
745 }
746 }
747
748 if ( pMenuItemDisposing )
749 {
750 // Release references to the dispatch object
751 URL aTargetURL;
752 aTargetURL.Complete = pMenuItemDisposing->aMenuItemURL;
753
754 // Check reference of service manager before we use it. Reference could
755 // be cleared due to RemoveListener call!
756 Reference< XMultiServiceFactory > xServiceManager( getServiceFactory() );
757 if ( xServiceManager.is() )
758 {
759 m_xURLTransformer->parseStrict( aTargetURL );
760
761 pMenuItemDisposing->xMenuItemDispatch->removeStatusListener(
762 static_cast< XStatusListener* >( this ), aTargetURL );
763 pMenuItemDisposing->xMenuItemDispatch = Reference< XDispatch >();
764 if ( pMenuItemDisposing->xPopupMenu.is() )
765 {
766 Reference< com::sun::star::lang::XEventListener > xEventListener( pMenuItemDisposing->xPopupMenuController, UNO_QUERY );
767 if ( xEventListener.is() )
768 xEventListener->disposing( Source );
769
770 {
771 // Remove popup menu from menu structure as we release our reference to
772 // the controller.
773 OGuard aGuard2( Application::GetSolarMutex() );
774 m_pVCLMenu->SetPopupMenu( pMenuItemDisposing->nItemId, 0 );
775 }
776
777 pMenuItemDisposing->xPopupMenuController.clear();
778 pMenuItemDisposing->xPopupMenu.clear();
779 }
780 }
781 return;
782 }
783 else if ( Source.Source == m_xFrame )
784 {
785 // Our frame gets disposed. We have to remove all our listeners
786 RemoveListener();
787 }
788 else if ( Source.Source == Reference< XInterface >( m_xDocImageManager, UNO_QUERY ))
789 m_xDocImageManager.clear();
790 else if ( Source.Source == Reference< XInterface >( m_xModuleImageManager, UNO_QUERY ))
791 m_xModuleImageManager.clear();
792 }
793
794
795 void MenuBarManager::CheckAndAddMenuExtension( Menu* pMenu )
796 {
797 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "framework", "Ocke.Janssen@sun.com", "MenuBarManager::CheckAndAddMenuExtension" );
798 static const char REFERENCECOMMAND_AFTER[] = ".uno:OnlineRegistrationDlg";
799 static const char REFERENCECOMMAND_BEFORE[] = ".uno:About";
800
801 // retrieve menu extension item
802 MenuExtensionItem aMenuItem( GetMenuExtension() );
803 if (( aMenuItem.aURL.getLength() > 0 ) &&
804 ( aMenuItem.aLabel.getLength() > 0 ))
805 {
806 // remove all old window list entries from menu
807 sal_uInt16 nNewItemId( 0 );
808 sal_uInt16 nInsertPos( MENU_APPEND );
809 sal_uInt16 nAfterPos( MENU_APPEND );
810 sal_uInt16 nBeforePos( MENU_APPEND );
811 String aCommandAfter( String::CreateFromAscii ( REFERENCECOMMAND_AFTER ));
812 String aCommandBefore( String::CreateFromAscii ( REFERENCECOMMAND_BEFORE ));
813 for ( sal_uInt16 n = 0; n < pMenu->GetItemCount(); n++ )
814 {
815 sal_uInt16 nItemId = pMenu->GetItemId( n );
816 nNewItemId = std::max( nItemId, nNewItemId );
817 if ( pMenu->GetItemCommand( nItemId ) == aCommandAfter )
818 nAfterPos = n+1;
819 else if ( pMenu->GetItemCommand( nItemId ) == aCommandBefore )
820 nBeforePos = n;
821 }
822 ++nNewItemId;
823
824 if ( nAfterPos != MENU_APPEND )
825 nInsertPos = nAfterPos;
826 else if ( nBeforePos != MENU_APPEND )
827 nInsertPos = nBeforePos;
828
829 pMenu->InsertItem( nNewItemId, aMenuItem.aLabel, 0, nInsertPos );
830 pMenu->SetItemCommand( nNewItemId, aMenuItem.aURL );
831 }
832 }
833
834 static void lcl_CheckForChildren(Menu* pMenu, USHORT nItemId)
835 {
836 if (PopupMenu* pThisPopup = pMenu->GetPopupMenu( nItemId ))
837 pMenu->EnableItem( nItemId, pThisPopup->GetItemCount() ? true : false );
838 }
839
840 //_________________________________________________________________________________________________________________
841 // vcl handler
842 //_________________________________________________________________________________________________________________
843
844 IMPL_LINK( MenuBarManager, Activate, Menu *, pMenu )
845 {
846 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "framework", "Ocke.Janssen@sun.com", "MenuBarManager::Activate" );
847 if ( pMenu == m_pVCLMenu )
848 {
849 // set/unset hiding disabled menu entries
850 sal_Bool bDontHide = SvtMenuOptions().IsEntryHidingEnabled();
851 const StyleSettings& rSettings = Application::GetSettings().GetStyleSettings();
852 sal_Bool bShowMenuImages = rSettings.GetUseImagesInMenus();
853 sal_Bool bHasDisabledEntries = SvtCommandOptions().HasEntries( SvtCommandOptions::CMDOPTION_DISABLED );
854
855 ResetableGuard aGuard( m_aLock );
856
857 sal_uInt16 nFlag = pMenu->GetMenuFlags();
858 if ( bDontHide )
859 nFlag &= ~MENU_FLAG_HIDEDISABLEDENTRIES;
860 else
861 nFlag |= MENU_FLAG_HIDEDISABLEDENTRIES;
862 pMenu->SetMenuFlags( nFlag );
863
864 if ( m_bActive )
865 return 0;
866
867 m_bActive = TRUE;
868
869 ::rtl::OUString aMenuCommand( m_aMenuItemCommand );
870 if ( m_aMenuItemCommand == aSpecialWindowMenu ||
871 m_aMenuItemCommand == aSlotSpecialWindowMenu ||
872 aMenuCommand == aSpecialWindowCommand )
873 MenuManager::UpdateSpecialWindowMenu( pMenu,getServiceFactory(),m_aLock );
874
875 // Check if some modes have changed so we have to update our menu images
876 sal_Bool bIsHiContrast = rSettings.GetHighContrastMode();
877 sal_Int16 nSymbolsStyle = SvtMiscOptions().GetCurrentSymbolsStyle();
878
879 if ( m_bRetrieveImages ||
880 m_bWasHiContrast != bIsHiContrast ||
881 bShowMenuImages != m_bShowMenuImages ||
882 nSymbolsStyle != m_nSymbolsStyle )
883 {
884 // The mode changed so we have to replace all images
885 m_bWasHiContrast = bIsHiContrast;
886 m_bShowMenuImages = bShowMenuImages;
887 m_bRetrieveImages = sal_False;
888 m_nSymbolsStyle = nSymbolsStyle;
889 MenuManager::FillMenuImages(m_xFrame,pMenu,bIsHiContrast,bShowMenuImages);
890 }
891
892 // Try to map commands to labels
893 for ( USHORT nPos = 0; nPos < pMenu->GetItemCount(); nPos++ )
894 {
895 USHORT nItemId = pMenu->GetItemId( nPos );
896 if (( pMenu->GetItemType( nPos ) != MENUITEM_SEPARATOR ) &&
897 ( pMenu->GetItemText( nItemId ).Len() == 0 ))
898 {
899 String aCommand = pMenu->GetItemCommand( nItemId );
900 if ( aCommand.Len() > 0 )
901 pMenu->SetItemText( nItemId, RetrieveLabelFromCommand( aCommand ));
902 }
903 }
904
905 // Try to set accelerator keys
906 {
907 RetrieveShortcuts( m_aMenuItemHandlerVector );
908 std::vector< MenuItemHandler* >::iterator p;
909 for ( p = m_aMenuItemHandlerVector.begin(); p != m_aMenuItemHandlerVector.end(); p++ )
910 {
911 MenuItemHandler* pMenuItemHandler = *p;
912
913 // Set key code, workaround for hard-coded shortcut F1 mapped to .uno:HelpIndex
914 // Only non-popup menu items can have a short-cut
915 if ( pMenuItemHandler->aMenuItemURL == aCmdHelpIndex )
916 {
917 KeyCode aKeyCode( KEY_F1 );
918 pMenu->SetAccelKey( pMenuItemHandler->nItemId, aKeyCode );
919 }
920 else if ( pMenu->GetPopupMenu( pMenuItemHandler->nItemId ) == 0 )
921 pMenu->SetAccelKey( pMenuItemHandler->nItemId, pMenuItemHandler->aKeyCode );
922 }
923 }
924
925 URL aTargetURL;
926
927 // Use provided dispatch provider => fallback to frame as dispatch provider
928 Reference< XDispatchProvider > xDispatchProvider;
929 if ( m_xDispatchProvider.is() )
930 xDispatchProvider = m_xDispatchProvider;
931 else
932 xDispatchProvider = Reference< XDispatchProvider >( m_xFrame, UNO_QUERY );
933
934 if ( xDispatchProvider.is() )
935 {
936 KeyCode aEmptyKeyCode;
937 SvtCommandOptions aCmdOptions;
938 std::vector< MenuItemHandler* >::iterator p;
939 for ( p = m_aMenuItemHandlerVector.begin(); p != m_aMenuItemHandlerVector.end(); p++ )
940 {
941 MenuItemHandler* pMenuItemHandler = *p;
942 if ( pMenuItemHandler )
943 {
944 if ( !pMenuItemHandler->xMenuItemDispatch.is() &&
945 !pMenuItemHandler->xSubMenuManager.is() )
946 {
947 // There is no dispatch mechanism for the special window list menu items,
948 // because they are handled directly through XFrame->activate!!!
949 // Don't update dispatches for special file menu items.
950 if ( !(( pMenuItemHandler->nItemId >= START_ITEMID_WINDOWLIST &&
951 pMenuItemHandler->nItemId < END_ITEMID_WINDOWLIST )))
952 {
953 Reference< XDispatch > xMenuItemDispatch;
954
955 ::rtl::OUString aItemCommand = pMenu->GetItemCommand( pMenuItemHandler->nItemId );
956 if ( !aItemCommand.getLength() )
957 {
958 aItemCommand = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "slot:" ));
959 aItemCommand += ::rtl::OUString::valueOf( (sal_Int32)pMenuItemHandler->nItemId );
960 pMenu->SetItemCommand( pMenuItemHandler->nItemId, aItemCommand );
961 }
962
963 aTargetURL.Complete = aItemCommand;
964
965 m_xURLTransformer->parseStrict( aTargetURL );
966
967 if ( bHasDisabledEntries )
968 {
969 if ( aCmdOptions.Lookup( SvtCommandOptions::CMDOPTION_DISABLED, aTargetURL.Path ))
970 pMenu->HideItem( pMenuItemHandler->nItemId );
971 }
972
973 if ( m_bIsBookmarkMenu )
974 xMenuItemDispatch = xDispatchProvider->queryDispatch( aTargetURL, pMenuItemHandler->aTargetFrame, 0 );
975 else
976 xMenuItemDispatch = xDispatchProvider->queryDispatch( aTargetURL, ::rtl::OUString(), 0 );
977
978 sal_Bool bPopupMenu( sal_False );
979 if ( !pMenuItemHandler->xPopupMenuController.is() &&
980 m_xPopupMenuControllerRegistration->hasController( aItemCommand, rtl::OUString() ))
981 {
982 bPopupMenu = CreatePopupMenuController( pMenuItemHandler );
983 }
984 else if ( pMenuItemHandler->xPopupMenuController.is() )
985 {
986 // Force update of popup menu
987 pMenuItemHandler->xPopupMenuController->updatePopupMenu();
988 bPopupMenu = sal_True;
989 if (PopupMenu* pThisPopup = pMenu->GetPopupMenu( pMenuItemHandler->nItemId ))
990 pMenu->EnableItem( pMenuItemHandler->nItemId, pThisPopup->GetItemCount() ? true : false );
991 }
992
993 lcl_CheckForChildren(pMenu, pMenuItemHandler->nItemId);
994
995 if ( xMenuItemDispatch.is() )
996 {
997 pMenuItemHandler->xMenuItemDispatch = xMenuItemDispatch;
998 pMenuItemHandler->aMenuItemURL = aTargetURL.Complete;
999
1000 if ( !bPopupMenu )
1001 {
1002 // We need only an update to reflect the current state
1003 xMenuItemDispatch->addStatusListener( static_cast< XStatusListener* >( this ), aTargetURL );
1004 xMenuItemDispatch->removeStatusListener( static_cast< XStatusListener* >( this ), aTargetURL );
1005 }
1006 }
1007 else if ( !bPopupMenu )
1008 pMenu->EnableItem( pMenuItemHandler->nItemId, sal_False );
1009 }
1010 }
1011 else if ( pMenuItemHandler->xPopupMenuController.is() )
1012 {
1013 // Force update of popup menu
1014 pMenuItemHandler->xPopupMenuController->updatePopupMenu();
1015 lcl_CheckForChildren(pMenu, pMenuItemHandler->nItemId);
1016 }
1017 else if ( pMenuItemHandler->xMenuItemDispatch.is() )
1018 {
1019 // We need an update to reflect the current state
1020 try
1021 {
1022 aTargetURL.Complete = pMenuItemHandler->aMenuItemURL;
1023 m_xURLTransformer->parseStrict( aTargetURL );
1024
1025 pMenuItemHandler->xMenuItemDispatch->addStatusListener(
1026 static_cast< XStatusListener* >( this ), aTargetURL );
1027 pMenuItemHandler->xMenuItemDispatch->removeStatusListener(
1028 static_cast< XStatusListener* >( this ), aTargetURL );
1029 }
1030 catch ( Exception& )
1031 {
1032 }
1033 }
1034 else if ( pMenuItemHandler->xSubMenuManager.is() )
1035 lcl_CheckForChildren(pMenu, pMenuItemHandler->nItemId);
1036 }
1037 }
1038 }
1039 }
1040
1041 return 1;
1042 }
1043
1044
1045 IMPL_LINK( MenuBarManager, Deactivate, Menu *, pMenu )
1046 {
1047 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "framework", "Ocke.Janssen@sun.com", "MenuBarManager::Deactivate" );
1048 if ( pMenu == m_pVCLMenu )
1049 {
1050 m_bActive = sal_False;
1051 if ( pMenu->IsMenuBar() && m_xDeferedItemContainer.is() )
1052 {
1053 // Start timer to handle settings asynchronous
1054 // Changing the menu inside this handler leads to
1055 // a crash under X!
1056 m_aAsyncSettingsTimer.SetTimeoutHdl(LINK(this, MenuBarManager, AsyncSettingsHdl));
1057 m_aAsyncSettingsTimer.SetTimeout(10);
1058 m_aAsyncSettingsTimer.Start();
1059 }
1060 }
1061
1062 return 1;
1063 }
1064
1065 IMPL_LINK( MenuBarManager, AsyncSettingsHdl, Timer*,)
1066 {
1067 OGuard aGuard( Application::GetSolarMutex() );
1068 Reference< XInterface > xSelfHold(
1069 static_cast< ::cppu::OWeakObject* >( this ), UNO_QUERY_THROW );
1070
1071 m_aAsyncSettingsTimer.Stop();
1072 if ( !m_bActive && m_xDeferedItemContainer.is() )
1073 {
1074 SetItemContainer( m_xDeferedItemContainer );
1075 m_xDeferedItemContainer.clear();
1076 }
1077
1078 return 0;
1079 }
1080
1081 IMPL_LINK( MenuBarManager, Select, Menu *, pMenu )
1082 {
1083 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "framework", "Ocke.Janssen@sun.com", "MenuBarManager::Select" );
1084 URL aTargetURL;
1085 Sequence<PropertyValue> aArgs;
1086 Reference< XDispatch > xDispatch;
1087
1088 {
1089 ResetableGuard aGuard( m_aLock );
1090
1091 USHORT nCurItemId = pMenu->GetCurItemId();
1092 USHORT nCurPos = pMenu->GetItemPos( nCurItemId );
1093 if ( pMenu == m_pVCLMenu &&
1094 pMenu->GetItemType( nCurPos ) != MENUITEM_SEPARATOR )
1095 {
1096 if ( nCurItemId >= START_ITEMID_WINDOWLIST &&
1097 nCurItemId <= END_ITEMID_WINDOWLIST )
1098 {
1099 // window list menu item selected
1100
1101 // #110897#
1102 // Reference< XFramesSupplier > xDesktop( ::comphelper::getProcessServiceFactory()->createInstance( DESKTOP_SERVICE ), UNO_QUERY );
1103 Reference< XFramesSupplier > xDesktop( getServiceFactory()->createInstance( SERVICENAME_DESKTOP ), UNO_QUERY );
1104
1105 if ( xDesktop.is() )
1106 {
1107 USHORT nTaskId = START_ITEMID_WINDOWLIST;
1108 Reference< XIndexAccess > xList( xDesktop->getFrames(), UNO_QUERY );
1109 sal_Int32 nCount = xList->getCount();
1110 for ( sal_Int32 i=0; i<nCount; ++i )
1111 {
1112 Reference< XFrame > xFrame;
1113 xList->getByIndex(i) >>= xFrame;
1114 if ( xFrame.is() && nTaskId == nCurItemId )
1115 {
1116 Window* pWin = VCLUnoHelper::GetWindow( xFrame->getContainerWindow() );
1117 pWin->GrabFocus();
1118 pWin->ToTop( TOTOP_RESTOREWHENMIN );
1119 break;
1120 }
1121
1122 nTaskId++;
1123 }
1124 }
1125 }
1126 else
1127 {
1128 MenuItemHandler* pMenuItemHandler = GetMenuItemHandler( nCurItemId );
1129 if ( pMenuItemHandler && pMenuItemHandler->xMenuItemDispatch.is() )
1130 {
1131 aTargetURL.Complete = pMenuItemHandler->aMenuItemURL;
1132 m_xURLTransformer->parseStrict( aTargetURL );
1133
1134 if ( m_bIsBookmarkMenu )
1135 {
1136 // bookmark menu item selected
1137 aArgs.realloc( 1 );
1138 aArgs[0].Name = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Referer" ));
1139 aArgs[0].Value <<= ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( SFX_REFERER_USER ));
1140 }
1141
1142 xDispatch = pMenuItemHandler->xMenuItemDispatch;
1143 }
1144 }
1145 }
1146 }
1147
1148 if ( xDispatch.is() )
1149 {
1150 const sal_uInt32 nRef = Application::ReleaseSolarMutex();
1151 if(::comphelper::UiEventsLogger::isEnabled()) //#i88653#
1152 UiEventLogHelper(::rtl::OUString::createFromAscii("MenuBarManager")).log(getServiceFactory(), m_xFrame, aTargetURL, aArgs);
1153 xDispatch->dispatch( aTargetURL, aArgs );
1154 Application::AcquireSolarMutex( nRef );
1155 }
1156
1157 return 1;
1158 }
1159
1160
1161 IMPL_LINK( MenuBarManager, Highlight, Menu *, EMPTYARG )
1162 {
1163 return 0;
1164 }
1165
1166 sal_Bool MenuBarManager::MustBeHidden( PopupMenu* pPopupMenu, const Reference< XURLTransformer >& rTransformer )
1167 {
1168 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "framework", "Ocke.Janssen@sun.com", "MenuBarManager::MustBeHidden" );
1169 if ( pPopupMenu )
1170 {
1171 URL aTargetURL;
1172 SvtCommandOptions aCmdOptions;
1173
1174 sal_uInt16 nCount = pPopupMenu->GetItemCount();
1175 sal_uInt16 nHideCount( 0 );
1176
1177 for ( sal_uInt16 i = 0; i < nCount; i++ )
1178 {
1179 sal_uInt16 nId = pPopupMenu->GetItemId( i );
1180 if ( nId > 0 )
1181 {
1182 PopupMenu* pSubPopupMenu = pPopupMenu->GetPopupMenu( nId );
1183 if ( pSubPopupMenu )
1184 {
1185 if ( MustBeHidden( pSubPopupMenu, rTransformer ))
1186 {
1187 pPopupMenu->HideItem( nId );
1188 ++nHideCount;
1189 }
1190 }
1191 else
1192 {
1193 aTargetURL.Complete = pPopupMenu->GetItemCommand( nId );
1194 rTransformer->parseStrict( aTargetURL );
1195
1196 if ( aCmdOptions.Lookup( SvtCommandOptions::CMDOPTION_DISABLED, aTargetURL.Path ))
1197 ++nHideCount;
1198 }
1199 }
1200 else
1201 ++nHideCount;
1202 }
1203
1204 return ( nCount == nHideCount );
1205 }
1206
1207 return sal_True;
1208 }
1209 String MenuBarManager::RetrieveLabelFromCommand( const String& aCmdURL )
1210 {
1211 return framework::RetrieveLabelFromCommand(aCmdURL,mxServiceFactory,m_xUICommandLabels,m_xFrame,m_aModuleIdentifier,m_bModuleIdentified,"Label");
1212 }
1213
1214
1215
1216 sal_Bool MenuBarManager::CreatePopupMenuController( MenuItemHandler* pMenuItemHandler )
1217 {
1218 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "framework", "Ocke.Janssen@sun.com", "MenuBarManager::CreatePopupMenuController" );
1219 rtl::OUString aItemCommand( pMenuItemHandler->aMenuItemURL );
1220
1221 // Try instanciate a popup menu controller. It is stored in the menu item handler.
1222 Reference< XMultiComponentFactory > xPopupMenuControllerFactory( m_xPopupMenuControllerRegistration, UNO_QUERY );
1223 if ( xPopupMenuControllerFactory.is() )
1224 {
1225 Sequence< Any > aSeq( 2 );
1226 PropertyValue aPropValue;
1227
1228 aPropValue.Name = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "ModuleName" ));
1229 aPropValue.Value <<= m_aModuleIdentifier;
1230 aSeq[0] <<= aPropValue;
1231 aPropValue.Name = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Frame" ));
1232 aPropValue.Value <<= m_xFrame;
1233 aSeq[1] <<= aPropValue;
1234
1235 Reference< XComponentContext > xComponentContext;
1236 Reference< XPropertySet > xProps( getServiceFactory(), UNO_QUERY );
1237
1238 xProps->getPropertyValue( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "DefaultContext" ))) >>=
1239 xComponentContext;
1240
1241 Reference< XPopupMenuController > xPopupMenuController(
1242 xPopupMenuControllerFactory->createInstanceWithArgumentsAndContext(
1243 aItemCommand,
1244 aSeq,
1245 xComponentContext ),
1246 UNO_QUERY );
1247
1248 if ( xPopupMenuController.is() )
1249 {
1250 // Provide our awt popup menu to the popup menu controller
1251 pMenuItemHandler->xPopupMenuController = xPopupMenuController;
1252 xPopupMenuController->setPopupMenu( pMenuItemHandler->xPopupMenu );
1253 return sal_True;
1254 }
1255 }
1256
1257 return sal_False;
1258 }
1259
1260 void MenuBarManager::FillMenuManager( Menu* pMenu, const Reference< XFrame >& rFrame, const Reference< XDispatchProvider >& rDispatchProvider, const rtl::OUString& rModuleIdentifier, sal_Bool bDelete, sal_Bool bDeleteChildren )
1261 {
1262 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "framework", "Ocke.Janssen@sun.com", "MenuBarManager::FillMenuManager" );
1263 m_xFrame = rFrame;
1264 m_bActive = sal_False;
1265 m_bDeleteMenu = bDelete;
1266 m_bDeleteChildren = bDeleteChildren;
1267 m_pVCLMenu = pMenu;
1268 m_bInitialized = sal_False;
1269 m_bIsBookmarkMenu = sal_False;
1270 m_xDispatchProvider = rDispatchProvider;
1271
1272 const StyleSettings& rSettings = Application::GetSettings().GetStyleSettings();
1273 m_bWasHiContrast = rSettings.GetHighContrastMode();
1274 m_bShowMenuImages = rSettings.GetUseImagesInMenus();
1275 m_bRetrieveImages = sal_False;
1276
1277 sal_Int32 nAddonsURLPrefixLength = ADDONSPOPUPMENU_URL_PREFIX.getLength();
1278
1279 // Add root as ui configuration listener
1280 RetrieveImageManagers();
1281
1282 if ( pMenu->IsMenuBar() && rFrame.is() )
1283 {
1284 // First merge all addon popup menus into our structure
1285 USHORT nPos = 0;
1286 for ( nPos = 0; nPos < pMenu->GetItemCount(); nPos++ )
1287 {
1288 USHORT nItemId = pMenu->GetItemId( nPos );
1289 ::rtl::OUString aCommand = pMenu->GetItemCommand( nItemId );
1290 if ( nItemId == SID_MDIWINDOWLIST ||
1291 aCommand == aSpecialWindowCommand )
1292 {
1293 // Retrieve addon popup menus and add them to our menu bar
1294 Reference< com::sun::star::frame::XModel > xModel;
1295 Reference< com::sun::star::frame::XController > xController( rFrame->getController(), UNO_QUERY );
1296 if ( xController.is() )
1297 xModel = Reference< com::sun::star::frame::XModel >( xController->getModel(), UNO_QUERY );
1298 framework::AddonMenuManager::MergeAddonPopupMenus( rFrame, xModel, nPos, (MenuBar *)pMenu );
1299 break;
1300 }
1301 }
1302
1303 // Merge the Add-Ons help menu items into the Office help menu
1304 framework::AddonMenuManager::MergeAddonHelpMenu( rFrame, (MenuBar *)pMenu );
1305 }
1306
1307 String aEmpty;
1308 sal_Bool bAccessibilityEnabled( Application::GetSettings().GetMiscSettings().GetEnableATToolSupport() );
1309 USHORT nItemCount = pMenu->GetItemCount();
1310 ::rtl::OUString aItemCommand;
1311 m_aMenuItemHandlerVector.reserve(nItemCount);
1312 for ( USHORT i = 0; i < nItemCount; i++ )
1313 {
1314 USHORT nItemId = FillItemCommand(aItemCommand,pMenu, i );
1315
1316 // Set module identifier when provided from outside
1317 if ( rModuleIdentifier.getLength() > 0 )
1318 {
1319 m_aModuleIdentifier = rModuleIdentifier;
1320 m_bModuleIdentified = sal_True;
1321 }
1322
1323 if (( pMenu->IsMenuBar() || bAccessibilityEnabled ) &&
1324 ( pMenu->GetItemText( nItemId ).Len() == 0 ))
1325 {
1326 if ( aItemCommand.getLength() > 0 )
1327 pMenu->SetItemText( nItemId, RetrieveLabelFromCommand( aItemCommand ));
1328 }
1329
1330 Reference< XDispatch > xDispatch;
1331 Reference< XStatusListener > xStatusListener;
1332 PopupMenu* pPopup = pMenu->GetPopupMenu( nItemId );
1333 bool bItemShowMenuImages = m_bShowMenuImages;
1334 MenuItemBits nBits = pMenu->GetItemBits( nItemId );
1335 // overwrite the show icons on menu option?
1336 if ( nBits )
1337 bItemShowMenuImages = ( ( nBits & MIB_ICON ) == MIB_ICON );
1338 if ( pPopup )
1339 {
1340 // Retrieve module identifier from Help Command entry
1341 rtl::OUString aModuleIdentifier( rModuleIdentifier );
1342 if ( pMenu->GetHelpCommand( nItemId ).Len() > 0 )
1343 {
1344 aModuleIdentifier = pMenu->GetHelpCommand( nItemId );
1345 pMenu->SetHelpCommand( nItemId, aEmpty );
1346 }
1347
1348 if ( m_xPopupMenuControllerRegistration.is() &&
1349 pPopup->GetItemCount() == 0 &&
1350 m_xPopupMenuControllerRegistration->hasController( aItemCommand, rtl::OUString() )
1351 )
1352 {
1353 // Check if we have to create a popup menu for a uno based popup menu controller.
1354 // We have to set an empty popup menu into our menu structure so the controller also
1355 // works with inplace OLE. Remove old dummy popup menu!
1356 MenuItemHandler* pItemHandler = new MenuItemHandler( nItemId, xStatusListener, xDispatch );
1357 VCLXPopupMenu* pVCLXPopupMenu = new VCLXPopupMenu;
1358 PopupMenu* pNewPopupMenu = (PopupMenu *)pVCLXPopupMenu->GetMenu();
1359 pMenu->SetPopupMenu( nItemId, pNewPopupMenu );
1360 pItemHandler->xPopupMenu = Reference< com::sun::star::awt::XPopupMenu >( (OWeakObject *)pVCLXPopupMenu, UNO_QUERY );
1361 pItemHandler->aMenuItemURL = aItemCommand;
1362 m_aMenuItemHandlerVector.push_back( pItemHandler );
1363 delete pPopup;
1364
1365 if ( bAccessibilityEnabled )
1366 {
1367 if ( CreatePopupMenuController( pItemHandler ))
1368 pItemHandler->xPopupMenuController->updatePopupMenu();
1369 }
1370 lcl_CheckForChildren(pMenu, nItemId);
1371 }
1372 else if (( aItemCommand.getLength() > nAddonsURLPrefixLength ) &&
1373 ( aItemCommand.indexOf( ADDONSPOPUPMENU_URL_PREFIX ) == 0 ))
1374 {
1375 // A special addon popup menu, must be created with a different ctor
1376 // #110897#
1377 MenuBarManager* pSubMenuManager = new MenuBarManager( getServiceFactory(), m_xFrame, m_xURLTransformer,(AddonPopupMenu *)pPopup, bDeleteChildren, bDeleteChildren );
1378 AddMenu(pSubMenuManager,aItemCommand,nItemId);
1379 }
1380 else
1381 {
1382 Reference< XDispatchProvider > xPopupMenuDispatchProvider( rDispatchProvider );
1383
1384 // Retrieve possible attributes struct
1385 MenuConfiguration::Attributes* pAttributes = (MenuConfiguration::Attributes *)(pMenu->GetUserValue( nItemId ));
1386 if ( pAttributes )
1387 xPopupMenuDispatchProvider = pAttributes->xDispatchProvider;
1388
1389 // Check if this is the help menu. Add menu item if needed
1390 if ( nItemId == SID_HELPMENU || aItemCommand == aSlotHelpMenu || aItemCommand == aCmdHelpMenu )
1391 {
1392 // Check if this is the help menu. Add menu item if needed
1393 CheckAndAddMenuExtension( pPopup );
1394 }
1395 else if (( nItemId == SID_ADDONLIST || aItemCommand == aSlotSpecialToolsMenu || aItemCommand == aCmdToolsMenu ) &&
1396 AddonMenuManager::HasAddonMenuElements() )
1397 {
1398 // Create addon popup menu if there exist elements and this is the tools popup menu
1399 USHORT nCount = 0;
1400 AddonMenu* pSubMenu = AddonMenuManager::CreateAddonMenu( rFrame );
1401 if ( pSubMenu && ( pSubMenu->GetItemCount() > 0 ))
1402 {
1403 if ( pPopup->GetItemType( nCount-1 ) != MENUITEM_SEPARATOR )
1404 pPopup->InsertSeparator();
1405
1406 // Use resource to load popup menu title
1407 String aAddonsStrRes = String( FwkResId( STR_MENU_ADDONS ));
1408 pPopup->InsertItem( ITEMID_ADDONLIST, aAddonsStrRes );
1409 pPopup->SetPopupMenu( ITEMID_ADDONLIST, pSubMenu );
1410
1411 // Set item command for popup menu to enable it for GetImageFromURL
1412 const ::rtl::OUString aSlotString( RTL_CONSTASCII_USTRINGPARAM( "slot:" ));
1413 ::rtl::OUString aNewItemCommand( aSlotString );
1414 aNewItemCommand += ::rtl::OUString::valueOf( (sal_Int32)ITEMID_ADDONLIST );
1415 pPopup->SetItemCommand( ITEMID_ADDONLIST, aNewItemCommand );
1416 }
1417 else
1418 delete pSubMenu;
1419 }
1420
1421 if ( nItemId == ITEMID_ADDONLIST )
1422 {
1423 // Create control structure within the "Tools" sub menu for the Add-Ons popup menu
1424 // #110897# MenuBarManager* pSubMenuManager = new MenuBarManager( rFrame, pSubMenu, sal_True, sal_False );
1425 AddonMenu* pSubMenu = dynamic_cast< AddonMenu* >( pPopup );
1426 if ( pSubMenu )
1427 {
1428 MenuBarManager* pSubMenuManager = new MenuBarManager( getServiceFactory(), m_xFrame, m_xURLTransformer,pSubMenu, sal_True, sal_False );
1429 AddMenu(pSubMenuManager,aItemCommand,nItemId);
1430 pSubMenuManager->m_aMenuItemCommand = ::rtl::OUString();
1431
1432 // Set image for the addon popup menu item
1433 if ( bItemShowMenuImages && !pPopup->GetItemImage( ITEMID_ADDONLIST ))
1434 {
1435 Reference< XFrame > xTemp( rFrame );
1436 Image aImage = GetImageFromURL( xTemp, aItemCommand, FALSE, m_bWasHiContrast );
1437 if ( !!aImage )
1438 pPopup->SetItemImage( ITEMID_ADDONLIST, aImage );
1439 }
1440 }
1441 }
1442 else
1443 {
1444 // #110897# MenuBarManager* pSubMenuManager = new MenuBarManager( rFrame, pPopupMenu, bDeleteChildren, bDeleteChildren );
1445 MenuBarManager* pSubMenuMgr = new MenuBarManager( getServiceFactory(), rFrame, m_xURLTransformer,rDispatchProvider, aModuleIdentifier, pPopup, bDeleteChildren, bDeleteChildren );
1446 AddMenu(pSubMenuMgr,aItemCommand,nItemId);
1447 }
1448 }
1449 }
1450 else if ( pMenu->GetItemType( i ) != MENUITEM_SEPARATOR )
1451 {
1452 if ( bItemShowMenuImages )
1453 {
1454 if ( AddonMenuManager::IsAddonMenuId( nItemId ))
1455 {
1456 // Add-Ons uses images from different places
1457 Image aImage;
1458 rtl::OUString aImageId;
1459
1460 MenuConfiguration::Attributes* pMenuAttributes =
1461 (MenuConfiguration::Attributes*)pMenu->GetUserValue( nItemId );
1462
1463 if ( pMenuAttributes && pMenuAttributes->aImageId.getLength() > 0 )
1464 {
1465 // Retrieve image id from menu attributes
1466 aImage = GetImageFromURL( m_xFrame, aImageId, FALSE, m_bWasHiContrast );
1467 }
1468
1469 if ( !aImage )
1470 {
1471 aImage = GetImageFromURL( m_xFrame, aItemCommand, FALSE, m_bWasHiContrast );
1472 if ( !aImage )
1473 aImage = AddonsOptions().GetImageFromURL( aItemCommand, FALSE, m_bWasHiContrast );
1474 }
1475
1476 if ( !!aImage )
1477 pMenu->SetItemImage( nItemId, aImage );
1478 else
1479 m_bRetrieveImages = sal_True;
1480 }
1481 m_bRetrieveImages = sal_True;
1482 }
1483
1484 MenuItemHandler* pItemHandler = new MenuItemHandler( nItemId, xStatusListener, xDispatch );
1485 pItemHandler->aMenuItemURL = aItemCommand;
1486
1487 if ( m_xPopupMenuControllerRegistration.is() &&
1488 m_xPopupMenuControllerRegistration->hasController( aItemCommand, rtl::OUString() ))
1489 {
1490 // Check if we have to create a popup menu for a uno based popup menu controller.
1491 // We have to set an empty popup menu into our menu structure so the controller also
1492 // works with inplace OLE.
1493 VCLXPopupMenu* pVCLXPopupMenu = new VCLXPopupMenu;
1494 PopupMenu* pPopupMenu = (PopupMenu *)pVCLXPopupMenu->GetMenu();
1495 pMenu->SetPopupMenu( pItemHandler->nItemId, pPopupMenu );
1496 pItemHandler->xPopupMenu = Reference< com::sun::star::awt::XPopupMenu >( (OWeakObject *)pVCLXPopupMenu, UNO_QUERY );
1497
1498 if ( bAccessibilityEnabled && CreatePopupMenuController( pItemHandler ) )
1499 {
1500 pItemHandler->xPopupMenuController->updatePopupMenu();
1501 }
1502
1503 lcl_CheckForChildren(pMenu, pItemHandler->nItemId);
1504 }
1505
1506 m_aMenuItemHandlerVector.push_back( pItemHandler );
1507 }
1508 }
1509
1510 if ( bAccessibilityEnabled )
1511 {
1512 RetrieveShortcuts( m_aMenuItemHandlerVector );
1513 std::vector< MenuItemHandler* >::iterator p;
1514 for ( p = m_aMenuItemHandlerVector.begin(); p != m_aMenuItemHandlerVector.end(); p++ )
1515 {
1516 MenuItemHandler* pMenuItemHandler = *p;
1517
1518 // Set key code, workaround for hard-coded shortcut F1 mapped to .uno:HelpIndex
1519 // Only non-popup menu items can have a short-cut
1520 if ( pMenuItemHandler->aMenuItemURL == aCmdHelpIndex )
1521 {
1522 KeyCode aKeyCode( KEY_F1 );
1523 pMenu->SetAccelKey( pMenuItemHandler->nItemId, aKeyCode );
1524 }
1525 else if ( pMenu->GetPopupMenu( pMenuItemHandler->nItemId ) == 0 )
1526 pMenu->SetAccelKey( pMenuItemHandler->nItemId, pMenuItemHandler->aKeyCode );
1527 }
1528 }
1529
1530 SetHdl();
1531 }
1532
1533 void MenuBarManager::impl_RetrieveShortcutsFromConfiguration(
1534 const Reference< XAcceleratorConfiguration >& rAccelCfg,
1535 const Sequence< rtl::OUString >& rCommands,
1536 std::vector< MenuItemHandler* >& aMenuShortCuts )
1537 {
1538 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "framework", "Ocke.Janssen@sun.com", "MenuBarManager::impl_RetrieveShortcutsFromConfiguration" );
1539 if ( rAccelCfg.is() )
1540 {
1541 try
1542 {
1543 com::sun::star::awt::KeyEvent aKeyEvent;
1544 Sequence< Any > aSeqKeyCode = rAccelCfg->getPreferredKeyEventsForCommandList( rCommands );
1545 for ( sal_Int32 i = 0; i < aSeqKeyCode.getLength(); i++ )
1546 {
1547 if ( aSeqKeyCode[i] >>= aKeyEvent )
1548 aMenuShortCuts[i]->aKeyCode = svt::AcceleratorExecute::st_AWTKey2VCLKey( aKeyEvent );
1549 }
1550 }
1551 catch ( IllegalArgumentException& )
1552 {
1553 }
1554 }
1555 }
1556
1557 void MenuBarManager::RetrieveShortcuts( std::vector< MenuItemHandler* >& aMenuShortCuts )
1558 {
1559 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "framework", "Ocke.Janssen@sun.com", "MenuBarManager::RetrieveShortcuts" );
1560 if ( !m_bModuleIdentified )
1561 {
1562 m_bModuleIdentified = sal_True;
1563 Reference< XModuleManager > xModuleManager;
1564 xModuleManager = Reference< XModuleManager >( getServiceFactory()->createInstance( SERVICENAME_MODULEMANAGER ), UNO_QUERY_THROW );
1565
1566 try
1567 {
1568 m_aModuleIdentifier = xModuleManager->identify( m_xFrame );
1569 }
1570 catch( Exception& )
1571 {
1572 }
1573 }
1574
1575 if ( m_bModuleIdentified )
1576 {
1577 Reference< XAcceleratorConfiguration > xDocAccelCfg( m_xDocAcceleratorManager );
1578 Reference< XAcceleratorConfiguration > xModuleAccelCfg( m_xModuleAcceleratorManager );
1579 Reference< XAcceleratorConfiguration > xGlobalAccelCfg( m_xGlobalAcceleratorManager );
1580
1581 if ( !m_bAcceleratorCfg )
1582 {
1583 // Retrieve references on demand
1584 m_bAcceleratorCfg = sal_True;
1585 if ( !xDocAccelCfg.is() )
1586 {
1587 Reference< XController > xController = m_xFrame->getController();
1588 Reference< XModel > xModel;
1589 if ( xController.is() )
1590 {
1591 xModel = xController->getModel();
1592 if ( xModel.is() )
1593 {
1594 Reference< XUIConfigurationManagerSupplier > xSupplier( xModel, UNO_QUERY );
1595 if ( xSupplier.is() )
1596 {
1597 Reference< XUIConfigurationManager > xDocUICfgMgr( xSupplier->getUIConfigurationManager(), UNO_QUERY );
1598 if ( xDocUICfgMgr.is() )
1599 {
1600 xDocAccelCfg = Reference< XAcceleratorConfiguration >( xDocUICfgMgr->getShortCutManager(), UNO_QUERY );
1601 m_xDocAcceleratorManager = xDocAccelCfg;
1602 }
1603 }
1604 }
1605 }
1606 }
1607
1608 if ( !xModuleAccelCfg.is() )
1609 {
1610 Reference< XModuleUIConfigurationManagerSupplier > xModuleCfgMgrSupplier( getServiceFactory()->createInstance(
1611 SERVICENAME_MODULEUICONFIGURATIONMANAGERSUPPLIER ),
1612 UNO_QUERY );
1613 try
1614 {
1615 Reference< XUIConfigurationManager > xUICfgMgr = xModuleCfgMgrSupplier->getUIConfigurationManager( m_aModuleIdentifier );
1616 if ( xUICfgMgr.is() )
1617 {
1618 xModuleAccelCfg = Reference< XAcceleratorConfiguration >( xUICfgMgr->getShortCutManager(), UNO_QUERY );
1619 m_xModuleAcceleratorManager = xModuleAccelCfg;
1620 }
1621 }
1622 catch ( RuntimeException& )
1623 {
1624 throw;
1625 }
1626 catch ( Exception& )
1627 {
1628 }
1629 }
1630
1631 if ( !xGlobalAccelCfg.is() )
1632 {
1633 xGlobalAccelCfg = Reference< XAcceleratorConfiguration >( getServiceFactory()->createInstance(
1634 SERVICENAME_GLOBALACCELERATORCONFIGURATION ),
1635 UNO_QUERY );
1636 m_xGlobalAcceleratorManager = xGlobalAccelCfg;
1637 }
1638 }
1639
1640 KeyCode aEmptyKeyCode;
1641 Sequence< rtl::OUString > aSeq( aMenuShortCuts.size() );
1642 const sal_uInt32 nCount = aMenuShortCuts.size();
1643 for ( sal_uInt32 i = 0; i < nCount; ++i )
1644 {
1645 aSeq[i] = aMenuShortCuts[i]->aMenuItemURL;
1646 aMenuShortCuts[i]->aKeyCode = aEmptyKeyCode;
1647 }
1648
1649 if ( m_xGlobalAcceleratorManager.is() )
1650 impl_RetrieveShortcutsFromConfiguration( xGlobalAccelCfg, aSeq, aMenuShortCuts );
1651 if ( m_xModuleAcceleratorManager.is() )
1652 impl_RetrieveShortcutsFromConfiguration( xModuleAccelCfg, aSeq, aMenuShortCuts );
1653 if ( m_xDocAcceleratorManager.is() )
1654 impl_RetrieveShortcutsFromConfiguration( xGlobalAccelCfg, aSeq, aMenuShortCuts );
1655 }
1656 }
1657
1658 void MenuBarManager::RetrieveImageManagers()
1659 {
1660 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "framework", "Ocke.Janssen@sun.com", "MenuBarManager::RetrieveImageManagers" );
1661 if ( !m_xDocImageManager.is() )
1662 {
1663 Reference< XController > xController = m_xFrame->getController();
1664 Reference< XModel > xModel;
1665 if ( xController.is() )
1666 {
1667 xModel = xController->getModel();
1668 if ( xModel.is() )
1669 {
1670 Reference< XUIConfigurationManagerSupplier > xSupplier( xModel, UNO_QUERY );
1671 if ( xSupplier.is() )
1672 {
1673 Reference< XUIConfigurationManager > xDocUICfgMgr( xSupplier->getUIConfigurationManager(), UNO_QUERY );
1674 m_xDocImageManager = Reference< XImageManager >( xDocUICfgMgr->getImageManager(), UNO_QUERY );
1675 m_xDocImageManager->addConfigurationListener(
1676 Reference< XUIConfigurationListener >(
1677 static_cast< OWeakObject* >( this ), UNO_QUERY ));
1678 }
1679 }
1680 }
1681 }
1682
1683 Reference< XModuleManager > xModuleManager;
1684 if ( m_aModuleIdentifier.getLength() == 0 )
1685 xModuleManager.set( getServiceFactory()->createInstance( SERVICENAME_MODULEMANAGER ), UNO_QUERY_THROW );
1686
1687 try
1688 {
1689 if ( xModuleManager.is() )
1690 m_aModuleIdentifier = xModuleManager->identify( Reference< XInterface >( m_xFrame, UNO_QUERY ) );
1691 }
1692 catch( Exception& )
1693 {
1694 }
1695
1696 if ( !m_xModuleImageManager.is() )
1697 {
1698 Reference< XModuleUIConfigurationManagerSupplier > xModuleCfgMgrSupplier( getServiceFactory()->createInstance(
1699 SERVICENAME_MODULEUICONFIGURATIONMANAGERSUPPLIER ),
1700 UNO_QUERY );
1701 Reference< XUIConfigurationManager > xUICfgMgr = xModuleCfgMgrSupplier->getUIConfigurationManager( m_aModuleIdentifier );
1702 m_xModuleImageManager.set( xUICfgMgr->getImageManager(), UNO_QUERY );
1703 m_xModuleImageManager->addConfigurationListener( Reference< XUIConfigurationListener >(
1704 static_cast< OWeakObject* >( this ), UNO_QUERY ));
1705 }
1706 }
1707
1708 void MenuBarManager::FillMenuWithConfiguration(
1709 USHORT& nId,
1710 Menu* pMenu,
1711 const ::rtl::OUString& rModuleIdentifier,
1712 const Reference< XIndexAccess >& rItemContainer,
1713 const Reference< XURLTransformer >& rTransformer )
1714 {
1715 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "framework", "Ocke.Janssen@sun.com", "MenuBarManager::FillMenuWithConfiguration" );
1716 Reference< XDispatchProvider > xEmptyDispatchProvider;
1717 MenuBarManager::FillMenu( nId, pMenu, rModuleIdentifier, rItemContainer, xEmptyDispatchProvider );
1718
1719 // Merge add-on menu entries into the menu bar
1720 MenuBarManager::MergeAddonMenus( static_cast< Menu* >( pMenu ),
1721 AddonsOptions().GetMergeMenuInstructions(),
1722 rModuleIdentifier );
1723
1724 sal_Bool bHasDisabledEntries = SvtCommandOptions().HasEntries( SvtCommandOptions::CMDOPTION_DISABLED );
1725 if ( bHasDisabledEntries )
1726 {
1727 sal_uInt16 nCount = pMenu->GetItemCount();
1728 for ( sal_uInt16 i = 0; i < nCount; i++ )
1729 {
1730 sal_uInt16 nID = pMenu->GetItemId( i );
1731 if ( nID > 0 )
1732 {
1733 PopupMenu* pPopupMenu = pMenu->GetPopupMenu( nID );
1734 if ( pPopupMenu )
1735 {
1736 if ( MustBeHidden( pPopupMenu, rTransformer ))
1737 pMenu->HideItem( nId );
1738 }
1739 }
1740 }
1741 }
1742 }
1743
1744 void MenuBarManager::FillMenu(
1745 USHORT& nId,
1746 Menu* pMenu,
1747 const rtl::OUString& rModuleIdentifier,
1748 const Reference< XIndexAccess >& rItemContainer,
1749 const Reference< XDispatchProvider >& rDispatchProvider )
1750 {
1751 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "framework", "Ocke.Janssen@sun.com", "MenuBarManager::FillMenu" );
1752 // Fill menu bar with container contents
1753 for ( sal_Int32 n = 0; n < rItemContainer->getCount(); n++ )
1754 {
1755 Sequence< PropertyValue > aProp;
1756 rtl::OUString aCommandURL;
1757 rtl::OUString aLabel;
1758 rtl::OUString aHelpURL;
1759 rtl::OUString aModuleIdentifier( rModuleIdentifier );
1760 sal_uInt16 nType = 0;
1761 Reference< XIndexAccess > xIndexContainer;
1762 Reference< XDispatchProvider > xDispatchProvider( rDispatchProvider );
1763 sal_Int16 nStyle = 0;
1764 try
1765 {
1766 if ( rItemContainer->getByIndex( n ) >>= aProp )
1767 {
1768 for ( int i = 0; i < aProp.getLength(); i++ )
1769 {
1770 rtl::OUString aPropName = aProp[i].Name;
1771 if ( aPropName.equalsAsciiL( ITEM_DESCRIPTOR_COMMANDURL,
1772 LEN_DESCRIPTOR_COMMANDURL ))
1773 aProp[i].Value >>= aCommandURL;
1774 else if ( aPropName.equalsAsciiL( ITEM_DESCRIPTOR_HELPURL,
1775 LEN_DESCRIPTOR_HELPURL ))
1776 aProp[i].Value >>= aHelpURL;
1777 else if ( aPropName.equalsAsciiL( ITEM_DESCRIPTOR_CONTAINER,
1778 LEN_DESCRIPTOR_CONTAINER ))
1779 aProp[i].Value >>= xIndexContainer;
1780 else if ( aPropName.equalsAsciiL( ITEM_DESCRIPTOR_LABEL,
1781 LEN_DESCRIPTOR_LABEL ))
1782 aProp[i].Value >>= aLabel;
1783 else if ( aPropName.equalsAsciiL( ITEM_DESCRIPTOR_TYPE,
1784 LEN_DESCRIPTOR_TYPE ))
1785 aProp[i].Value >>= nType;
1786 else if ( aPropName.equalsAsciiL( ITEM_DESCRIPTOR_MODULEIDENTIFIER,
1787 LEN_DESCRIPTOR_MODULEIDENTIFIER ))
1788 aProp[i].Value >>= aModuleIdentifier;
1789 else if ( aPropName.equalsAsciiL( ITEM_DESCRIPTOR_DISPATCHPROVIDER,
1790 LEN_DESCRIPTOR_DISPATCHPROVIDER ))
1791 aProp[i].Value >>= xDispatchProvider;
1792 else if ( aProp[i].Name.equalsAsciiL( ITEM_DESCRIPTOR_STYLE, ITEM_DESCRIPTOR_STYLE_LEN ))
1793 aProp[i].Value >>= nStyle;
1794 }
1795
1796 if ( nType == ::com::sun::star::ui::ItemType::DEFAULT )
1797 {
1798 pMenu->InsertItem( nId, aLabel );
1799 pMenu->SetItemCommand( nId, aCommandURL );
1800
1801 sal_Int32 nHelpId = aHelpURL.toInt32();
1802 if ( nHelpId > 0 )
1803 pMenu->SetHelpId( nId, (USHORT)nHelpId );
1804 if ( nStyle )
1805 {
1806 MenuItemBits nBits = pMenu->GetItemBits( nId );
1807 if ( nStyle & ::com::sun::star::ui::ItemStyle::ICON )
1808 nBits |= MIB_ICON;
1809 if ( nStyle & ::com::sun::star::ui::ItemStyle::TEXT )
1810 nBits |= MIB_TEXT;
1811 pMenu->SetItemBits( nId, nBits );
1812 }
1813 if ( xIndexContainer.is() )
1814 {
1815 PopupMenu* pNewPopupMenu = new PopupMenu;
1816 pMenu->SetPopupMenu( nId, pNewPopupMenu );
1817
1818 if ( xDispatchProvider.is() )
1819 {
1820 // Use attributes struct to transport special dispatch provider
1821 MenuConfiguration::Attributes* pAttributes = new MenuConfiguration::Attributes;
1822 pAttributes->xDispatchProvider = xDispatchProvider;
1823 pMenu->SetUserValue( nId, (ULONG)( pAttributes ));
1824 }
1825
1826 // Use help command to transport module identifier
1827 if ( aModuleIdentifier.getLength() > 0 )
1828 pMenu->SetHelpCommand( nId, aModuleIdentifier );
1829
1830 ++nId;
1831 FillMenu( nId, pNewPopupMenu, aModuleIdentifier, xIndexContainer, xDispatchProvider );
1832 }
1833 else
1834 ++nId;
1835 }
1836 else
1837 {
1838 pMenu->InsertSeparator();
1839 ++nId;
1840 }
1841 }
1842 }
1843 catch ( IndexOutOfBoundsException& )
1844 {
1845 break;
1846 }
1847 }
1848 }
1849
1850 void MenuBarManager::MergeAddonMenus(
1851 Menu* pMenuBar,
1852 const MergeMenuInstructionContainer& aMergeInstructionContainer,
1853 const ::rtl::OUString& rModuleIdentifier )
1854 {
1855 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "framework", "Ocke.Janssen@sun.com", "MenuBarManager::MergeAddonMenus" );
1856 // set start value for the item ID for the new addon menu items
1857 sal_uInt16 nItemId = ADDONMENU_MERGE_ITEMID_START;
1858
1859 const sal_uInt32 nCount = aMergeInstructionContainer.size();
1860 for ( sal_uInt32 i = 0; i < nCount; i++ )
1861 {
1862 const MergeMenuInstruction& rMergeInstruction = aMergeInstructionContainer[i];
1863
1864 if ( MenuBarMerger::IsCorrectContext( rMergeInstruction.aMergeContext, rModuleIdentifier ))
1865 {
1866 ::std::vector< ::rtl::OUString > aMergePath;
1867
1868 // retrieve the merge path from the merge point string
1869 MenuBarMerger::RetrieveReferencePath( rMergeInstruction.aMergePoint, aMergePath );
1870
1871 // convert the sequence/sequence property value to a more convenient vector<>
1872 AddonMenuContainer aMergeMenuItems;
1873 MenuBarMerger::GetSubMenu( rMergeInstruction.aMergeMenu, aMergeMenuItems );
1874
1875 // try to find the reference point for our merge operation
1876 Menu* pMenu = pMenuBar;
1877 ReferencePathInfo aResult = MenuBarMerger::FindReferencePath( aMergePath, pMenu );
1878
1879 if ( aResult.eResult == RP_OK )
1880 {
1881 // normal merge operation
1882 MenuBarMerger::ProcessMergeOperation( aResult.pPopupMenu,
1883 aResult.nPos,
1884 nItemId,
1885 rMergeInstruction.aMergeCommand,
1886 rMergeInstruction.aMergeCommandParameter,
1887 rModuleIdentifier,
1888 aMergeMenuItems );
1889 }
1890 else
1891 {
1892 // fallback
1893 MenuBarMerger::ProcessFallbackOperation( aResult,
1894 nItemId,
1895 rMergeInstruction.aMergeCommand,
1896 rMergeInstruction.aMergeFallback,
1897 aMergePath,
1898 rModuleIdentifier,
1899 aMergeMenuItems );
1900 }
1901 }
1902 }
1903 }
1904
1905 void MenuBarManager::SetItemContainer( const Reference< XIndexAccess >& rItemContainer )
1906 {
1907 RTL_LOGFILE_CONTEXT( aLog, "framework (cd100003) ::MenuBarManager::SetItemContainer" );
1908
1909 ResetableGuard aGuard( m_aLock );
1910
1911 Reference< XFrame > xFrame = m_xFrame;
1912
1913 if ( !m_bModuleIdentified )
1914 {
1915 m_bModuleIdentified = sal_True;
1916 Reference< XModuleManager > xModuleManager;
1917 xModuleManager = Reference< XModuleManager >( getServiceFactory()->createInstance( SERVICENAME_MODULEMANAGER ), UNO_QUERY_THROW );
1918
1919 try
1920 {
1921 m_aModuleIdentifier = xModuleManager->identify( xFrame );
1922 }
1923 catch( Exception& )
1924 {
1925 }
1926 }
1927
1928 // Clear MenuBarManager structures
1929 {
1930 vos::OGuard aSolarMutexGuard( Application::GetSolarMutex() );
1931
1932 // Check active state as we cannot change our VCL menu during activation by the user
1933 if ( m_bActive )
1934 {
1935 m_xDeferedItemContainer = rItemContainer;
1936 return;
1937 }
1938
1939 RemoveListener();
1940 std::vector< MenuItemHandler* >::iterator p;
1941 for ( p = m_aMenuItemHandlerVector.begin(); p != m_aMenuItemHandlerVector.end(); p++ )
1942 {
1943 MenuItemHandler* pItemHandler = *p;
1944 pItemHandler->xMenuItemDispatch.clear();
1945 pItemHandler->xSubMenuManager.clear();
1946 delete pItemHandler;
1947 }
1948 m_aMenuItemHandlerVector.clear();
1949
1950 // Remove top-level parts
1951 m_pVCLMenu->Clear();
1952
1953 USHORT nId = 1;
1954
1955 // Fill menu bar with container contents
1956 FillMenuWithConfiguration( nId, (Menu *)m_pVCLMenu, m_aModuleIdentifier, rItemContainer, m_xURLTransformer );
1957
1958 // Refill menu manager again
1959 Reference< XDispatchProvider > xDispatchProvider;
1960 FillMenuManager( m_pVCLMenu, xFrame, xDispatchProvider, m_aModuleIdentifier, sal_False, sal_True );
1961
1962 // add itself as frame action listener
1963 m_xFrame->addFrameActionListener( Reference< XFrameActionListener >( static_cast< OWeakObject* >( this ), UNO_QUERY ));
1964 }
1965 }
1966
1967 void MenuBarManager::GetPopupController( PopupControllerCache& rPopupController )
1968 {
1969 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "framework", "Ocke.Janssen@sun.com", "MenuBarManager::GetPopupController" );
1970 String aPopupScheme = String::CreateFromAscii( "vnd.sun.star.popup:" );
1971
1972 vos::OGuard aSolarMutexGuard( Application::GetSolarMutex() );
1973
1974 std::vector< MenuItemHandler* >::iterator p;
1975 for ( p = m_aMenuItemHandlerVector.begin(); p != m_aMenuItemHandlerVector.end(); p++ )
1976 {
1977 MenuItemHandler* pItemHandler = *p;
1978 if ( pItemHandler->xPopupMenuController.is() )
1979 {
1980 Reference< XDispatchProvider > xDispatchProvider( pItemHandler->xPopupMenuController, UNO_QUERY );
1981
1982 PopupControllerEntry aPopupControllerEntry;
1983 aPopupControllerEntry.m_xDispatchProvider = xDispatchProvider;
1984
1985 // Just use the main part of the URL for popup menu controllers
1986 sal_Int32 nQueryPart( 0 );
1987 sal_Int32 nSchemePart( 0 );
1988 rtl::OUString aMainURL( RTL_CONSTASCII_USTRINGPARAM( "vnd.sun.star.popup:" ));
1989 rtl::OUString aMenuURL( pItemHandler->aMenuItemURL );
1990
1991 nSchemePart = aMenuURL.indexOf( ':' );
1992 if (( nSchemePart > 0 ) &&
1993 ( aMenuURL.getLength() > ( nSchemePart+1 )))
1994 {
1995 nQueryPart = aMenuURL.indexOf( '?', nSchemePart );
1996 if ( nQueryPart > 0 )
1997 aMainURL += aMenuURL.copy( nSchemePart, nQueryPart-nSchemePart );
1998 else if ( nQueryPart == -1 )
1999 aMainURL += aMenuURL.copy( nSchemePart+1 );
2000
2001 rPopupController.insert( PopupControllerCache::value_type(
2002 aMainURL, aPopupControllerEntry ));
2003 }
2004 }
2005 if ( pItemHandler->xSubMenuManager.is() )
2006 {
2007 MenuBarManager* pMenuBarManager = (MenuBarManager*)(pItemHandler->xSubMenuManager.get());
2008 if ( pMenuBarManager )
2009 pMenuBarManager->GetPopupController( rPopupController );
2010 }
2011 }
2012 }
2013
2014 // #110897#
2015 const Reference< XMultiServiceFactory >& MenuBarManager::getServiceFactory()
2016 {
2017 // #110897#
2018 return mxServiceFactory;
2019 }
2020
2021 void MenuBarManager::AddMenu(MenuBarManager* pSubMenuManager,const ::rtl::OUString& _sItemCommand,USHORT _nItemId)
2022 {
2023 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "framework", "Ocke.Janssen@sun.com", "MenuBarManager::AddMenu" );
2024 Reference< XStatusListener > xSubMenuManager( static_cast< OWeakObject *>( pSubMenuManager ), UNO_QUERY );
2025 m_xFrame->addFrameActionListener( Reference< XFrameActionListener >( xSubMenuManager, UNO_QUERY ));
2026
2027 // store menu item command as we later have to know which menu is active (see Activate handler)
2028 pSubMenuManager->m_aMenuItemCommand = _sItemCommand;
2029 Reference< XDispatch > xDispatch;
2030 MenuItemHandler* pMenuItemHandler = new MenuItemHandler(
2031 _nItemId,
2032 xSubMenuManager,
2033 xDispatch );
2034 pMenuItemHandler->aMenuItemURL = _sItemCommand;
2035 m_aMenuItemHandlerVector.push_back( pMenuItemHandler );
2036 }
2037
2038 USHORT MenuBarManager::FillItemCommand(::rtl::OUString& _rItemCommand,Menu* _pMenu,USHORT _nIndex) const
2039 {
2040 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "framework", "Ocke.Janssen@sun.com", "MenuBarManager::FillItemCommand" );
2041 USHORT nItemId = _pMenu->GetItemId( _nIndex );
2042
2043 _rItemCommand = _pMenu->GetItemCommand( nItemId );
2044 if ( !_rItemCommand.getLength() )
2045 {
2046 const static ::rtl::OUString aSlotString( RTL_CONSTASCII_USTRINGPARAM( "slot:" ));
2047 _rItemCommand = aSlotString;
2048 _rItemCommand += ::rtl::OUString::valueOf( (sal_Int32)nItemId );
2049 _pMenu->SetItemCommand( nItemId, _rItemCommand );
2050 }
2051 return nItemId;
2052 }
2053 void MenuBarManager::Init(const Reference< XFrame >& rFrame,AddonMenu* pAddonMenu,sal_Bool bDelete,sal_Bool bDeleteChildren,bool _bHandlePopUp)
2054 {
2055 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "framework", "Ocke.Janssen@sun.com", "MenuBarManager::Init" );
2056 m_bActive = sal_False;
2057 m_bDeleteMenu = bDelete;
2058 m_bDeleteChildren = bDeleteChildren;
2059 m_pVCLMenu = pAddonMenu;
2060 m_xFrame = rFrame;
2061 m_bInitialized = sal_False;
2062 m_bIsBookmarkMenu = sal_True;
2063
2064 rtl::OUString aModuleIdentifier;
2065 m_xPopupMenuControllerRegistration = Reference< ::com::sun::star::frame::XUIControllerRegistration >(
2066 getServiceFactory()->createInstance( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.frame.PopupMenuControllerFactory" ))),
2067 UNO_QUERY );
2068
2069 const StyleSettings& rSettings = Application::GetSettings().GetStyleSettings();
2070 m_bWasHiContrast = rSettings.GetHighContrastMode();
2071
2072 Reference< XStatusListener > xStatusListener;
2073 Reference< XDispatch > xDispatch;
2074 USHORT nItemCount = pAddonMenu->GetItemCount();
2075 ::rtl::OUString aItemCommand;
2076 m_aMenuItemHandlerVector.reserve(nItemCount);
2077 for ( USHORT i = 0; i < nItemCount; i++ )
2078 {
2079 USHORT nItemId = FillItemCommand(aItemCommand,pAddonMenu, i );
2080
2081 PopupMenu* pPopupMenu = pAddonMenu->GetPopupMenu( nItemId );
2082 if ( pPopupMenu )
2083 {
2084 // #110897#
2085 Reference< XDispatchProvider > xDispatchProvider;
2086 MenuBarManager* pSubMenuManager = new MenuBarManager( getServiceFactory(), rFrame, m_xURLTransformer,xDispatchProvider, aModuleIdentifier, pPopupMenu, _bHandlePopUp ? sal_False : bDeleteChildren, _bHandlePopUp ? sal_False : bDeleteChildren );
2087
2088 Reference< XStatusListener > xSubMenuManager( static_cast< OWeakObject *>( pSubMenuManager ), UNO_QUERY );
2089
2090 // store menu item command as we later have to know which menu is active (see Acivate handler)
2091 pSubMenuManager->m_aMenuItemCommand = aItemCommand;
2092
2093 MenuItemHandler* pMenuItemHandler = new MenuItemHandler(
2094 nItemId,
2095 xSubMenuManager,
2096 xDispatch );
2097 m_aMenuItemHandlerVector.push_back( pMenuItemHandler );
2098 }
2099 else
2100 {
2101 if ( pAddonMenu->GetItemType( i ) != MENUITEM_SEPARATOR )
2102 {
2103 MenuConfiguration::Attributes* pAddonAttributes = (MenuConfiguration::Attributes *)(pAddonMenu->GetUserValue( nItemId ));
2104 MenuItemHandler* pMenuItemHandler = new MenuItemHandler( nItemId, xStatusListener, xDispatch );
2105
2106 if ( pAddonAttributes )
2107 {
2108 // read additional attributes from attributes struct and AddonMenu implementation will delete all attributes itself!!
2109 pMenuItemHandler->aTargetFrame = pAddonAttributes->aTargetFrame;
2110 }
2111
2112 pMenuItemHandler->aMenuItemURL = aItemCommand;
2113 if ( _bHandlePopUp )
2114 {
2115 // Check if we have to create a popup menu for a uno based popup menu controller.
2116 // We have to set an empty popup menu into our menu structure so the controller also
2117 // works with inplace OLE.
2118 if ( m_xPopupMenuControllerRegistration.is() &&
2119 m_xPopupMenuControllerRegistration->hasController( aItemCommand, rtl::OUString() ))
2120 {
2121 VCLXPopupMenu* pVCLXPopupMenu = new VCLXPopupMenu;
2122 PopupMenu* pCtlPopupMenu = (PopupMenu *)pVCLXPopupMenu->GetMenu();
2123 pAddonMenu->SetPopupMenu( pMenuItemHandler->nItemId, pCtlPopupMenu );
2124 pMenuItemHandler->xPopupMenu = Reference< com::sun::star::awt::XPopupMenu >( (OWeakObject *)pVCLXPopupMenu, UNO_QUERY );
2125
2126 }
2127 }
2128 m_aMenuItemHandlerVector.push_back( pMenuItemHandler );
2129 }
2130 }
2131 }
2132
2133 SetHdl();
2134 }
2135
2136 void MenuBarManager::SetHdl()
2137 {
2138 m_pVCLMenu->SetHighlightHdl( LINK( this, MenuBarManager, Highlight ));
2139 m_pVCLMenu->SetActivateHdl( LINK( this, MenuBarManager, Activate ));
2140 m_pVCLMenu->SetDeactivateHdl( LINK( this, MenuBarManager, Deactivate ));
2141 m_pVCLMenu->SetSelectHdl( LINK( this, MenuBarManager, Select ));
2142
2143 if ( !m_xURLTransformer.is() && mxServiceFactory.is() )
2144 m_xURLTransformer.set( mxServiceFactory->createInstance(
2145 SERVICENAME_URLTRANSFORMER),
2146 UNO_QUERY );
2147 }
2148
2149 }
vba interoperability for OOo