framework/source/classes/menumanager.cxx

   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: menumanager.cxx,v $
  10  * $Revision: 1.41 $
  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 <classes/menumanager.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 <services.h>
  47 #include "classes/resource.hrc"
  48
  49 //_________________________________________________________________________________________________________________
  50 //      interface includes
  51 //_________________________________________________________________________________________________________________
  52 #include <com/sun/star/frame/XDispatchProvider.hpp>
  53 #include <com/sun/star/frame/XDispatch.hpp>
  54 #include <com/sun/star/util/XURLTransformer.hpp>
  55 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
  56 #include <com/sun/star/beans/XPropertySet.hpp>
  57 #include <com/sun/star/frame/XFramesSupplier.hpp>
  58 #include <com/sun/star/frame/XDesktop.hpp>
  59 #include <com/sun/star/container/XEnumeration.hpp>
  60 #include <com/sun/star/util/XStringWidth.hpp>
  61
  62 //_________________________________________________________________________________________________________________
  63 //      includes of other projects
  64 //_________________________________________________________________________________________________________________
  65 #include <comphelper/processfactory.hxx>
  66
  67 #include <comphelper/extract.hxx>
  68 #include <svtools/menuoptions.hxx>
  69 #include <svtools/historyoptions.hxx>
  70 #include <svtools/pathoptions.hxx>
  71 #include <unotools/localfilehelper.hxx>
  72
  73 #ifndef _TOOLKIT_HELPER_VCLUNOHELPER_HXX_
  74 #include <toolkit/unohlp.hxx>
  75 #endif
  76 #include <tools/urlobj.hxx>
  77
  78 #include <vcl/svapp.hxx>
  79 #include <vcl/window.hxx>
  80 #include <vos/mutex.hxx>
  81 #include <vcl/svapp.hxx>
  82 #include <osl/file.hxx>
  83 #include <cppuhelper/implbase1.hxx>
  84
  85 //_________________________________________________________________________________________________________________
  86 //      namespace
  87 //_________________________________________________________________________________________________________________
  88
  89 using namespace ::cppu;
  90 using namespace ::vos;
  91 using namespace ::com::sun::star::uno;
  92 using namespace ::com::sun::star::util;
  93 using namespace ::com::sun::star::beans;
  94 using namespace ::com::sun::star::frame;
  95 using namespace ::com::sun::star::lang;
  96 using namespace ::com::sun::star::container;
  97
  98
  99 class StringLength : public ::cppu::WeakImplHelper1< ::com::sun::star::util::XStringWidth >
 100 {
 101     public:
 102         StringLength() {}
 103         virtual ~StringLength() {}
 104
 105         // XStringWidth
 106         sal_Int32 SAL_CALL queryStringWidth( const ::rtl::OUString& aString )
 107             throw (::com::sun::star::uno::RuntimeException)
 108         {
 109             return aString.getLength();
 110         }
 111 };
 112
 113 namespace framework
 114 {
 115
 116 // special menu ids/command ids for dynamic popup menus
 117 #define SID_SFX_START                   5000
 118 #define SID_NEWDOCDIRECT                (SID_SFX_START + 537)
 119 #define SID_AUTOPILOTMENU               (SID_SFX_START + 1381)
 120 #define SID_PICKLIST                    (SID_SFX_START + 510)
 121 #define SID_MDIWINDOWLIST               (SID_SFX_START + 610)
 122 #define SID_ADDONLIST                   (SID_SFX_START + 1677)
 123 #define SID_HELPMENU                    (SID_SFX_START + 410)
 124
 125 #define SFX_REFERER_USER                "private:user"
 126
 127 const ::rtl::OUString aSlotNewDocDirect( RTL_CONSTASCII_USTRINGPARAM( "slot:5537" ));
 128 const ::rtl::OUString aSlotAutoPilot( RTL_CONSTASCII_USTRINGPARAM( "slot:6381" ));
 129
 130 const ::rtl::OUString aSpecialFileMenu( RTL_CONSTASCII_USTRINGPARAM( "file" ));
 131 const ::rtl::OUString aSpecialWindowMenu( RTL_CONSTASCII_USTRINGPARAM( "window" ));
 132 const ::rtl::OUString aSlotSpecialFileMenu( RTL_CONSTASCII_USTRINGPARAM( "slot:5510" ));
 133 const ::rtl::OUString aSlotSpecialWindowMenu( RTL_CONSTASCII_USTRINGPARAM( "slot:5610" ));
 134 const ::rtl::OUString aSlotSpecialToolsMenu( RTL_CONSTASCII_USTRINGPARAM( "slot:6677" ));
 135
 136 // special uno commands for picklist and window list
 137 const ::rtl::OUString aSpecialFileCommand( RTL_CONSTASCII_USTRINGPARAM( "PickList" ));
 138 const ::rtl::OUString aSpecialWindowCommand( RTL_CONSTASCII_USTRINGPARAM( "WindowList" ));
 139
 140 const ::rtl::OUString UNO_COMMAND( RTL_CONSTASCII_USTRINGPARAM( ".uno:" ));
 141
 142 // #110897#
 143 MenuManager::MenuManager(
 144     const ::com::sun::star::uno::Reference< ::com::sun::star::lang::XMultiServiceFactory >& xServiceFactory,
 145     REFERENCE< XFRAME >& rFrame, Menu* pMenu, sal_Bool bDelete, sal_Bool bDeleteChildren )
 146 :       // #110897#
 147     ThreadHelpBase( &Application::GetSolarMutex() ),
 148     mxServiceFactory(xServiceFactory)
 149 {
 150     m_bActive                   = sal_False;
 151     m_bDeleteMenu               = bDelete;
 152     m_bDeleteChildren   = bDeleteChildren;
 153     m_pVCLMenu                  = pMenu;
 154     m_xFrame                    = rFrame;
 155     m_bInitialized              = sal_False;
 156     m_bIsBookmarkMenu   = sal_False;
 157     SAL_STATIC_CAST( ::com::sun::star::uno::XInterface*, (OWeakObject*)this )->acquire();
 158
 159     const StyleSettings& rSettings = Application::GetSettings().GetStyleSettings();
 160     m_bWasHiContrast    = rSettings.GetHighContrastMode();
 161     m_bShowMenuImages   = rSettings.GetUseImagesInMenus();
 162
 163     sal_Int32 nAddonsURLPrefixLength = ADDONSPOPUPMENU_URL_PREFIX.getLength();
 164 #if 0
 165     ::std::vector< USHORT > aQueryLabelItemIdVector;
 166 #endif
 167
 168     USHORT nItemCount = pMenu->GetItemCount();
 169     m_aMenuItemHandlerVector.reserve(nItemCount);
 170     ::rtl::OUString aItemCommand;
 171     for ( USHORT i = 0; i < nItemCount; i++ )
 172     {
 173         USHORT nItemId = FillItemCommand(aItemCommand,pMenu, i );
 174
 175         PopupMenu* pPopupMenu = pMenu->GetPopupMenu( nItemId );
 176         if ( pPopupMenu )
 177         {
 178             AddMenu(pPopupMenu,aItemCommand,nItemId,bDeleteChildren,bDeleteChildren);
 179             if (! (( aItemCommand.getLength() > nAddonsURLPrefixLength ) &&
 180                 ( aItemCommand.indexOf( ADDONSPOPUPMENU_URL_PREFIX ) == 0 )) )
 181             {
 182                 // #110897#
 183                 // MenuManager* pSubMenuManager = new MenuManager( rFrame, pPopupMenu, bDeleteChildren, bDeleteChildren );
 184 #if 0
 185                 if ( pMenu->GetItemText( nItemId ).Len() == 0 )
 186                     aQueryLabelItemIdVector.push_back( nItemId );
 187 #endif
 188
 189                 // Create addon popup menu if there exist elements and this is the tools popup menu
 190                 if (( nItemId == SID_ADDONLIST ||
 191                     aItemCommand == aSlotSpecialToolsMenu ) &&
 192                     AddonMenuManager::HasAddonMenuElements() )
 193                 {
 194                     USHORT      nCount   = 0;
 195                     AddonMenu*  pSubMenu = AddonMenuManager::CreateAddonMenu( rFrame );
 196                     if ( pSubMenu && ( pSubMenu->GetItemCount() > 0 ))
 197                     {
 198                         if ( pPopupMenu->GetItemType( nCount-1 ) != MENUITEM_SEPARATOR )
 199                             pPopupMenu->InsertSeparator();
 200
 201                         // Use resource to load popup menu title
 202                         String aAddonsStrRes = String( FwkResId( STR_MENU_ADDONS ));
 203                         pPopupMenu->InsertItem( ITEMID_ADDONLIST, aAddonsStrRes );
 204                         pPopupMenu->SetPopupMenu( ITEMID_ADDONLIST, pSubMenu );
 205
 206                         // Set item command for popup menu to enable it for GetImageFromURL
 207                         const static ::rtl::OUString aSlotString( RTL_CONSTASCII_USTRINGPARAM( "slot:" ));
 208                         aItemCommand = aSlotString;
 209                         aItemCommand += ::rtl::OUString::valueOf( (sal_Int32)ITEMID_ADDONLIST );
 210                         pPopupMenu->SetItemCommand( ITEMID_ADDONLIST, aItemCommand );
 211
 212                         // #110897#
 213                         // MenuManager* pSubMenuManager = new MenuManager( rFrame, pSubMenu, sal_True, sal_False );
 214                         AddMenu(pSubMenu,::rtl::OUString(),nItemId,sal_True,sal_False);
 215 #if 0
 216                         if ( pMenu->GetItemText( nItemId ).Len() == 0 )
 217                             aQueryLabelItemIdVector.push_back( nItemId );
 218 #endif
 219                         // Set image for the addon popup menu item
 220                         if ( m_bShowMenuImages && !pPopupMenu->GetItemImage( ITEMID_ADDONLIST ))
 221                         {
 222                             Image aImage = GetImageFromURL( rFrame, aItemCommand, FALSE, m_bWasHiContrast );
 223                             if ( !!aImage )
 224                                    pPopupMenu->SetItemImage( ITEMID_ADDONLIST, aImage );
 225                         }
 226                     }
 227                     else
 228                         delete pSubMenu;
 229                 }
 230             }
 231         }
 232         else
 233         {
 234             if ( nItemId == SID_NEWDOCDIRECT ||
 235                  aItemCommand == aSlotNewDocDirect )
 236             {
 237                 // #110897#
 238                 // Reference< ::com::sun::star::lang::XMultiServiceFactory > aMultiServiceFactory(::comphelper::getProcessServiceFactory());
 239                 // MenuConfiguration aMenuCfg( aMultiServiceFactory );
 240                 MenuConfiguration aMenuCfg( getServiceFactory() );
 241                 BmkMenu* pSubMenu = (BmkMenu*)aMenuCfg.CreateBookmarkMenu( rFrame, BOOKMARK_NEWMENU );
 242                 pMenu->SetPopupMenu( nItemId, pSubMenu );
 243
 244                 // #110897#
 245                 // MenuManager* pSubMenuManager = new MenuManager( rFrame, pSubMenu, sal_True, sal_False );
 246                 AddMenu(pSubMenu,::rtl::OUString(),nItemId,sal_True,sal_False);
 247 #if 0
 248                 if ( pMenu->GetItemText( nItemId ).Len() == 0 )
 249                     aQueryLabelItemIdVector.push_back( nItemId );
 250 #endif
 251
 252                 if ( m_bShowMenuImages && !pMenu->GetItemImage( nItemId ))
 253                 {
 254                     Image aImage = GetImageFromURL( rFrame, aItemCommand, FALSE, m_bWasHiContrast );
 255                     if ( !!aImage )
 256                            pMenu->SetItemImage( nItemId, aImage );
 257                 }
 258             }
 259             else if ( nItemId == SID_AUTOPILOTMENU ||
 260                       aItemCommand == aSlotAutoPilot )
 261             {
 262                 // #110897#
 263                 // Reference< ::com::sun::star::lang::XMultiServiceFactory > aMultiServiceFactory(::comphelper::getProcessServiceFactory());
 264                 // MenuConfiguration aMenuCfg( aMultiServiceFactory );
 265                 MenuConfiguration aMenuCfg( getServiceFactory() );
 266                 BmkMenu* pSubMenu = (BmkMenu*)aMenuCfg.CreateBookmarkMenu( rFrame, BOOKMARK_WIZARDMENU );
 267                 pMenu->SetPopupMenu( nItemId, pSubMenu );
 268
 269                 // #110897#
 270                 // MenuManager* pSubMenuManager = new MenuManager( rFrame, pSubMenu, sal_True, sal_False );
 271                 AddMenu(pSubMenu,::rtl::OUString(),nItemId,sal_True,sal_False);
 272 #if 0
 273                 if ( pMenu->GetItemText( nItemId ).Len() == 0 )
 274                     aQueryLabelItemIdVector.push_back( nItemId );
 275 #endif
 276
 277                 if ( m_bShowMenuImages && !pMenu->GetItemImage( nItemId ))
 278                 {
 279                     Image aImage = GetImageFromURL( rFrame, aItemCommand, FALSE, m_bWasHiContrast );
 280                     if ( !!aImage )
 281                            pMenu->SetItemImage( nItemId, aImage );
 282                 }
 283             }
 284             else if ( pMenu->GetItemType( i ) != MENUITEM_SEPARATOR )
 285             {
 286                 if ( m_bShowMenuImages )
 287                 {
 288                     if ( AddonMenuManager::IsAddonMenuId( nItemId ))
 289                     {
 290                         // Add-Ons uses a images from different places
 291                         Image           aImage;
 292                         rtl::OUString   aImageId;
 293
 294                         MenuConfiguration::Attributes* pMenuAttributes =
 295                             (MenuConfiguration::Attributes*)pMenu->GetUserValue( nItemId );
 296
 297                         if ( pMenuAttributes && pMenuAttributes->aImageId.getLength() > 0 )
 298                         {
 299                             // Retrieve image id from menu attributes
 300                             aImage = GetImageFromURL( rFrame, aImageId, FALSE, m_bWasHiContrast );
 301                         }
 302
 303                         if ( !aImage )
 304                         {
 305                             aImage = GetImageFromURL( rFrame, aItemCommand, FALSE, m_bWasHiContrast );
 306                             if ( !aImage )
 307                                 aImage = AddonsOptions().GetImageFromURL( aItemCommand, FALSE, m_bWasHiContrast );
 308                         }
 309
 310                         if ( !!aImage )
 311                             pMenu->SetItemImage( nItemId, aImage );
 312                     }
 313                     else if ( !pMenu->GetItemImage( nItemId ))
 314                     {
 315                         Image aImage = GetImageFromURL( rFrame, aItemCommand, FALSE, m_bWasHiContrast );
 316                         if ( !!aImage )
 317                                pMenu->SetItemImage( nItemId, aImage );
 318                     }
 319                 }
 320
 321                 REFERENCE< XDISPATCH > aXDispatchRef;
 322                 m_aMenuItemHandlerVector.push_back( new MenuItemHandler( nItemId, NULL, aXDispatchRef ));
 323 #if 0
 324                 if ( pMenu->GetItemText( nItemId ).Len() == 0 )
 325                     aQueryLabelItemIdVector.push_back( nItemId );
 326 #endif
 327             }
 328         }
 329     }
 330
 331
 332     // retrieve label information for all menu items without item text
 333 #if 0
 334     if ( aQueryLabelItemIdVector.size() > 0 )
 335     {
 336         Sequence< ::rtl::OUString > aURLSequence( aQueryLabelItemIdVector.size() );
 337         Sequence< ::rtl::OUString > aLabelSequence( aQueryLabelItemIdVector.size() );
 338
 339         sal_uInt32 nPos = 0;
 340         ::std::vector< USHORT >::iterator p;
 341         for ( p = aQueryLabelItemIdVector.begin(); p != aQueryLabelItemIdVector.end(); p++ )
 342             aURLSequence[nPos++] = pMenu->GetItemCommand( *p );
 343
 344         Reference< XDispatchInformationProvider > xDIP( xFrame, UNO_QUERY );
 345         if ( xDIP.is() )
 346         {
 347             nPos = 0;
 348             xDIP->queryDispatchInformations( aURLSequence, aLabelSequence );
 349             for ( p = aQueryLabelItemIdVector.begin(); p != aQueryLabelItemIdVector.end(); p++ )
 350                 pMenu->SetItemText( *p, aLabelSequence( nPos++ ));
 351         }
 352     }
 353 #endif
 354     SetHdl();
 355 }
 356
 357 // #110897#
 358 MenuManager::MenuManager(
 359     const ::com::sun::star::uno::Reference< ::com::sun::star::lang::XMultiServiceFactory >& xServiceFactory,
 360     REFERENCE< XFRAME >& rFrame, AddonMenu* pAddonMenu, sal_Bool bDelete, sal_Bool bDeleteChildren )
 361 :       // #110897#
 362     ThreadHelpBase( &Application::GetSolarMutex() ),
 363     mxServiceFactory(xServiceFactory)
 364 {
 365     m_bActive                   = sal_False;
 366     m_bDeleteMenu               = bDelete;
 367     m_bDeleteChildren   = bDeleteChildren;
 368     m_pVCLMenu                  = pAddonMenu;
 369     m_xFrame                    = rFrame;
 370     m_bInitialized              = sal_False;
 371     m_bIsBookmarkMenu   = sal_True;
 372
 373     const StyleSettings& rSettings = Application::GetSettings().GetStyleSettings();
 374     m_bWasHiContrast    = rSettings.GetHighContrastMode();
 375
 376     SAL_STATIC_CAST( ::com::sun::star::uno::XInterface*, (OWeakObject*)this )->acquire();
 377
 378     USHORT nItemCount = pAddonMenu->GetItemCount();
 379     m_aMenuItemHandlerVector.reserve(nItemCount);
 380     ::rtl::OUString aItemCommand;
 381     for ( USHORT i = 0; i < nItemCount; i++ )
 382     {
 383         USHORT nItemId = FillItemCommand(aItemCommand,pAddonMenu, i );
 384
 385         PopupMenu* pPopupMenu = pAddonMenu->GetPopupMenu( nItemId );
 386         if ( pPopupMenu )
 387         {
 388             // #110897#
 389             // MenuManager* pSubMenuManager = new MenuManager( rFrame, pPopupMenu, bDeleteChildren, bDeleteChildren );
 390             AddMenu(pPopupMenu,aItemCommand,nItemId,bDeleteChildren,bDeleteChildren);
 391         }
 392         else
 393         {
 394             if ( pAddonMenu->GetItemType( i ) != MENUITEM_SEPARATOR )
 395             {
 396                 MenuConfiguration::Attributes* pAddonAttributes = (MenuConfiguration::Attributes *)(pAddonMenu->GetUserValue( nItemId ));
 397                 REFERENCE< XDISPATCH > aXDispatchRef;
 398                 MenuItemHandler* pMenuItemHandler = new MenuItemHandler( nItemId, NULL, aXDispatchRef );
 399
 400                 if ( pAddonAttributes )
 401                 {
 402                     // read additional attributes from attributes struct and AddonMenu implementation will delete all attributes itself!!
 403                     pMenuItemHandler->aTargetFrame = pAddonAttributes->aTargetFrame;
 404                 }
 405
 406                 m_aMenuItemHandlerVector.push_back( pMenuItemHandler );
 407             }
 408         }
 409     }
 410
 411     SetHdl();
 412 }
 413
 414 void MenuManager::SetHdl()
 415 {
 416     m_pVCLMenu->SetHighlightHdl( LINK( this, MenuManager, Highlight ));
 417     m_pVCLMenu->SetActivateHdl( LINK( this, MenuManager, Activate ));
 418     m_pVCLMenu->SetDeactivateHdl( LINK( this, MenuManager, Deactivate ));
 419     m_pVCLMenu->SetSelectHdl( LINK( this, MenuManager, Select ));
 420
 421     if ( mxServiceFactory.is() )
 422         m_xURLTransformer.set( mxServiceFactory->createInstance(SERVICENAME_URLTRANSFORMER),UNO_QUERY );
 423 }
 424
 425 MenuManager::~MenuManager()
 426 {
 427     std::vector< MenuItemHandler* >::iterator p;
 428     for ( p = m_aMenuItemHandlerVector.begin(); p != m_aMenuItemHandlerVector.end(); p++ )
 429     {
 430         MenuItemHandler* pItemHandler = *p;
 431         pItemHandler->xMenuItemDispatch.clear();
 432         if ( pItemHandler->pSubMenuManager )
 433             SAL_STATIC_CAST( ::com::sun::star::uno::XInterface*, (OWeakObject*)pItemHandler->pSubMenuManager )->release();
 434         delete pItemHandler;
 435     }
 436
 437     if ( m_bDeleteMenu )
 438         delete m_pVCLMenu;
 439 }
 440
 441
 442 MenuManager::MenuItemHandler* MenuManager::GetMenuItemHandler( USHORT nItemId )
 443 {
 444     ResetableGuard aGuard( m_aLock );
 445
 446     std::vector< MenuItemHandler* >::iterator p;
 447     for ( p = m_aMenuItemHandlerVector.begin(); p != m_aMenuItemHandlerVector.end(); p++ )
 448     {
 449         MenuItemHandler* pItemHandler = *p;
 450         if ( pItemHandler->nItemId == nItemId )
 451             return pItemHandler;
 452     }
 453
 454     return 0;
 455 }
 456
 457
 458 void SAL_CALL MenuManager::statusChanged( const FEATURSTATEEVENT& Event )
 459 throw ( RuntimeException )
 460 {
 461     ::rtl::OUString aFeatureURL = Event.FeatureURL.Complete;
 462     MenuItemHandler* pStatusChangedMenu = NULL;
 463
 464     {
 465         ResetableGuard aGuard( m_aLock );
 466
 467         std::vector< MenuItemHandler* >::iterator p;
 468         for ( p = m_aMenuItemHandlerVector.begin(); p != m_aMenuItemHandlerVector.end(); p++ )
 469         {
 470             MenuItemHandler* pMenuItemHandler = *p;
 471             if ( pMenuItemHandler->aMenuItemURL == aFeatureURL )
 472             {
 473                 pStatusChangedMenu = pMenuItemHandler;
 474                 break;
 475             }
 476         }
 477     }
 478
 479     if ( pStatusChangedMenu )
 480     {
 481         OGuard  aSolarGuard( Application::GetSolarMutex() );
 482         {
 483             ResetableGuard aGuard( m_aLock );
 484
 485             sal_Bool bSetCheckmark      = sal_False;
 486             sal_Bool bCheckmark                 = sal_False;
 487             sal_Bool bMenuItemEnabled   = m_pVCLMenu->IsItemEnabled( pStatusChangedMenu->nItemId );
 488
 489             if ( Event.IsEnabled != bMenuItemEnabled )
 490                 m_pVCLMenu->EnableItem( pStatusChangedMenu->nItemId, Event.IsEnabled );
 491
 492             if ( Event.State >>= bCheckmark )
 493                  bSetCheckmark = sal_True;
 494
 495             if ( bSetCheckmark )
 496                 m_pVCLMenu->CheckItem( pStatusChangedMenu->nItemId, bCheckmark );
 497         }
 498
 499         if ( Event.Requery )
 500         {
 501             URL aTargetURL;
 502             aTargetURL.Complete = pStatusChangedMenu->aMenuItemURL;
 503
 504             // #110897#
 505             m_xURLTransformer->parseStrict( aTargetURL );
 506
 507             REFERENCE< XDISPATCHPROVIDER > xDispatchProvider( m_xFrame, UNO_QUERY );
 508             REFERENCE< XDISPATCH > xMenuItemDispatch = xDispatchProvider->queryDispatch(
 509                                                             aTargetURL, ::rtl::OUString(), 0 );
 510
 511             if ( xMenuItemDispatch.is() )
 512             {
 513                 pStatusChangedMenu->xMenuItemDispatch   = xMenuItemDispatch;
 514                 pStatusChangedMenu->aMenuItemURL                = aTargetURL.Complete;
 515                 xMenuItemDispatch->addStatusListener( SAL_STATIC_CAST( XSTATUSLISTENER*, this ), aTargetURL );
 516             }
 517         }
 518     }
 519 }
 520
 521
 522 void MenuManager::RemoveListener()
 523 {
 524     ResetableGuard aGuard( m_aLock );
 525     ClearMenuDispatch();
 526 }
 527
 528 void MenuManager::ClearMenuDispatch(const EVENTOBJECT& Source,bool _bRemoveOnly)
 529 {
 530     // disposing called from parent dispatcher
 531     // remove all listener to prepare shutdown
 532
 533     // #110897#
 534     std::vector< MenuItemHandler* >::iterator p;
 535     for ( p = m_aMenuItemHandlerVector.begin(); p != m_aMenuItemHandlerVector.end(); p++ )
 536     {
 537         MenuItemHandler* pItemHandler = *p;
 538         if ( pItemHandler->xMenuItemDispatch.is() )
 539         {
 540             URL aTargetURL;
 541             aTargetURL.Complete = pItemHandler->aMenuItemURL;
 542             m_xURLTransformer->parseStrict( aTargetURL );
 543
 544             pItemHandler->xMenuItemDispatch->removeStatusListener(
 545                 SAL_STATIC_CAST( XSTATUSLISTENER*, this ), aTargetURL );
 546         }
 547
 548         pItemHandler->xMenuItemDispatch.clear();
 549         if ( pItemHandler->pSubMenuManager )
 550         {
 551             if ( _bRemoveOnly )
 552                 pItemHandler->pSubMenuManager->RemoveListener();
 553             else
 554                 pItemHandler->pSubMenuManager->disposing( Source );
 555         }
 556     }
 557 }
 558
 559
 560 void SAL_CALL MenuManager::disposing( const EVENTOBJECT& Source ) throw ( RUNTIMEEXCEPTION )
 561 {
 562     if ( Source.Source == m_xFrame )
 563     {
 564         ResetableGuard aGuard( m_aLock );
 565         ClearMenuDispatch(Source,false);
 566     }
 567     else
 568     {
 569         // disposing called from menu item dispatcher, remove listener
 570         MenuItemHandler* pMenuItemDisposing = NULL;
 571
 572         {
 573             ResetableGuard aGuard( m_aLock );
 574
 575             std::vector< MenuItemHandler* >::iterator p;
 576             for ( p = m_aMenuItemHandlerVector.begin(); p != m_aMenuItemHandlerVector.end(); p++ )
 577             {
 578                 MenuItemHandler* pMenuItemHandler = *p;
 579                 if ( pMenuItemHandler->xMenuItemDispatch == Source.Source )
 580                 {
 581                     pMenuItemDisposing = pMenuItemHandler;
 582                     break;
 583                 }
 584             }
 585
 586             if ( pMenuItemDisposing )
 587             {
 588                 URL aTargetURL;
 589                 aTargetURL.Complete     = pMenuItemDisposing->aMenuItemURL;
 590
 591                 // #110897#
 592                 m_xURLTransformer->parseStrict( aTargetURL );
 593
 594                 pMenuItemDisposing->xMenuItemDispatch->removeStatusListener(SAL_STATIC_CAST( XSTATUSLISTENER*, this ), aTargetURL );
 595                 pMenuItemDisposing->xMenuItemDispatch.clear();
 596             }
 597         }
 598     }
 599 }
 600
 601
 602 void MenuManager::UpdateSpecialFileMenu( Menu* pMenu )
 603 {
 604     // update picklist
 605     Sequence< Sequence< PropertyValue > > aHistoryList = SvtHistoryOptions().GetList( ePICKLIST );
 606     ::std::vector< MenuItemHandler* > aNewPickVector;
 607     Reference< XStringWidth > xStringLength( new StringLength );
 608
 609     USHORT      nPickItemId = START_ITEMID_PICKLIST;
 610     int         nPickListMenuItems = ( aHistoryList.getLength() > 99 ) ? 99 : aHistoryList.getLength();
 611
 612     aNewPickVector.reserve(nPickListMenuItems);
 613     for ( int i = 0; i < nPickListMenuItems; i++ )
 614     {
 615         Sequence< PropertyValue > aPickListEntry = aHistoryList[i];
 616
 617         REFERENCE< XDISPATCH > aXDispatchRef;
 618         MenuItemHandler* pNewMenuItemHandler = new MenuItemHandler(
 619                                                     nPickItemId++,
 620                                                     NULL,
 621                                                     aXDispatchRef );
 622
 623         for ( int j = 0; j < aPickListEntry.getLength(); j++ )
 624         {
 625             Any a = aPickListEntry[j].Value;
 626
 627             if ( aPickListEntry[j].Name == HISTORY_PROPERTYNAME_URL )
 628                 a >>= pNewMenuItemHandler->aMenuItemURL;
 629             else if ( aPickListEntry[j].Name == HISTORY_PROPERTYNAME_FILTER )
 630                 a >>= pNewMenuItemHandler->aFilter;
 631             else if ( aPickListEntry[j].Name == HISTORY_PROPERTYNAME_TITLE )
 632                 a >>= pNewMenuItemHandler->aTitle;
 633             else if ( aPickListEntry[j].Name == HISTORY_PROPERTYNAME_PASSWORD )
 634                 a >>= pNewMenuItemHandler->aPassword;
 635         }
 636
 637         aNewPickVector.push_back( pNewMenuItemHandler );
 638     }
 639
 640     if ( !aNewPickVector.empty() )
 641     {
 642         URL aTargetURL;
 643         REFERENCE< XDISPATCHPROVIDER > xDispatchProvider( m_xFrame, UNO_QUERY );
 644
 645         // #110897#
 646         REFERENCE< XDISPATCH > xMenuItemDispatch;
 647
 648         static const ::rtl::OUString s_sDefault(RTL_CONSTASCII_USTRINGPARAM("_default"));
 649         // query for dispatcher
 650         std::vector< MenuItemHandler* >::iterator p;
 651         for ( p = aNewPickVector.begin(); p != aNewPickVector.end(); p++ )
 652         {
 653             MenuItemHandler* pMenuItemHandler = *p;
 654
 655             aTargetURL.Complete = pMenuItemHandler->aMenuItemURL;
 656             m_xURLTransformer->parseStrict( aTargetURL );
 657
 658             if ( !xMenuItemDispatch.is() )
 659             {
 660                 // attention: this code assume that "_blank" can only be consumed by desktop service
 661                 xMenuItemDispatch = xDispatchProvider->queryDispatch( aTargetURL, s_sDefault, 0 );
 662             }
 663
 664             if ( xMenuItemDispatch.is() )
 665             {
 666                 pMenuItemHandler->xMenuItemDispatch = xMenuItemDispatch;
 667                 pMenuItemHandler->aMenuItemURL          = aTargetURL.Complete;
 668             }
 669         }
 670
 671         {
 672             ResetableGuard aGuard( m_aLock );
 673
 674             int nRemoveItemCount = 0;
 675             int nItemCount               = pMenu->GetItemCount();
 676
 677             if ( nItemCount > 0 )
 678             {
 679                 // remove all old picklist entries from menu
 680                 sal_uInt16 nPos = pMenu->GetItemPos( START_ITEMID_PICKLIST );
 681                 for ( sal_uInt16 n = nPos; n < pMenu->GetItemCount(); )
 682                 {
 683                     pMenu->RemoveItem( n );
 684                     ++nRemoveItemCount;
 685                 }
 686
 687                 if ( pMenu->GetItemType( pMenu->GetItemCount()-1 ) == MENUITEM_SEPARATOR )
 688                     pMenu->RemoveItem( pMenu->GetItemCount()-1 );
 689
 690                 // remove all old picklist entries from menu handler
 691                 if ( nRemoveItemCount > 0 )
 692                 {
 693                     for( sal_uInt32 nIndex = m_aMenuItemHandlerVector.size() - nRemoveItemCount;
 694                          nIndex < m_aMenuItemHandlerVector.size();  )
 695                     {
 696                         delete m_aMenuItemHandlerVector.at( nIndex );
 697                         m_aMenuItemHandlerVector.erase( m_aMenuItemHandlerVector.begin() + nIndex );
 698                     }
 699                 }
 700             }
 701
 702             // append new picklist menu entries
 703             aNewPickVector.reserve(aNewPickVector.size());
 704             pMenu->InsertSeparator();
 705             const sal_uInt32 nCount = aNewPickVector.size();
 706             for ( sal_uInt32 i = 0; i < nCount; i++ )
 707             {
 708                 char menuShortCut[5] = "~n: ";
 709
 710                 ::rtl::OUString aMenuShortCut;
 711                 if ( i <= 9 )
 712                 {
 713                     if ( i == 9 )
 714                         aMenuShortCut = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "1~0: " ));
 715                     else
 716                     {
 717                         menuShortCut[1] = (char)( '1' + i );
 718                         aMenuShortCut = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( menuShortCut ));
 719                     }
 720                 }
 721                 else
 722                 {
 723                     aMenuShortCut = rtl::OUString::valueOf((sal_Int32)( i + 1 ));
 724                     aMenuShortCut += rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ": " ));
 725                 }
 726
 727                 // Abbreviate URL
 728                 rtl::OUString   aURLString( aNewPickVector.at( i )->aMenuItemURL );
 729                 rtl::OUString   aTipHelpText;
 730                 rtl::OUString   aMenuTitle;
 731                 INetURLObject   aURL( aURLString );
 732
 733                 if ( aURL.GetProtocol() == INET_PROT_FILE )
 734                 {
 735                     // Do handle file URL differently => convert it to a system
 736                     // path and abbreviate it with a special function:
 737                     String aFileSystemPath( aURL.getFSysPath( INetURLObject::FSYS_DETECT ) );
 738
 739                     ::rtl::OUString     aSystemPath( aFileSystemPath );
 740                     ::rtl::OUString     aCompactedSystemPath;
 741
 742                     aTipHelpText = aSystemPath;
 743                     oslFileError nError = osl_abbreviateSystemPath( aSystemPath.pData, &aCompactedSystemPath.pData, 46, NULL );
 744                     if ( !nError )
 745                         aMenuTitle = String( aCompactedSystemPath );
 746                     else
 747                         aMenuTitle = aSystemPath;
 748                 }
 749                 else
 750                 {
 751                     // Use INetURLObject to abbreviate all other URLs
 752                     String      aShortURL;
 753                     aShortURL = aURL.getAbbreviated( xStringLength, 46, INetURLObject::DECODE_UNAMBIGUOUS );
 754                     aMenuTitle += aShortURL;
 755                     aTipHelpText = aURLString;
 756                 }
 757
 758                 ::rtl::OUString aTitle( aMenuShortCut + aMenuTitle );
 759
 760                 MenuItemHandler* pMenuItemHandler = aNewPickVector.at( i );
 761                 pMenu->InsertItem( pMenuItemHandler->nItemId, aTitle );
 762                 pMenu->SetTipHelpText( pMenuItemHandler->nItemId, aTipHelpText );
 763                 m_aMenuItemHandlerVector.push_back( pMenuItemHandler );
 764             }
 765         }
 766     }
 767 }
 768
 769 void MenuManager::UpdateSpecialWindowMenu( Menu* pMenu,const Reference< XMultiServiceFactory >& xServiceFactory,framework::IMutex& _rMutex )
 770 {
 771     // update window list
 772     ::std::vector< ::rtl::OUString > aNewWindowListVector;
 773
 774     // #110897#
 775     Reference< XDesktop > xDesktop( xServiceFactory->createInstance( SERVICENAME_DESKTOP ), UNO_QUERY );
 776
 777     USHORT      nActiveItemId = 0;
 778     USHORT      nItemId = START_ITEMID_WINDOWLIST;
 779
 780     if ( xDesktop.is() )
 781     {
 782         Reference< XFramesSupplier > xTasksSupplier( xDesktop, UNO_QUERY );
 783         Reference< XFrame > xCurrentFrame = xDesktop->getCurrentFrame();
 784         Reference< XIndexAccess > xList( xTasksSupplier->getFrames(), UNO_QUERY );
 785         sal_Int32 nCount = xList->getCount();
 786         aNewWindowListVector.reserve(nCount);
 787         for (sal_Int32 i=0; i<nCount; ++i )
 788         {
 789             Reference< XFrame > xFrame;
 790             xList->getByIndex(i) >>= xFrame;
 791
 792             if (xFrame.is())
 793             {
 794                 if ( xFrame == xCurrentFrame )
 795                     nActiveItemId = nItemId;
 796
 797                 Window* pWin = VCLUnoHelper::GetWindow( xFrame->getContainerWindow() );
 798                 if ( pWin && pWin->IsVisible() )
 799                 {
 800                     aNewWindowListVector.push_back( pWin->GetText() );
 801                     ++nItemId;
 802                 }
 803             }
 804         }
 805     }
 806
 807     {
 808         ResetableGuard aGuard( _rMutex );
 809
 810         int     nItemCount = pMenu->GetItemCount();
 811
 812         if ( nItemCount > 0 )
 813         {
 814             // remove all old window list entries from menu
 815             sal_uInt16 nPos = pMenu->GetItemPos( START_ITEMID_WINDOWLIST );
 816             for ( sal_uInt16 n = nPos; n < pMenu->GetItemCount(); )
 817                 pMenu->RemoveItem( n );
 818
 819             if ( pMenu->GetItemType( pMenu->GetItemCount()-1 ) == MENUITEM_SEPARATOR )
 820                 pMenu->RemoveItem( pMenu->GetItemCount()-1 );
 821         }
 822
 823         if ( !aNewWindowListVector.empty() )
 824         {
 825             // append new window list entries to menu
 826             pMenu->InsertSeparator();
 827             nItemId = START_ITEMID_WINDOWLIST;
 828             const sal_uInt32 nCount = aNewWindowListVector.size();
 829             for ( sal_uInt32 i = 0; i < nCount; i++ )
 830             {
 831                 pMenu->InsertItem( nItemId, aNewWindowListVector.at( i ), MIB_RADIOCHECK );
 832                 if ( nItemId == nActiveItemId )
 833                     pMenu->CheckItem( nItemId );
 834                 ++nItemId;
 835             }
 836         }
 837     }
 838 }
 839
 840
 841 void MenuManager::CreatePicklistArguments( Sequence< PropertyValue >& aArgsList, const MenuItemHandler* pMenuItemHandler )
 842 {
 843     int NUM_OF_PICKLIST_ARGS = 3;
 844
 845     Any a;
 846     aArgsList.realloc( NUM_OF_PICKLIST_ARGS );
 847
 848     aArgsList[0].Name = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "FileName" ));
 849     a <<= pMenuItemHandler->aMenuItemURL;
 850     aArgsList[0].Value = a;
 851
 852     aArgsList[1].Name = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Referer" ));
 853     a <<= ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( SFX_REFERER_USER ));
 854     aArgsList[1].Value = a;
 855
 856     ::rtl::OUString aFilter( pMenuItemHandler->aFilter );
 857
 858     sal_Int32 nPos = aFilter.indexOf( '|' );
 859     if ( nPos >= 0 )
 860     {
 861         ::rtl::OUString aFilterOptions;
 862
 863         if ( nPos < ( aFilter.getLength() - 1 ) )
 864             aFilterOptions = aFilter.copy( nPos+1 );
 865
 866         aArgsList[2].Name = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "FilterOptions" ));
 867         a <<= aFilterOptions;
 868         aArgsList[2].Value = a;
 869
 870         aFilter = aFilter.copy( 0, nPos-1 );
 871         aArgsList.realloc( ++NUM_OF_PICKLIST_ARGS );
 872     }
 873
 874     aArgsList[NUM_OF_PICKLIST_ARGS-1].Name = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "FilterName" ));
 875     a <<= aFilter;
 876     aArgsList[NUM_OF_PICKLIST_ARGS-1].Value = a;
 877 }
 878
 879
 880 //_________________________________________________________________________________________________________________
 881 // vcl handler
 882 //_________________________________________________________________________________________________________________
 883
 884 IMPL_LINK( MenuManager, Activate, Menu *, pMenu )
 885 {
 886     if ( pMenu == m_pVCLMenu )
 887     {
 888         // set/unset hiding disabled menu entries
 889         sal_Bool bDontHide                      = SvtMenuOptions().IsEntryHidingEnabled();
 890         const StyleSettings& rSettings = Application::GetSettings().GetStyleSettings();
 891         sal_Bool bShowMenuImages        = rSettings.GetUseImagesInMenus();
 892
 893         sal_uInt16 nFlag = pMenu->GetMenuFlags();
 894         if ( bDontHide )
 895             nFlag &= ~MENU_FLAG_HIDEDISABLEDENTRIES;
 896         else
 897             nFlag |= MENU_FLAG_HIDEDISABLEDENTRIES;
 898         pMenu->SetMenuFlags( nFlag );
 899
 900         if ( m_bActive )
 901             return 0;
 902
 903         m_bActive = TRUE;
 904
 905         ::rtl::OUString aCommand( m_aMenuItemCommand );
 906         if ( m_aMenuItemCommand.matchIgnoreAsciiCase( UNO_COMMAND, 0 ))
 907         {
 908             // Remove protocol part from command so we can use an easier comparision method
 909             aCommand = aCommand.copy( UNO_COMMAND.getLength() );
 910         }
 911
 912         if ( m_aMenuItemCommand == aSpecialFileMenu ||
 913              m_aMenuItemCommand == aSlotSpecialFileMenu ||
 914              aCommand == aSpecialFileCommand )
 915             UpdateSpecialFileMenu( pMenu );
 916         else if ( m_aMenuItemCommand == aSpecialWindowMenu ||
 917                   m_aMenuItemCommand == aSlotSpecialWindowMenu ||
 918                   aCommand == aSpecialWindowCommand )
 919                   UpdateSpecialWindowMenu( pMenu,getServiceFactory(),m_aLock );
 920
 921         // Check if some modes have changed so we have to update our menu images
 922         sal_Bool bIsHiContrast = rSettings.GetHighContrastMode();
 923
 924         if ( m_bWasHiContrast != bIsHiContrast || bShowMenuImages != m_bShowMenuImages )
 925         {
 926             // The mode changed so we have to replace all images
 927             m_bWasHiContrast    = bIsHiContrast;
 928             m_bShowMenuImages   = bShowMenuImages;
 929             FillMenuImages(m_xFrame,pMenu,bIsHiContrast,bShowMenuImages);
 930         }
 931
 932         if ( m_bInitialized )
 933             return 0;
 934         else
 935         {
 936             URL aTargetURL;
 937
 938             // #110897#
 939             ResetableGuard aGuard( m_aLock );
 940
 941             REFERENCE< XDISPATCHPROVIDER > xDispatchProvider( m_xFrame, UNO_QUERY );
 942             if ( xDispatchProvider.is() )
 943             {
 944                 std::vector< MenuItemHandler* >::iterator p;
 945                 for ( p = m_aMenuItemHandlerVector.begin(); p != m_aMenuItemHandlerVector.end(); p++ )
 946                 {
 947                     MenuItemHandler* pMenuItemHandler = *p;
 948                     if ( pMenuItemHandler &&
 949                          pMenuItemHandler->pSubMenuManager == 0 &&
 950                          !pMenuItemHandler->xMenuItemDispatch.is() )
 951                     {
 952                         // There is no dispatch mechanism for the special window list menu items,
 953                         // because they are handled directly through XFrame->activate!!!
 954                         if ( pMenuItemHandler->nItemId < START_ITEMID_WINDOWLIST ||
 955                              pMenuItemHandler->nItemId > END_ITEMID_WINDOWLIST )
 956                         {
 957                             ::rtl::OUString aItemCommand = pMenu->GetItemCommand( pMenuItemHandler->nItemId );
 958                             if ( !aItemCommand.getLength() )
 959                             {
 960                                 const static ::rtl::OUString aSlotString( RTL_CONSTASCII_USTRINGPARAM( "slot:" ));
 961                                 aItemCommand = aSlotString;
 962                                 aItemCommand += ::rtl::OUString::valueOf( (sal_Int32)pMenuItemHandler->nItemId );
 963                                 pMenu->SetItemCommand( pMenuItemHandler->nItemId, aItemCommand );
 964                             }
 965
 966                             aTargetURL.Complete = aItemCommand;
 967
 968                             m_xURLTransformer->parseStrict( aTargetURL );
 969
 970                             REFERENCE< XDISPATCH > xMenuItemDispatch;
 971                             if ( m_bIsBookmarkMenu )
 972                                 xMenuItemDispatch = xDispatchProvider->queryDispatch( aTargetURL, pMenuItemHandler->aTargetFrame, 0 );
 973                             else
 974                                 xMenuItemDispatch = xDispatchProvider->queryDispatch( aTargetURL, ::rtl::OUString(), 0 );
 975
 976                             if ( xMenuItemDispatch.is() )
 977                             {
 978                                 pMenuItemHandler->xMenuItemDispatch = xMenuItemDispatch;
 979                                 pMenuItemHandler->aMenuItemURL          = aTargetURL.Complete;
 980                                 xMenuItemDispatch->addStatusListener( SAL_STATIC_CAST( XSTATUSLISTENER*, this ), aTargetURL );
 981                             }
 982                             else
 983                                 pMenu->EnableItem( pMenuItemHandler->nItemId, sal_False );
 984                         }
 985                     }
 986                 }
 987             }
 988         }
 989     }
 990
 991     return 1;
 992 }
 993
 994
 995 IMPL_LINK( MenuManager, Deactivate, Menu *, pMenu )
 996 {
 997     if ( pMenu == m_pVCLMenu )
 998         m_bActive = sal_False;
 999
1000     return 1;
1001 }
1002
1003
1004 IMPL_LINK( MenuManager, Select, Menu *, pMenu )
1005 {
1006     URL                                         aTargetURL;
1007     Sequence<PropertyValue>     aArgs;
1008     REFERENCE< XDISPATCH >      xDispatch;
1009
1010     {
1011         ResetableGuard aGuard( m_aLock );
1012
1013         USHORT nCurItemId = pMenu->GetCurItemId();
1014         if ( pMenu == m_pVCLMenu &&
1015              pMenu->GetItemType( nCurItemId ) != MENUITEM_SEPARATOR )
1016         {
1017             if ( nCurItemId >= START_ITEMID_WINDOWLIST &&
1018                  nCurItemId <= END_ITEMID_WINDOWLIST )
1019             {
1020                 // window list menu item selected
1021
1022                 // #110897#
1023                 // Reference< XFramesSupplier > xDesktop( ::comphelper::getProcessServiceFactory()->createInstance(
1024                 //      DESKTOP_SERVICE ), UNO_QUERY );
1025                 Reference< XFramesSupplier > xDesktop( getServiceFactory()->createInstance( SERVICENAME_DESKTOP ), UNO_QUERY );
1026
1027                 if ( xDesktop.is() )
1028                 {
1029                     USHORT nTaskId = START_ITEMID_WINDOWLIST;
1030                     Reference< XIndexAccess > xList( xDesktop->getFrames(), UNO_QUERY );
1031                     sal_Int32 nCount = xList->getCount();
1032                     for ( sal_Int32 i=0; i<nCount; ++i )
1033                     {
1034                         Reference< XFrame > xFrame;
1035                         xList->getByIndex(i) >>= xFrame;
1036
1037                         if ( xFrame.is() && nTaskId == nCurItemId )
1038                         {
1039                             Window* pWin = VCLUnoHelper::GetWindow( xFrame->getContainerWindow() );
1040                             pWin->GrabFocus();
1041                             pWin->ToTop( TOTOP_RESTOREWHENMIN );
1042                             break;
1043                         }
1044
1045                         nTaskId++;
1046                     }
1047                 }
1048             }
1049             else
1050             {
1051                 MenuItemHandler* pMenuItemHandler = GetMenuItemHandler( nCurItemId );
1052                 if ( pMenuItemHandler && pMenuItemHandler->xMenuItemDispatch.is() )
1053                 {
1054                     aTargetURL.Complete = pMenuItemHandler->aMenuItemURL;
1055                     m_xURLTransformer->parseStrict( aTargetURL );
1056
1057                     if ( nCurItemId >= START_ITEMID_PICKLIST &&
1058                          nCurItemId <  START_ITEMID_WINDOWLIST )
1059                     {
1060                         // picklist menu item selected
1061                         CreatePicklistArguments( aArgs, pMenuItemHandler );
1062                     }
1063                     else if ( m_bIsBookmarkMenu )
1064                     {
1065                         // bookmark menu item selected
1066                         aArgs.realloc( 1 );
1067                         aArgs[0].Name = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Referer" ));
1068                         aArgs[0].Value <<= ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( SFX_REFERER_USER ));
1069                     }
1070
1071                     xDispatch = pMenuItemHandler->xMenuItemDispatch;
1072                 }
1073             }
1074         }
1075     }
1076
1077     if ( xDispatch.is() )
1078         xDispatch->dispatch( aTargetURL, aArgs );
1079
1080     return 1;
1081 }
1082
1083
1084 IMPL_LINK( MenuManager, Highlight, Menu *, EMPTYARG )
1085 {
1086     return 0;
1087 }
1088
1089 // #110897#
1090 const ::com::sun::star::uno::Reference< ::com::sun::star::lang::XMultiServiceFactory >& MenuManager::getServiceFactory()
1091 {
1092     // #110897#
1093     return mxServiceFactory;
1094 }
1095
1096 void MenuManager::AddMenu(PopupMenu* _pPopupMenu,const ::rtl::OUString& _sItemCommand,USHORT _nItemId,sal_Bool _bDelete,sal_Bool _bDeleteChildren)
1097 {
1098     MenuManager* pSubMenuManager = new MenuManager( getServiceFactory(), m_xFrame, _pPopupMenu, _bDelete, _bDeleteChildren );
1099
1100     // store menu item command as we later have to know which menu is active (see Activate handler)
1101     pSubMenuManager->m_aMenuItemCommand = _sItemCommand;
1102
1103     REFERENCE< XDISPATCH > aXDispatchRef;
1104     MenuItemHandler* pMenuItemHandler = new MenuItemHandler(
1105                                                 _nItemId,
1106                                                 pSubMenuManager,
1107                                                 aXDispatchRef );
1108     m_aMenuItemHandlerVector.push_back( pMenuItemHandler );
1109 }
1110
1111 USHORT MenuManager::FillItemCommand(::rtl::OUString& _rItemCommand,Menu* _pMenu,USHORT _nIndex) const
1112 {
1113     USHORT nItemId = _pMenu->GetItemId( _nIndex );
1114
1115     _rItemCommand = _pMenu->GetItemCommand( nItemId );
1116     if ( !_rItemCommand.getLength() )
1117     {
1118         const static ::rtl::OUString aSlotString( RTL_CONSTASCII_USTRINGPARAM( "slot:" ));
1119         _rItemCommand = aSlotString;
1120         _rItemCommand += ::rtl::OUString::valueOf( (sal_Int32)nItemId );
1121         _pMenu->SetItemCommand( nItemId, _rItemCommand );
1122     }
1123     return nItemId;
1124 }
1125 void MenuManager::FillMenuImages(Reference< XFrame >& _xFrame,Menu* _pMenu,sal_Bool bIsHiContrast,sal_Bool bShowMenuImages)
1126 {
1127     AddonsOptions               aAddonOptions;
1128
1129     for ( USHORT nPos = 0; nPos < _pMenu->GetItemCount(); nPos++ )
1130     {
1131         USHORT nId = _pMenu->GetItemId( nPos );
1132         if ( _pMenu->GetItemType( nPos ) != MENUITEM_SEPARATOR )
1133         {
1134             if ( bShowMenuImages )
1135             {
1136                 sal_Bool                bImageSet = sal_False;
1137                 ::rtl::OUString aImageId;
1138
1139                 ::framework::MenuConfiguration::Attributes* pMenuAttributes =
1140                     (::framework::MenuConfiguration::Attributes*)_pMenu->GetUserValue( nId );
1141
1142                 if ( pMenuAttributes )
1143                     aImageId = pMenuAttributes->aImageId; // Retrieve image id from menu attributes
1144
1145                 if ( aImageId.getLength() > 0 )
1146                 {
1147                     Image aImage = GetImageFromURL( _xFrame, aImageId, FALSE, bIsHiContrast );
1148                     if ( !!aImage )
1149                     {
1150                         bImageSet = sal_True;
1151                         _pMenu->SetItemImage( nId, aImage );
1152                     }
1153                 }
1154
1155                 if ( !bImageSet )
1156                 {
1157                     rtl::OUString aMenuItemCommand = _pMenu->GetItemCommand( nId );
1158                     Image aImage = GetImageFromURL( _xFrame, aMenuItemCommand, FALSE, bIsHiContrast );
1159                     if ( !aImage )
1160                         aImage = aAddonOptions.GetImageFromURL( aMenuItemCommand, FALSE, bIsHiContrast );
1161
1162                     _pMenu->SetItemImage( nId, aImage );
1163                 }
1164             }
1165             else
1166                 _pMenu->SetItemImage( nId, Image() );
1167         }
1168     }
1169 }
1170 }