framework/source/uielement/menubarmanager.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <uielement/menubarmanager.hxx>
  21 #include <uielement/styletoolbarcontroller.hxx>
  22 #include <menuconfiguration.hxx>
  23 #include <addonmenu.hxx>
  24 #include <framework/addonsoptions.hxx>
  25 #include <classes/fwkresid.hxx>
  26 #include <strings.hrc>
  27
  28 #include <com/sun/star/frame/XDispatch.hpp>
  29 #include <com/sun/star/lang/IndexOutOfBoundsException.hpp>
  30 #include <com/sun/star/lang/DisposedException.hpp>
  31 #include <com/sun/star/uno/XComponentContext.hpp>
  32 #include <com/sun/star/uno/XCurrentContext.hpp>
  33 #include <com/sun/star/frame/XPopupMenuController.hpp>
  34 #include <com/sun/star/frame/thePopupMenuControllerFactory.hpp>
  35 #include <com/sun/star/lang/SystemDependent.hpp>
  36 #include <com/sun/star/ui/GlobalAcceleratorConfiguration.hpp>
  37 #include <com/sun/star/ui/ItemType.hpp>
  38 #include <com/sun/star/ui/theModuleUIConfigurationManagerSupplier.hpp>
  39 #include <com/sun/star/ui/XUIConfigurationManagerSupplier.hpp>
  40 #include <com/sun/star/ui/ItemStyle.hpp>
  41 #include <com/sun/star/frame/status/Visibility.hpp>
  42 #include <com/sun/star/util/URLTransformer.hpp>
  43
  44 #include <comphelper/propertysequence.hxx>
  45 #include <comphelper/propertyvalue.hxx>
  46 #include <officecfg/Office/Common.hxx>
  47 #include <svtools/javainteractionhandler.hxx>
  48 #include <uno/current_context.hxx>
  49 #include <unotools/cmdoptions.hxx>
  50 #include <toolkit/awt/vclxmenu.hxx>
  51 #include <utility>
  52 #include <vcl/svapp.hxx>
  53 #include <vcl/sysdata.hxx>
  54 #include <vcl/menu.hxx>
  55 #include <vcl/settings.hxx>
  56 #include <vcl/commandinfoprovider.hxx>
  57 #include <sal/log.hxx>
  58 #include <svtools/acceleratorexecute.hxx>
  59 #include <svtools/miscopt.hxx>
  60 #include <uielement/menubarmerger.hxx>
  61 #include <tools/urlobj.hxx>
  62
  63 using namespace ::cppu;
  64 using namespace ::com::sun::star;
  65 using namespace ::com::sun::star::uno;
  66 using namespace ::com::sun::star::util;
  67 using namespace ::com::sun::star::beans;
  68 using namespace ::com::sun::star::frame;
  69 using namespace ::com::sun::star::container;
  70 using namespace ::com::sun::star::lang;
  71 using namespace ::com::sun::star::ui;
  72
  73 const sal_uInt16 ADDONMENU_MERGE_ITEMID_START = 1500;
  74 const sal_uInt16 ITEMID_ADDONLIST             = 6678; // used to be a SID in sfx2, now just a unique id...
  75
  76 namespace framework
  77 {
  78
  79 constexpr OUStringLiteral aCmdHelpIndex = u".uno:HelpIndex";
  80 constexpr OUStringLiteral aCmdToolsMenu = u".uno:ToolsMenu";
  81 constexpr OUStringLiteral aCmdHelpMenu = u".uno:HelpMenu";
  82 constexpr OUStringLiteral aSpecialWindowCommand = u".uno:WindowList";
  83
  84 MenuBarManager::MenuBarManager(
  85     const Reference< XComponentContext >& rxContext,
  86     const Reference< XFrame >& rFrame,
  87     const Reference< XURLTransformer >& _xURLTransformer,
  88     const Reference< XDispatchProvider >& rDispatchProvider,
  89     const OUString& rModuleIdentifier,
  90     Menu* pMenu, bool bDelete, bool bHasMenuBar ):
  91       m_bRetrieveImages( false )
  92     , m_bAcceleratorCfg( false )
  93     , m_bHasMenuBar( bHasMenuBar )
  94     , m_xContext(rxContext)
  95     , m_xURLTransformer(_xURLTransformer)
  96     , m_sIconTheme( SvtMiscOptions::GetIconTheme() )
  97     , m_aAsyncSettingsTimer( "framework::MenuBarManager::Deactivate m_aAsyncSettingsTimer" )
  98 {
  99     m_xPopupMenuControllerFactory = frame::thePopupMenuControllerFactory::get(m_xContext);
 100     FillMenuManager( pMenu, rFrame, rDispatchProvider, rModuleIdentifier, bDelete );
 101 }
 102
 103 Any SAL_CALL MenuBarManager::getMenuHandle( const Sequence< sal_Int8 >& /*ProcessId*/, sal_Int16 SystemType )
 104 {
 105     SolarMutexGuard aSolarGuard;
 106
 107     if ( m_bDisposed )
 108         throw css::lang::DisposedException();
 109
 110     Any a;
 111
 112     if ( m_pVCLMenu )
 113     {
 114         SystemMenuData aSystemMenuData;
 115
 116         m_pVCLMenu->GetSystemMenuData( &aSystemMenuData );
 117 #ifdef _WIN32
 118         if( SystemType == SystemDependent::SYSTEM_WIN32 )
 119         {
 120             a <<= sal_Int64(
 121                 reinterpret_cast<sal_IntPtr>(aSystemMenuData.hMenu));
 122         }
 123 #else
 124         (void) SystemType;
 125 #endif
 126     }
 127
 128     return a;
 129 }
 130
 131 MenuBarManager::~MenuBarManager()
 132 {
 133     // stop asynchronous settings timer
 134     m_xDeferredItemContainer.clear();
 135     m_aAsyncSettingsTimer.Stop();
 136
 137     SAL_WARN_IF( OWeakObject::m_refCount != 0, "fwk.uielement", "Who wants to delete an object with refcount > 0!" );
 138 }
 139
 140 // XComponent
 141 void MenuBarManager::disposing(std::unique_lock<std::mutex>& )
 142 {
 143     Reference< XComponent > xThis( this );
 144
 145     SolarMutexGuard g;
 146
 147     // stop asynchronous settings timer and
 148     // release deferred item container reference
 149     m_aAsyncSettingsTimer.Stop();
 150     m_xDeferredItemContainer.clear();
 151     RemoveListener();
 152
 153     m_aMenuItemHandlerVector.clear();
 154
 155     if ( m_bDeleteMenu )
 156     {
 157         m_pVCLMenu.disposeAndClear();
 158     }
 159
 160     if ( m_xDocImageManager.is() )
 161     {
 162         try
 163         {
 164             m_xDocImageManager->removeConfigurationListener(
 165                 Reference< XUIConfigurationListener >(this) );
 166         }
 167         catch ( const Exception& )
 168         {
 169         }
 170     }
 171     if ( m_xModuleImageManager.is() )
 172     {
 173         try
 174         {
 175             m_xModuleImageManager->removeConfigurationListener(
 176                 Reference< XUIConfigurationListener >(this) );
 177         }
 178         catch ( const Exception& )
 179         {
 180         }
 181     }
 182     m_xDocImageManager.clear();
 183     m_xModuleImageManager.clear();
 184     m_xGlobalAcceleratorManager.clear();
 185     m_xModuleAcceleratorManager.clear();
 186     m_xDocAcceleratorManager.clear();
 187     m_xPopupMenuControllerFactory.clear();
 188     m_xContext.clear();
 189 }
 190
 191 void SAL_CALL MenuBarManager::elementInserted( const css::ui::ConfigurationEvent& Event )
 192 {
 193     SolarMutexGuard g;
 194
 195     /* SAFE AREA ----------------------------------------------------------------------------------------------- */
 196     if ( m_bDisposed )
 197         return;
 198
 199     sal_Int16 nImageType = sal_Int16();
 200     if (( Event.aInfo >>= nImageType ) && nImageType == 0 )
 201         RequestImages();
 202 }
 203
 204 void SAL_CALL MenuBarManager::elementRemoved( const css::ui::ConfigurationEvent& Event )
 205 {
 206     elementInserted(Event);
 207 }
 208
 209 void SAL_CALL MenuBarManager::elementReplaced( const css::ui::ConfigurationEvent& Event )
 210 {
 211     elementInserted(Event);
 212 }
 213
 214 // XFrameActionListener
 215 void SAL_CALL MenuBarManager::frameAction( const FrameActionEvent& Action )
 216 {
 217     SolarMutexGuard g;
 218
 219     if ( m_bDisposed )
 220         throw css::lang::DisposedException();
 221
 222     if ( Action.Action != FrameAction_CONTEXT_CHANGED )
 223         return;
 224
 225     for (auto const& menuItemHandler : m_aMenuItemHandlerVector)
 226     {
 227         // Clear dispatch reference as we will requery it later
 228         if ( menuItemHandler->xMenuItemDispatch.is() )
 229         {
 230             URL aTargetURL;
 231             aTargetURL.Complete = menuItemHandler->aMenuItemURL;
 232             m_xURLTransformer->parseStrict( aTargetURL );
 233
 234             menuItemHandler->xMenuItemDispatch->removeStatusListener( this, aTargetURL );
 235         }
 236         menuItemHandler->xMenuItemDispatch.clear();
 237     }
 238 }
 239
 240 // XStatusListener
 241 void SAL_CALL MenuBarManager::statusChanged( const FeatureStateEvent& Event )
 242 {
 243     OUString aFeatureURL = Event.FeatureURL.Complete;
 244
 245     SolarMutexGuard aSolarGuard;
 246     {
 247         if ( m_bDisposed )
 248             return;
 249
 250         // We have to check all menu entries as there can be identical entries in a popup menu.
 251         for (auto const& menuItemHandler : m_aMenuItemHandlerVector)
 252         {
 253             if ( menuItemHandler->aParsedItemURL == aFeatureURL )
 254             {
 255                 bool            bCheckmark( false );
 256                 bool            bMenuItemEnabled( m_pVCLMenu->IsItemEnabled( menuItemHandler->nItemId ));
 257                 bool            bEnabledItem( Event.IsEnabled );
 258                 OUString       aItemText;
 259                 status::Visibility  aVisibilityStatus;
 260
 261                 #ifdef UNIX
 262                 //enable some slots hardly, because UNIX clipboard does not notify all changes
 263                 // Can be removed if follow up task will be fixed directly within applications.
 264                 // Note: PasteSpecial is handled specifically by calc
 265                 // Calc also disables Paste under some circumstances, do not override.
 266                 /* TODO: is this workaround even needed anymore? Was introduced
 267                  * in 2009 with commit 426ab2c0e8f6e3fe2b766f74f6b8da873d860260
 268                  * as some "metropatch" and the other places it touched seem to
 269                  * be gone. */
 270                 if ( (menuItemHandler->aMenuItemURL == ".uno:Paste" &&
 271                             m_aModuleIdentifier != "com.sun.star.sheet.SpreadsheetDocument")
 272                         || menuItemHandler->aMenuItemURL == ".uno:PasteClipboard" )    // special for draw/impress
 273                     bEnabledItem = true;
 274                 #endif
 275
 276                 // Enable/disable item
 277                 if ( bEnabledItem != bMenuItemEnabled )
 278                 {
 279                     m_pVCLMenu->EnableItem( menuItemHandler->nItemId, bEnabledItem );
 280
 281                     // Remove "checked" mark for disabled menu items.
 282                     // Initially disabled but checkable menu items do not receive
 283                     // checked/unchecked state, so can appear inconsistently after
 284                     // enabling/disabling. Since we can not pass checked state for disabled
 285                     // items, we will just reset checked state for them, anyway correct state
 286                     // will be transferred from controller once item enabled.
 287                     if ( !bEnabledItem && m_pVCLMenu->IsItemChecked( menuItemHandler->nItemId ) )
 288                         m_pVCLMenu->CheckItem( menuItemHandler->nItemId, false );
 289                 }
 290
 291                 if ( Event.State >>= bCheckmark )
 292                 {
 293                     // Checkmark or RadioButton
 294                     m_pVCLMenu->CheckItem( menuItemHandler->nItemId, bCheckmark );
 295                     // If not already designated RadioButton set as CheckMark
 296                     MenuItemBits nBits = m_pVCLMenu->GetItemBits( menuItemHandler->nItemId );
 297                     if (!(nBits & MenuItemBits::RADIOCHECK))
 298                         m_pVCLMenu->SetItemBits( menuItemHandler->nItemId, nBits | MenuItemBits::CHECKABLE );
 299
 300                     if ( menuItemHandler->bMadeInvisible )
 301                         m_pVCLMenu->ShowItem( menuItemHandler->nItemId );
 302                 }
 303                 else if ( Event.State >>= aItemText )
 304                 {
 305                     INetURLObject aURL( aFeatureURL );
 306                     OUString aEnumPart = aURL.GetURLPath().getToken( 1, '.' );
 307                     if ( !aEnumPart.isEmpty() && aURL.GetProtocol() == INetProtocol::Uno )
 308                     {
 309                         // Checkmark or RadioButton
 310                         m_pVCLMenu->CheckItem( menuItemHandler->nItemId, aItemText == aEnumPart );
 311                         // If not already designated RadioButton set as CheckMark
 312                         MenuItemBits nBits = m_pVCLMenu->GetItemBits( menuItemHandler->nItemId );
 313                         if (!(nBits & MenuItemBits::RADIOCHECK))
 314                             m_pVCLMenu->SetItemBits( menuItemHandler->nItemId, nBits | MenuItemBits::CHECKABLE );
 315                     }
 316                     else
 317                     {
 318                         // Replacement for place holders
 319                         if ( aItemText.startsWith("($1)") )
 320                         {
 321                             aItemText = FwkResId(STR_UPDATEDOC) + " " + aItemText.subView( 4 );
 322                         }
 323                         else if ( aItemText.startsWith("($2)") )
 324                         {
 325                             aItemText = FwkResId(STR_CLOSEDOC_ANDRETURN) + aItemText.subView( 4 );
 326                         }
 327                         else if ( aItemText.startsWith("($3)") )
 328                         {
 329                             aItemText = FwkResId(STR_SAVECOPYDOC) + aItemText.subView( 4 );
 330                         }
 331
 332                         m_pVCLMenu->SetItemText( menuItemHandler->nItemId, aItemText );
 333                     }
 334
 335                     if ( menuItemHandler->bMadeInvisible )
 336                         m_pVCLMenu->ShowItem( menuItemHandler->nItemId );
 337                 }
 338                 else if ( Event.State >>= aVisibilityStatus )
 339                 {
 340                     // Visibility
 341                     m_pVCLMenu->ShowItem( menuItemHandler->nItemId, aVisibilityStatus.bVisible );
 342                     menuItemHandler->bMadeInvisible = !aVisibilityStatus.bVisible;
 343                 }
 344                 else if ( menuItemHandler->bMadeInvisible )
 345                     m_pVCLMenu->ShowItem( menuItemHandler->nItemId );
 346             }
 347
 348             if ( Event.Requery )
 349             {
 350                 // Release dispatch object - will be required on the next activate!
 351                 menuItemHandler->xMenuItemDispatch.clear();
 352             }
 353         }
 354     }
 355 }
 356
 357 // Helper to retrieve own structure from item ID
 358 MenuBarManager::MenuItemHandler* MenuBarManager::GetMenuItemHandler( sal_uInt16 nItemId )
 359 {
 360     SolarMutexGuard g;
 361
 362     for (auto const& menuItemHandler : m_aMenuItemHandlerVector)
 363     {
 364         if ( menuItemHandler->nItemId == nItemId )
 365             return menuItemHandler.get();
 366     }
 367
 368     return nullptr;
 369 }
 370
 371 // Helper to set request images flag
 372 void MenuBarManager::RequestImages()
 373 {
 374
 375     m_bRetrieveImages = true;
 376     for (auto const& menuItemHandler : m_aMenuItemHandlerVector)
 377     {
 378         if ( menuItemHandler->xSubMenuManager.is() )
 379         {
 380             MenuBarManager* pMenuBarManager = static_cast<MenuBarManager*>(menuItemHandler->xSubMenuManager.get());
 381             pMenuBarManager->RequestImages();
 382         }
 383     }
 384 }
 385
 386 // Helper to reset objects to prepare shutdown
 387 void MenuBarManager::RemoveListener()
 388 {
 389     SolarMutexGuard g;
 390
 391     for (auto const& menuItemHandler : m_aMenuItemHandlerVector)
 392     {
 393         if ( menuItemHandler->xMenuItemDispatch.is() )
 394         {
 395             URL aTargetURL;
 396             aTargetURL.Complete = menuItemHandler->aMenuItemURL;
 397             m_xURLTransformer->parseStrict( aTargetURL );
 398
 399             menuItemHandler->xMenuItemDispatch->removeStatusListener(
 400                 static_cast< XStatusListener* >( this ), aTargetURL );
 401         }
 402
 403         menuItemHandler->xMenuItemDispatch.clear();
 404
 405         if ( menuItemHandler->xPopupMenu.is() )
 406         {
 407             {
 408                 // Remove popup menu from menu structure
 409                 m_pVCLMenu->SetPopupMenu( menuItemHandler->nItemId, nullptr );
 410             }
 411
 412             Reference< css::lang::XEventListener > xEventListener( menuItemHandler->xPopupMenuController, UNO_QUERY );
 413             if ( xEventListener.is() )
 414             {
 415                 EventObject aEventObject;
 416                 aEventObject.Source = static_cast<OWeakObject *>(this);
 417                 xEventListener->disposing( aEventObject );
 418             }
 419
 420             // We now provide a popup menu controller to external code.
 421             // Therefore the life-time must be explicitly handled via
 422             // dispose!!
 423             try
 424             {
 425                 Reference< XComponent > xComponent( menuItemHandler->xPopupMenuController, UNO_QUERY );
 426                 if ( xComponent.is() )
 427                     xComponent->dispose();
 428             }
 429             catch ( const RuntimeException& )
 430             {
 431                 throw;
 432             }
 433             catch ( const Exception& )
 434             {
 435             }
 436
 437             // Release references to controller and popup menu
 438             menuItemHandler->xPopupMenuController.clear();
 439             menuItemHandler->xPopupMenu.clear();
 440         }
 441
 442         Reference< XComponent > xComponent( menuItemHandler->xSubMenuManager, UNO_QUERY );
 443         if ( xComponent.is() )
 444             xComponent->dispose();
 445     }
 446
 447     try
 448     {
 449         if ( m_xFrame.is() )
 450             m_xFrame->removeFrameActionListener( Reference< XFrameActionListener >(this) );
 451     }
 452     catch ( const Exception& )
 453     {
 454     }
 455
 456     m_xFrame = nullptr;
 457 }
 458
 459 void SAL_CALL MenuBarManager::disposing( const EventObject& Source )
 460 {
 461     MenuItemHandler* pMenuItemDisposing = nullptr;
 462
 463     SolarMutexGuard g;
 464
 465     for (auto const& menuItemHandler : m_aMenuItemHandlerVector)
 466     {
 467         if ( menuItemHandler->xMenuItemDispatch.is() &&
 468              menuItemHandler->xMenuItemDispatch == Source.Source )
 469         {
 470             // disposing called from menu item dispatcher, remove listener
 471             pMenuItemDisposing = menuItemHandler.get();
 472             break;
 473         }
 474     }
 475
 476     if ( pMenuItemDisposing )
 477     {
 478         // Release references to the dispatch object
 479         URL aTargetURL;
 480         aTargetURL.Complete = pMenuItemDisposing->aMenuItemURL;
 481
 482         m_xURLTransformer->parseStrict( aTargetURL );
 483
 484         pMenuItemDisposing->xMenuItemDispatch->removeStatusListener(
 485             static_cast< XStatusListener* >( this ), aTargetURL );
 486         pMenuItemDisposing->xMenuItemDispatch.clear();
 487         if ( pMenuItemDisposing->xPopupMenu.is() )
 488         {
 489             Reference< css::lang::XEventListener > xEventListener( pMenuItemDisposing->xPopupMenuController, UNO_QUERY );
 490             if ( xEventListener.is() )
 491                 xEventListener->disposing( Source );
 492
 493             {
 494                 // Remove popup menu from menu structure as we release our reference to
 495                 // the controller.
 496                 m_pVCLMenu->SetPopupMenu( pMenuItemDisposing->nItemId, nullptr );
 497             }
 498
 499             pMenuItemDisposing->xPopupMenuController.clear();
 500             pMenuItemDisposing->xPopupMenu.clear();
 501         }
 502         return;
 503     }
 504     else if ( Source.Source == m_xFrame )
 505     {
 506         // Our frame gets disposed. We have to remove all our listeners
 507         RemoveListener();
 508     }
 509     else if ( Source.Source == Reference< XInterface >( m_xDocImageManager, UNO_QUERY ))
 510         m_xDocImageManager.clear();
 511     else if ( Source.Source == Reference< XInterface >( m_xModuleImageManager, UNO_QUERY ))
 512         m_xModuleImageManager.clear();
 513 }
 514
 515 static void lcl_CheckForChildren(Menu* pMenu, sal_uInt16 nItemId)
 516 {
 517     if (PopupMenu* pThisPopup = pMenu->GetPopupMenu( nItemId ))
 518         pMenu->EnableItem( nItemId, pThisPopup->GetItemCount() != 0 );
 519 }
 520
 521 // vcl handler
 522
 523 namespace {
 524
 525 class QuietInteractionContext:
 526     public cppu::WeakImplHelper< css::uno::XCurrentContext >
 527 {
 528 public:
 529     explicit QuietInteractionContext(
 530         css::uno::Reference< css::uno::XCurrentContext > context):
 531         context_(std::move(context)) {}
 532     QuietInteractionContext(const QuietInteractionContext&) = delete;
 533     QuietInteractionContext& operator=(const QuietInteractionContext&) = delete;
 534
 535 private:
 536     virtual ~QuietInteractionContext() override {}
 537
 538     virtual css::uno::Any SAL_CALL getValueByName(
 539         OUString const & Name) override
 540     {
 541         return Name != JAVA_INTERACTION_HANDLER_NAME && context_.is()
 542             ? context_->getValueByName(Name)
 543             : css::uno::Any();
 544     }
 545
 546     css::uno::Reference< css::uno::XCurrentContext >
 547         context_;
 548 };
 549
 550 }
 551
 552 IMPL_LINK( MenuBarManager, Activate, Menu *, pMenu, bool )
 553 {
 554     if ( pMenu != m_pVCLMenu )
 555         return true;
 556
 557     css::uno::ContextLayer layer(
 558         new QuietInteractionContext(
 559             css::uno::getCurrentContext()));
 560
 561     // set/unset hiding disabled menu entries
 562     bool bDontHide           = officecfg::Office::Common::View::Menu::DontHideDisabledEntry::get();
 563     const StyleSettings& rSettings = Application::GetSettings().GetStyleSettings();
 564     bool bShowMenuImages     = rSettings.GetUseImagesInMenus();
 565     bool bShowShortcuts      = m_bHasMenuBar || rSettings.GetContextMenuShortcuts();
 566     bool bHasDisabledEntries = SvtCommandOptions().HasEntriesDisabled();
 567
 568     SolarMutexGuard g;
 569
 570     MenuFlags nFlag = pMenu->GetMenuFlags();
 571     if ( bDontHide )
 572         nFlag &= ~MenuFlags::HideDisabledEntries;
 573     else
 574         nFlag |= MenuFlags::HideDisabledEntries;
 575     pMenu->SetMenuFlags( nFlag );
 576
 577     if ( m_bActive )
 578         return false;
 579
 580     m_bActive = true;
 581
 582     // Check if some modes have changed so we have to update our menu images
 583     OUString sIconTheme = SvtMiscOptions::GetIconTheme();
 584
 585     if ( m_bRetrieveImages ||
 586          bShowMenuImages != m_bShowMenuImages ||
 587          sIconTheme != m_sIconTheme )
 588     {
 589         m_bShowMenuImages   = bShowMenuImages;
 590         m_bRetrieveImages   = false;
 591         m_sIconTheme     = sIconTheme;
 592         FillMenuImages( m_xFrame, pMenu, bShowMenuImages );
 593     }
 594
 595     // Try to map commands to labels
 596     for ( sal_uInt16 nPos = 0; nPos < pMenu->GetItemCount(); nPos++ )
 597     {
 598         sal_uInt16 nItemId = pMenu->GetItemId( nPos );
 599         if (( pMenu->GetItemType( nPos ) != MenuItemType::SEPARATOR ) &&
 600             ( pMenu->GetItemText( nItemId ).isEmpty() ))
 601         {
 602             OUString aCommand = pMenu->GetItemCommand( nItemId );
 603             if ( !aCommand.isEmpty() ) {
 604                 pMenu->SetItemText( nItemId, RetrieveLabelFromCommand( aCommand ));
 605             }
 606         }
 607     }
 608
 609     // Try to set accelerator keys
 610     {
 611         if ( bShowShortcuts )
 612             RetrieveShortcuts( m_aMenuItemHandlerVector );
 613
 614         for (auto const& menuItemHandler : m_aMenuItemHandlerVector)
 615         {
 616             if ( !bShowShortcuts )
 617             {
 618                 pMenu->SetAccelKey( menuItemHandler->nItemId, vcl::KeyCode() );
 619             }
 620             else if ( menuItemHandler->aMenuItemURL == aCmdHelpIndex )
 621             {
 622                 // Set key code, workaround for hard-coded shortcut F1 mapped to .uno:HelpIndex
 623                 // Only non-popup menu items can have a short-cut
 624                 vcl::KeyCode aKeyCode( KEY_F1 );
 625                 pMenu->SetAccelKey( menuItemHandler->nItemId, aKeyCode );
 626             }
 627             else if ( pMenu->GetPopupMenu( menuItemHandler->nItemId ) == nullptr )
 628                 pMenu->SetAccelKey( menuItemHandler->nItemId, menuItemHandler->aKeyCode );
 629         }
 630     }
 631
 632     URL aTargetURL;
 633
 634     // Use provided dispatch provider => fallback to frame as dispatch provider
 635     Reference< XDispatchProvider > xDispatchProvider;
 636     if ( m_xDispatchProvider.is() )
 637         xDispatchProvider = m_xDispatchProvider;
 638     else
 639         xDispatchProvider.set( m_xFrame, UNO_QUERY );
 640
 641     if ( !xDispatchProvider.is() )
 642         return true;
 643
 644     SvtCommandOptions aCmdOptions;
 645     for (auto const& menuItemHandler : m_aMenuItemHandlerVector)
 646     {
 647         if (menuItemHandler)
 648         {
 649             if ( !menuItemHandler->xMenuItemDispatch.is() &&
 650                  !menuItemHandler->xSubMenuManager.is()      )
 651             {
 652                 Reference< XDispatch > xMenuItemDispatch;
 653
 654                 aTargetURL.Complete = menuItemHandler->aMenuItemURL;
 655
 656                 m_xURLTransformer->parseStrict( aTargetURL );
 657
 658                 if ( bHasDisabledEntries )
 659                 {
 660                     if ( aCmdOptions.LookupDisabled( aTargetURL.Path ))
 661                         pMenu->HideItem( menuItemHandler->nItemId );
 662                 }
 663
 664                 if ( aTargetURL.Complete.startsWith( ".uno:StyleApply?" ) )
 665                     xMenuItemDispatch = new StyleDispatcher( m_xFrame, m_xURLTransformer, aTargetURL );
 666                 else
 667                     xMenuItemDispatch = xDispatchProvider->queryDispatch( aTargetURL, menuItemHandler->aTargetFrame, 0 );
 668
 669                 bool bPopupMenu( false );
 670                 if ( !menuItemHandler->xPopupMenuController.is() &&
 671                      m_xPopupMenuControllerFactory->hasController( menuItemHandler->aMenuItemURL, m_aModuleIdentifier ) )
 672                 {
 673                     if( xMenuItemDispatch.is() || menuItemHandler->aMenuItemURL != ".uno:RecentFileList" )
 674                         bPopupMenu = CreatePopupMenuController(menuItemHandler.get(), m_xDispatchProvider, m_aModuleIdentifier);
 675                 }
 676                 else if ( menuItemHandler->xPopupMenuController.is() )
 677                 {
 678                     // Force update of popup menu
 679                     menuItemHandler->xPopupMenuController->updatePopupMenu();
 680                     bPopupMenu = true;
 681                     if (PopupMenu*  pThisPopup = pMenu->GetPopupMenu( menuItemHandler->nItemId ))
 682                         pMenu->EnableItem( menuItemHandler->nItemId, pThisPopup->GetItemCount() != 0 );
 683                 }
 684                 lcl_CheckForChildren(pMenu, menuItemHandler->nItemId);
 685
 686                 if ( xMenuItemDispatch.is() )
 687                 {
 688                     menuItemHandler->xMenuItemDispatch = xMenuItemDispatch;
 689                     menuItemHandler->aParsedItemURL    = aTargetURL.Complete;
 690
 691                     if ( !bPopupMenu )
 692                     {
 693                         xMenuItemDispatch->addStatusListener( static_cast< XStatusListener* >( this ), aTargetURL );
 694                         // For the menubar, we have to keep status listening to support Ubuntu's HUD.
 695                         if ( !m_bHasMenuBar )
 696                             xMenuItemDispatch->removeStatusListener( static_cast< XStatusListener* >( this ), aTargetURL );
 697                     }
 698                 }
 699                 else if ( !bPopupMenu )
 700                     pMenu->EnableItem( menuItemHandler->nItemId, false );
 701             }
 702             else if ( menuItemHandler->xPopupMenuController.is() )
 703             {
 704                 // Force update of popup menu
 705                 menuItemHandler->xPopupMenuController->updatePopupMenu();
 706                 lcl_CheckForChildren(pMenu, menuItemHandler->nItemId);
 707             }
 708             else if ( menuItemHandler->xMenuItemDispatch.is() )
 709             {
 710                 // We need an update to reflect the current state
 711                 try
 712                 {
 713                     aTargetURL.Complete = menuItemHandler->aMenuItemURL;
 714                     m_xURLTransformer->parseStrict( aTargetURL );
 715
 716                     menuItemHandler->xMenuItemDispatch->addStatusListener(
 717                                                             static_cast< XStatusListener* >( this ), aTargetURL );
 718                     menuItemHandler->xMenuItemDispatch->removeStatusListener(
 719                                                             static_cast< XStatusListener* >( this ), aTargetURL );
 720                 }
 721                 catch ( const Exception& )
 722                 {
 723                 }
 724             }
 725             else if ( menuItemHandler->xSubMenuManager.is() )
 726                 lcl_CheckForChildren(pMenu, menuItemHandler->nItemId);
 727         }
 728     }
 729
 730     return true;
 731 }
 732
 733 IMPL_LINK( MenuBarManager, Deactivate, Menu *, pMenu, bool )
 734 {
 735     if ( pMenu == m_pVCLMenu )
 736     {
 737         m_bActive = false;
 738         if ( pMenu->IsMenuBar() && m_xDeferredItemContainer.is() )
 739         {
 740             // Start timer to handle settings asynchronous
 741             // Changing the menu inside this handler leads to
 742             // a crash under X!
 743             m_aAsyncSettingsTimer.SetInvokeHandler(LINK(this, MenuBarManager, AsyncSettingsHdl));
 744             m_aAsyncSettingsTimer.SetTimeout(10);
 745             m_aAsyncSettingsTimer.Start();
 746         }
 747     }
 748
 749     return true;
 750 }
 751
 752 IMPL_LINK_NOARG( MenuBarManager, AsyncSettingsHdl, Timer*, void)
 753 {
 754     SolarMutexGuard g;
 755     Reference< XInterface > xSelfHold(
 756         static_cast< ::cppu::OWeakObject* >( this ), UNO_QUERY_THROW );
 757
 758     m_aAsyncSettingsTimer.Stop();
 759     if ( !m_bActive && m_xDeferredItemContainer.is() )
 760     {
 761         SetItemContainer( m_xDeferredItemContainer );
 762         m_xDeferredItemContainer.clear();
 763     }
 764 }
 765
 766 IMPL_LINK( MenuBarManager, Select, Menu *, pMenu, bool )
 767 {
 768     URL                     aTargetURL;
 769     Sequence<PropertyValue> aArgs;
 770     Reference< XDispatch >  xDispatch;
 771
 772     {
 773         SolarMutexGuard g;
 774
 775         sal_uInt16 nCurItemId = pMenu->GetCurItemId();
 776         sal_uInt16 nCurPos    = pMenu->GetItemPos( nCurItemId );
 777         if ( pMenu == m_pVCLMenu &&
 778              pMenu->GetItemType( nCurPos ) != MenuItemType::SEPARATOR )
 779         {
 780             MenuItemHandler* pMenuItemHandler = GetMenuItemHandler( nCurItemId );
 781             if ( pMenuItemHandler && pMenuItemHandler->xMenuItemDispatch.is() )
 782             {
 783                 aTargetURL.Complete = pMenuItemHandler->aMenuItemURL;
 784                 m_xURLTransformer->parseStrict( aTargetURL );
 785
 786                 if ( pMenu->GetUserValue( nCurItemId ) )
 787                 {
 788                     // addon menu item selected
 789                     aArgs = { comphelper::makePropertyValue("Referer", OUString("private:user")) };
 790                 }
 791
 792                 xDispatch = pMenuItemHandler->xMenuItemDispatch;
 793             }
 794         }
 795     }
 796
 797     // tdf#126054 don't let dispatch destroy this until after function completes
 798     rtl::Reference<MenuBarManager> xKeepAlive(this);
 799     if (xDispatch.is())
 800     {
 801         SolarMutexReleaser aReleaser;
 802         xDispatch->dispatch( aTargetURL, aArgs );
 803     }
 804
 805     if ( !m_bHasMenuBar )
 806         // Standalone (non-native) popup menu doesn't fire deactivate event
 807         // in this case, so we have to reset the active flag here.
 808         m_bActive = false;
 809
 810     return true;
 811 }
 812
 813 bool MenuBarManager::MustBeHidden( PopupMenu* pPopupMenu, const Reference< XURLTransformer >& rTransformer )
 814 {
 815     if ( !pPopupMenu )
 816         return true;
 817
 818     URL               aTargetURL;
 819     SvtCommandOptions aCmdOptions;
 820
 821     sal_uInt16 nCount = pPopupMenu->GetItemCount();
 822     sal_uInt16 nHideCount( 0 );
 823
 824     for ( sal_uInt16 i = 0; i < nCount; i++ )
 825     {
 826         sal_uInt16 nId = pPopupMenu->GetItemId( i );
 827         if ( nId > 0 )
 828         {
 829             PopupMenu* pSubPopupMenu = pPopupMenu->GetPopupMenu( nId );
 830             if ( pSubPopupMenu )
 831             {
 832                 if ( MustBeHidden( pSubPopupMenu, rTransformer ))
 833                 {
 834                     pPopupMenu->HideItem( nId );
 835                     ++nHideCount;
 836                 }
 837             }
 838             else
 839             {
 840                 aTargetURL.Complete = pPopupMenu->GetItemCommand( nId );
 841                 rTransformer->parseStrict( aTargetURL );
 842
 843                 if ( aCmdOptions.LookupDisabled( aTargetURL.Path ))
 844                     ++nHideCount;
 845             }
 846         }
 847         else
 848             ++nHideCount;
 849     }
 850
 851     return ( nCount == nHideCount );
 852 }
 853
 854 OUString MenuBarManager::RetrieveLabelFromCommand(const OUString& rCmdURL)
 855 {
 856     auto aProperties = vcl::CommandInfoProvider::GetCommandProperties(rCmdURL, m_aModuleIdentifier);
 857     if ( !m_bHasMenuBar )
 858     {
 859         // This is a context menu, prefer "PopupLabel" over "Label".
 860         return vcl::CommandInfoProvider::GetPopupLabelForCommand(aProperties);
 861     }
 862     return vcl::CommandInfoProvider::GetMenuLabelForCommand(aProperties);
 863 }
 864
 865 bool MenuBarManager::CreatePopupMenuController( MenuItemHandler* pMenuItemHandler,
 866                                                 const css::uno::Reference< css::frame::XDispatchProvider >& rDispatchProvider,
 867                                                 const OUString& rModuleIdentifier )
 868 {
 869     OUString aItemCommand( pMenuItemHandler->aMenuItemURL );
 870
 871     // Try instantiate a popup menu controller. It is stored in the menu item handler.
 872     if ( !m_xPopupMenuControllerFactory.is() )
 873         return false;
 874
 875     auto aSeq( comphelper::InitAnyPropertySequence( {
 876         { "DispatchProvider", Any(rDispatchProvider) },
 877         { "ModuleIdentifier", Any(rModuleIdentifier) },
 878         { "Frame", Any(m_xFrame) },
 879         { "InToolbar", Any(!m_bHasMenuBar) }
 880     } ) );
 881
 882     Reference< XPopupMenuController > xPopupMenuController(
 883                                             m_xPopupMenuControllerFactory->createInstanceWithArgumentsAndContext(
 884                                                 aItemCommand,
 885                                                 aSeq,
 886                                                 m_xContext ),
 887                                             UNO_QUERY );
 888
 889     if ( xPopupMenuController.is() )
 890     {
 891         // Provide our awt popup menu to the popup menu controller
 892         pMenuItemHandler->xPopupMenuController = xPopupMenuController;
 893         xPopupMenuController->setPopupMenu( pMenuItemHandler->xPopupMenu );
 894         return true;
 895     }
 896
 897     return false;
 898 }
 899
 900 void MenuBarManager::FillMenuManager( Menu* pMenu, const Reference< XFrame >& rFrame,
 901                                       const Reference< XDispatchProvider >& rDispatchProvider,
 902                                       const OUString& rModuleIdentifier, bool bDelete )
 903 {
 904     m_xFrame            = rFrame;
 905     m_bActive           = false;
 906     m_bDeleteMenu       = bDelete;
 907     m_pVCLMenu          = pMenu;
 908     m_xDispatchProvider = rDispatchProvider;
 909
 910     const StyleSettings& rSettings = Application::GetSettings().GetStyleSettings();
 911     m_bShowMenuImages   = rSettings.GetUseImagesInMenus();
 912     m_bRetrieveImages   = false;
 913
 914     // Set module identifier when provided from outside
 915     if (!rModuleIdentifier.isEmpty())
 916         m_aModuleIdentifier = rModuleIdentifier;
 917     else
 918         m_aModuleIdentifier = vcl::CommandInfoProvider::GetModuleIdentifier(m_xFrame);
 919
 920     // Add root as ui configuration listener
 921     RetrieveImageManagers();
 922
 923     if ( pMenu->IsMenuBar() && rFrame.is() )
 924     {
 925         // First merge all addon popup menus into our structure
 926         sal_uInt16 nPos = 0;
 927         for ( nPos = 0; nPos < pMenu->GetItemCount(); nPos++ )
 928         {
 929             sal_uInt16          nItemId  = pMenu->GetItemId( nPos );
 930             OUString aCommand = pMenu->GetItemCommand( nItemId );
 931             if ( aCommand == aSpecialWindowCommand || aCommand == aCmdHelpMenu )
 932             {
 933                 // Retrieve addon popup menus and add them to our menu bar
 934                 framework::AddonMenuManager::MergeAddonPopupMenus( rFrame, nPos, static_cast<MenuBar *>(pMenu) );
 935                 break;
 936             }
 937         }
 938
 939         // Merge the Add-Ons help menu items into the Office help menu
 940         framework::AddonMenuManager::MergeAddonHelpMenu( rFrame, static_cast<MenuBar *>(pMenu) );
 941     }
 942
 943     bool    bAccessibilityEnabled( Application::GetSettings().GetMiscSettings().GetEnableATToolSupport() );
 944     sal_uInt16 nItemCount = pMenu->GetItemCount();
 945     OUString aItemCommand;
 946     m_aMenuItemHandlerVector.reserve(nItemCount);
 947     for ( sal_uInt16 i = 0; i < nItemCount; i++ )
 948     {
 949         sal_uInt16 nItemId = FillItemCommand(aItemCommand,pMenu, i );
 950
 951         if (( pMenu->IsMenuBar() || bAccessibilityEnabled ) &&
 952             ( pMenu->GetItemText( nItemId ).isEmpty() ))
 953         {
 954             if ( !aItemCommand.isEmpty() )
 955                 pMenu->SetItemText( nItemId, RetrieveLabelFromCommand( aItemCommand ));
 956         }
 957
 958         // Command can be just an alias to another command.
 959         auto aProperties = vcl::CommandInfoProvider::GetCommandProperties(aItemCommand, m_aModuleIdentifier);
 960         OUString aRealCommand = vcl::CommandInfoProvider::GetRealCommandForCommand(aProperties);
 961         if ( !aRealCommand.isEmpty() )
 962             aItemCommand = aRealCommand;
 963
 964         Reference< XDispatch > xDispatch;
 965         Reference< XStatusListener > xStatusListener;
 966         VclPtr<PopupMenu> pPopup = pMenu->GetPopupMenu( nItemId );
 967         // overwrite the show icons on menu option?
 968         MenuItemBits nBits = pMenu->GetItemBits( nItemId ) & ( MenuItemBits::ICON | MenuItemBits::TEXT );
 969         bool bItemShowMenuImages = ( m_bShowMenuImages && nBits != MenuItemBits::TEXT ) || nBits & MenuItemBits::ICON;
 970
 971         if ( pPopup )
 972         {
 973             // Retrieve module identifier from Help Command entry
 974             OUString aModuleIdentifier( rModuleIdentifier );
 975             if (!pMenu->GetHelpCommand(nItemId).isEmpty())
 976             {
 977                 aModuleIdentifier = pMenu->GetHelpCommand( nItemId );
 978                 pMenu->SetHelpCommand( nItemId, "" );
 979             }
 980
 981             // Retrieve possible attributes struct
 982             Reference< XDispatchProvider > xPopupMenuDispatchProvider( rDispatchProvider );
 983             MenuAttributes* pAttributes = static_cast<MenuAttributes *>(pMenu->GetUserValue( nItemId ));
 984             if ( pAttributes )
 985                 xPopupMenuDispatchProvider = pAttributes->xDispatchProvider;
 986
 987             if ( m_xPopupMenuControllerFactory.is() &&
 988                  m_xPopupMenuControllerFactory->hasController( aItemCommand, aModuleIdentifier )
 989                   )
 990             {
 991                 // Check if we have to create a popup menu for a uno based popup menu controller.
 992                 // We have to set an empty popup menu into our menu structure so the controller also
 993                 // works with inplace OLE.
 994                 MenuItemHandler* pItemHandler = new MenuItemHandler( nItemId, xStatusListener, xDispatch );
 995                 rtl::Reference<VCLXPopupMenu> pVCLXPopupMenu = new VCLXPopupMenu(pPopup);
 996                 pItemHandler->xPopupMenu = pVCLXPopupMenu;
 997                 pItemHandler->aMenuItemURL = aItemCommand;
 998                 m_aMenuItemHandlerVector.push_back( std::unique_ptr<MenuItemHandler>(pItemHandler) );
 999
1000                 if ( bAccessibilityEnabled || pMenu->IsMenuBar())
1001                 {
1002                     if ( CreatePopupMenuController( pItemHandler, xPopupMenuDispatchProvider, aModuleIdentifier ))
1003                         pItemHandler->xPopupMenuController->updatePopupMenu();
1004                 }
1005                 lcl_CheckForChildren(pMenu, nItemId);
1006             }
1007             else
1008             {
1009                 // Check if this is the tools menu. Add menu item if needed
1010                 if ( aItemCommand == aCmdToolsMenu && AddonMenuManager::HasAddonMenuElements() )
1011                 {
1012                     // Create addon popup menu if there exist elements and this is the tools popup menu
1013                     VclPtr<PopupMenu> pSubMenu = AddonMenuManager::CreateAddonMenu(rFrame);
1014                     if ( pSubMenu && ( pSubMenu->GetItemCount() > 0 ))
1015                     {
1016                         if ( pPopup->GetItemType( pPopup->GetItemCount() - 1 ) != MenuItemType::SEPARATOR )
1017                             pPopup->InsertSeparator();
1018
1019                         pPopup->InsertItem( ITEMID_ADDONLIST, OUString() );
1020                         pPopup->SetPopupMenu( ITEMID_ADDONLIST, pSubMenu );
1021                         pPopup->SetItemCommand( ITEMID_ADDONLIST, ".uno:Addons" );
1022                     }
1023                     else
1024                         pSubMenu.disposeAndClear();
1025                 }
1026
1027                 rtl::Reference<MenuBarManager> pSubMenuManager = new MenuBarManager( m_xContext, rFrame, m_xURLTransformer,
1028                     xPopupMenuDispatchProvider, aModuleIdentifier, pPopup, false, m_bHasMenuBar );
1029
1030                 AddMenu(pSubMenuManager.get(), aItemCommand, nItemId);
1031             }
1032         }
1033         else if ( pMenu->GetItemType( i ) != MenuItemType::SEPARATOR )
1034         {
1035             if ( bItemShowMenuImages )
1036                 m_bRetrieveImages = true;
1037
1038             std::unique_ptr<MenuItemHandler> pItemHandler(new MenuItemHandler( nItemId, xStatusListener, xDispatch ));
1039             // Retrieve possible attributes struct
1040             MenuAttributes* pAttributes = static_cast<MenuAttributes *>(pMenu->GetUserValue( nItemId ));
1041             if ( pAttributes )
1042                 pItemHandler->aTargetFrame = pAttributes->aTargetFrame;
1043             pItemHandler->aMenuItemURL = aItemCommand;
1044
1045             if ( m_xPopupMenuControllerFactory.is() &&
1046                  m_xPopupMenuControllerFactory->hasController( aItemCommand, m_aModuleIdentifier ) )
1047             {
1048                 // Check if we have to create a popup menu for a uno based popup menu controller.
1049                 // We have to set an empty popup menu into our menu structure so the controller also
1050                 // works with inplace OLE.
1051                 rtl::Reference<VCLXPopupMenu> pVCLXPopupMenu = new VCLXPopupMenu;
1052                 PopupMenu* pPopupMenu = static_cast<PopupMenu *>(pVCLXPopupMenu->GetMenu());
1053                 pMenu->SetPopupMenu( pItemHandler->nItemId, pPopupMenu );
1054                 pItemHandler->xPopupMenu = pVCLXPopupMenu;
1055
1056                 if ( bAccessibilityEnabled && CreatePopupMenuController( pItemHandler.get(), m_xDispatchProvider, m_aModuleIdentifier ) )
1057                 {
1058                     pItemHandler->xPopupMenuController->updatePopupMenu();
1059                 }
1060
1061                 lcl_CheckForChildren(pMenu, pItemHandler->nItemId);
1062             }
1063
1064             m_aMenuItemHandlerVector.push_back( std::move(pItemHandler) );
1065         }
1066     }
1067
1068     if ( m_bHasMenuBar && bAccessibilityEnabled )
1069     {
1070         RetrieveShortcuts( m_aMenuItemHandlerVector );
1071         for (auto const& menuItemHandler : m_aMenuItemHandlerVector)
1072         {
1073             // Set key code, workaround for hard-coded shortcut F1 mapped to .uno:HelpIndex
1074             // Only non-popup menu items can have a short-cut
1075             if ( menuItemHandler->aMenuItemURL == aCmdHelpIndex )
1076             {
1077                 vcl::KeyCode aKeyCode( KEY_F1 );
1078                 pMenu->SetAccelKey( menuItemHandler->nItemId, aKeyCode );
1079             }
1080             else if ( pMenu->GetPopupMenu( menuItemHandler->nItemId ) == nullptr )
1081                 pMenu->SetAccelKey( menuItemHandler->nItemId, menuItemHandler->aKeyCode );
1082         }
1083     }
1084
1085     SetHdl();
1086 }
1087
1088 void MenuBarManager::impl_RetrieveShortcutsFromConfiguration(
1089     const Reference< XAcceleratorConfiguration >& rAccelCfg,
1090     const Sequence< OUString >& rCommands,
1091     std::vector< std::unique_ptr<MenuItemHandler> >& aMenuShortCuts )
1092 {
1093     if ( !rAccelCfg.is() )
1094         return;
1095
1096     try
1097     {
1098         css::awt::KeyEvent aKeyEvent;
1099         Sequence< Any > aSeqKeyCode = rAccelCfg->getPreferredKeyEventsForCommandList( rCommands );
1100         for ( sal_Int32 i = 0; i < aSeqKeyCode.getLength(); i++ )
1101         {
1102             if ( aSeqKeyCode[i] >>= aKeyEvent )
1103                 aMenuShortCuts[i]->aKeyCode = svt::AcceleratorExecute::st_AWTKey2VCLKey( aKeyEvent );
1104         }
1105     }
1106     catch ( const IllegalArgumentException& )
1107     {
1108     }
1109 }
1110
1111 void MenuBarManager::RetrieveShortcuts( std::vector< std::unique_ptr<MenuItemHandler> >& aMenuShortCuts )
1112 {
1113     Reference< XAcceleratorConfiguration > xDocAccelCfg( m_xDocAcceleratorManager );
1114     Reference< XAcceleratorConfiguration > xModuleAccelCfg( m_xModuleAcceleratorManager );
1115     Reference< XAcceleratorConfiguration > xGlobalAccelCfg( m_xGlobalAcceleratorManager );
1116
1117     if ( !m_bAcceleratorCfg )
1118     {
1119         // Retrieve references on demand
1120         m_bAcceleratorCfg = true;
1121         if ( !xDocAccelCfg.is() )
1122         {
1123             Reference< XController > xController = m_xFrame->getController();
1124             Reference< XModel > xModel;
1125             if ( xController.is() )
1126             {
1127                 xModel = xController->getModel();
1128                 if ( xModel.is() )
1129                 {
1130                     Reference< XUIConfigurationManagerSupplier > xSupplier( xModel, UNO_QUERY );
1131                     if ( xSupplier.is() )
1132                     {
1133                         Reference< XUIConfigurationManager > xDocUICfgMgr = xSupplier->getUIConfigurationManager();
1134                         if ( xDocUICfgMgr.is() )
1135                         {
1136                             xDocAccelCfg = xDocUICfgMgr->getShortCutManager();
1137                             m_xDocAcceleratorManager = xDocAccelCfg;
1138                         }
1139                     }
1140                 }
1141             }
1142         }
1143
1144         if ( !xModuleAccelCfg.is() )
1145         {
1146             Reference< XModuleUIConfigurationManagerSupplier > xModuleCfgMgrSupplier =
1147                 theModuleUIConfigurationManagerSupplier::get( m_xContext );
1148             try
1149             {
1150                 Reference< XUIConfigurationManager > xUICfgMgr = xModuleCfgMgrSupplier->getUIConfigurationManager( m_aModuleIdentifier );
1151                 if ( xUICfgMgr.is() )
1152                 {
1153                     xModuleAccelCfg = xUICfgMgr->getShortCutManager();
1154                     m_xModuleAcceleratorManager = xModuleAccelCfg;
1155                 }
1156             }
1157             catch ( const RuntimeException& )
1158             {
1159                 throw;
1160             }
1161             catch ( const Exception& )
1162             {
1163             }
1164         }
1165
1166         if ( !xGlobalAccelCfg.is() ) try
1167         {
1168             xGlobalAccelCfg = GlobalAcceleratorConfiguration::create( m_xContext );
1169             m_xGlobalAcceleratorManager = xGlobalAccelCfg;
1170         }
1171         catch ( const css::uno::DeploymentException& )
1172         {
1173             SAL_WARN("fwk.uielement", "GlobalAcceleratorConfiguration"
1174                     " not available. This should happen only on mobile platforms.");
1175         }
1176     }
1177
1178     vcl::KeyCode aEmptyKeyCode;
1179     Sequence< OUString > aSeq( aMenuShortCuts.size() );
1180     auto aSeqRange = asNonConstRange(aSeq);
1181     const sal_uInt32 nCount = aMenuShortCuts.size();
1182     for ( sal_uInt32 i = 0; i < nCount; ++i )
1183     {
1184         aSeqRange[i] = aMenuShortCuts[i]->aMenuItemURL;
1185         aMenuShortCuts[i]->aKeyCode = aEmptyKeyCode;
1186     }
1187
1188     if ( m_xGlobalAcceleratorManager.is() )
1189         impl_RetrieveShortcutsFromConfiguration( xGlobalAccelCfg, aSeq, aMenuShortCuts );
1190     if ( m_xModuleAcceleratorManager.is() )
1191         impl_RetrieveShortcutsFromConfiguration( xModuleAccelCfg, aSeq, aMenuShortCuts );
1192     if ( m_xDocAcceleratorManager.is() )
1193         impl_RetrieveShortcutsFromConfiguration( xDocAccelCfg, aSeq, aMenuShortCuts );
1194 }
1195
1196 void MenuBarManager::RetrieveImageManagers()
1197 {
1198     if ( !m_xDocImageManager.is() )
1199     {
1200         Reference< XController > xController = m_xFrame->getController();
1201         Reference< XModel > xModel;
1202         if ( xController.is() )
1203         {
1204             xModel = xController->getModel();
1205             if ( xModel.is() )
1206             {
1207                 Reference< XUIConfigurationManagerSupplier > xSupplier( xModel, UNO_QUERY );
1208                 if ( xSupplier.is() )
1209                 {
1210                     Reference< XUIConfigurationManager > xDocUICfgMgr = xSupplier->getUIConfigurationManager();
1211                     m_xDocImageManager.set( xDocUICfgMgr->getImageManager(), UNO_QUERY );
1212                     m_xDocImageManager->addConfigurationListener(
1213                                             Reference< XUIConfigurationListener >(this) );
1214                 }
1215             }
1216         }
1217     }
1218
1219     if ( !m_xModuleImageManager.is() )
1220     {
1221         Reference< XModuleUIConfigurationManagerSupplier > xModuleCfgMgrSupplier =
1222             theModuleUIConfigurationManagerSupplier::get( m_xContext );
1223         Reference< XUIConfigurationManager > xUICfgMgr = xModuleCfgMgrSupplier->getUIConfigurationManager( m_aModuleIdentifier );
1224         m_xModuleImageManager.set( xUICfgMgr->getImageManager(), UNO_QUERY );
1225         m_xModuleImageManager->addConfigurationListener( Reference< XUIConfigurationListener >(this) );
1226     }
1227 }
1228
1229 void MenuBarManager::FillMenuWithConfiguration(
1230     sal_uInt16&                         nId,
1231     Menu*                               pMenu,
1232     const OUString&              rModuleIdentifier,
1233     const Reference< XIndexAccess >&    rItemContainer,
1234     const Reference< XURLTransformer >& rTransformer )
1235 {
1236     Reference< XDispatchProvider > xEmptyDispatchProvider;
1237     MenuBarManager::FillMenu( nId, pMenu, rModuleIdentifier, rItemContainer, xEmptyDispatchProvider );
1238
1239     // Merge add-on menu entries into the menu bar
1240     MenuBarManager::MergeAddonMenus( pMenu,
1241                                      AddonsOptions().GetMergeMenuInstructions(),
1242                                      rModuleIdentifier );
1243
1244     bool bHasDisabledEntries = SvtCommandOptions().HasEntriesDisabled();
1245     if ( !bHasDisabledEntries )
1246         return;
1247
1248     sal_uInt16 nCount = pMenu->GetItemCount();
1249     for ( sal_uInt16 i = 0; i < nCount; i++ )
1250     {
1251         sal_uInt16 nID = pMenu->GetItemId( i );
1252         if ( nID > 0 )
1253         {
1254             PopupMenu* pPopupMenu = pMenu->GetPopupMenu( nID );
1255             if ( pPopupMenu )
1256             {
1257                 if ( MustBeHidden( pPopupMenu, rTransformer ))
1258                     pMenu->HideItem( nId );
1259             }
1260         }
1261     }
1262 }
1263
1264 void MenuBarManager::FillMenu(
1265     sal_uInt16& nId,
1266     Menu* pMenu,
1267     const OUString& rModuleIdentifier,
1268     const Reference< XIndexAccess >& rItemContainer,
1269     const Reference< XDispatchProvider >& rDispatchProvider )
1270 {
1271     // Fill menu bar with container contents
1272     for ( sal_Int32 n = 0; n < rItemContainer->getCount(); n++ )
1273     {
1274         Sequence< PropertyValue > aProps;
1275         OUString aCommandURL;
1276         OUString aLabel;
1277         OUString aModuleIdentifier( rModuleIdentifier );
1278         sal_uInt16 nType = 0;
1279         Reference< XIndexAccess > xIndexContainer;
1280         Reference< XDispatchProvider > xDispatchProvider( rDispatchProvider );
1281         sal_Int16 nStyle = 0;
1282         try
1283         {
1284             if ( rItemContainer->getByIndex( n ) >>= aProps )
1285             {
1286                 bool bShow = true;
1287                 bool bEnabled = true;
1288
1289                 for ( beans::PropertyValue const & rProp : std::as_const(aProps) )
1290                 {
1291                     OUString aPropName = rProp.Name;
1292                     if ( aPropName == "CommandURL" )
1293                         rProp.Value >>= aCommandURL;
1294                     else if ( aPropName == "ItemDescriptorContainer" )
1295                         rProp.Value >>= xIndexContainer;
1296                     else if ( aPropName == "Label" )
1297                         rProp.Value >>= aLabel;
1298                     else if ( aPropName == "Type" )
1299                         rProp.Value >>= nType;
1300                     else if ( aPropName == "ModuleIdentifier" )
1301                         rProp.Value >>= aModuleIdentifier;
1302                     else if ( aPropName == "DispatchProvider" )
1303                         rProp.Value >>= xDispatchProvider;
1304                     else if ( aPropName == "Style" )
1305                         rProp.Value >>= nStyle;
1306                     else if ( aPropName == "IsVisible" )
1307                         rProp.Value >>= bShow;
1308                     else if ( aPropName == "Enabled" )
1309                         rProp.Value >>= bEnabled;
1310                 }
1311
1312                 if (!aCommandURL.isEmpty() && vcl::CommandInfoProvider::IsExperimental(aCommandURL, rModuleIdentifier) &&
1313                     !officecfg::Office::Common::Misc::ExperimentalMode::get())
1314                 {
1315                     continue;
1316                 }
1317
1318                 if ( nType == css::ui::ItemType::DEFAULT )
1319                 {
1320                     pMenu->InsertItem( nId, aLabel );
1321                     pMenu->SetItemCommand( nId, aCommandURL );
1322
1323                     if ( nStyle )
1324                     {
1325                         MenuItemBits nBits = pMenu->GetItemBits( nId );
1326                         if ( nStyle & css::ui::ItemStyle::ICON )
1327                            nBits |= MenuItemBits::ICON;
1328                         if ( nStyle & css::ui::ItemStyle::TEXT )
1329                            nBits |= MenuItemBits::TEXT;
1330                         if ( nStyle & css::ui::ItemStyle::RADIO_CHECK )
1331                            nBits |= MenuItemBits::RADIOCHECK;
1332                         pMenu->SetItemBits( nId, nBits );
1333                     }
1334
1335                     if ( !bShow )
1336                         pMenu->HideItem( nId );
1337
1338                     if ( !bEnabled)
1339                         pMenu->EnableItem( nId, false );
1340
1341                     if ( xIndexContainer.is() )
1342                     {
1343                         VclPtr<PopupMenu> pNewPopupMenu = VclPtr<PopupMenu>::Create();
1344                         pMenu->SetPopupMenu( nId, pNewPopupMenu );
1345
1346                         if ( xDispatchProvider.is() )
1347                         {
1348                             // Use attributes struct to transport special dispatch provider
1349                             void* nAttributePtr = MenuAttributes::CreateAttribute(xDispatchProvider);
1350                             pMenu->SetUserValue(nId, nAttributePtr, MenuAttributes::ReleaseAttribute);
1351                         }
1352
1353                         // Use help command to transport module identifier
1354                         if ( !aModuleIdentifier.isEmpty() )
1355                             pMenu->SetHelpCommand( nId, aModuleIdentifier );
1356
1357                         ++nId;
1358                         FillMenu( nId, pNewPopupMenu, aModuleIdentifier, xIndexContainer, xDispatchProvider );
1359                     }
1360                     else
1361                         ++nId;
1362                 }
1363                 else
1364                 {
1365                     pMenu->InsertSeparator();
1366                     ++nId;
1367                 }
1368             }
1369         }
1370         catch ( const IndexOutOfBoundsException& )
1371         {
1372             break;
1373         }
1374     }
1375 }
1376
1377 void MenuBarManager::MergeAddonMenus(
1378     Menu* pMenuBar,
1379     const MergeMenuInstructionContainer& aMergeInstructionContainer,
1380     const OUString& rModuleIdentifier )
1381 {
1382     // set start value for the item ID for the new addon menu items
1383     sal_uInt16 nItemId = ADDONMENU_MERGE_ITEMID_START;
1384
1385     const sal_uInt32 nCount = aMergeInstructionContainer.size();
1386     for ( sal_uInt32 i = 0; i < nCount; i++ )
1387     {
1388         const MergeMenuInstruction& rMergeInstruction = aMergeInstructionContainer[i];
1389
1390         if ( MenuBarMerger::IsCorrectContext( rMergeInstruction.aMergeContext, rModuleIdentifier ))
1391         {
1392             ::std::vector< OUString > aMergePath;
1393
1394             // retrieve the merge path from the merge point string
1395             MenuBarMerger::RetrieveReferencePath( rMergeInstruction.aMergePoint, aMergePath );
1396
1397             // convert the sequence/sequence property value to a more convenient vector<>
1398             AddonMenuContainer aMergeMenuItems;
1399             MenuBarMerger::GetSubMenu( rMergeInstruction.aMergeMenu, aMergeMenuItems );
1400
1401             // try to find the reference point for our merge operation
1402             Menu* pMenu = pMenuBar;
1403             ReferencePathInfo aResult = MenuBarMerger::FindReferencePath( aMergePath, pMenu );
1404
1405             if ( aResult.eResult == RP_OK )
1406             {
1407                 // normal merge operation
1408                 MenuBarMerger::ProcessMergeOperation( aResult.pPopupMenu,
1409                                                       aResult.nPos,
1410                                                       nItemId,
1411                                                       rMergeInstruction.aMergeCommand,
1412                                                       rMergeInstruction.aMergeCommandParameter,
1413                                                       rModuleIdentifier,
1414                                                       aMergeMenuItems );
1415             }
1416             else
1417             {
1418                 // fallback
1419                 MenuBarMerger::ProcessFallbackOperation( aResult,
1420                                                          nItemId,
1421                                                          rMergeInstruction.aMergeCommand,
1422                                                          rMergeInstruction.aMergeFallback,
1423                                                          aMergePath,
1424                                                          rModuleIdentifier,
1425                                                          aMergeMenuItems );
1426             }
1427         }
1428     }
1429 }
1430
1431 void MenuBarManager::SetItemContainer( const Reference< XIndexAccess >& rItemContainer )
1432 {
1433     SolarMutexGuard aSolarMutexGuard;
1434
1435     Reference< XFrame > xFrame = m_xFrame;
1436
1437     // Clear MenuBarManager structures
1438     {
1439         // Check active state as we cannot change our VCL menu during activation by the user
1440         if ( m_bActive )
1441         {
1442             m_xDeferredItemContainer = rItemContainer;
1443             return;
1444         }
1445
1446         RemoveListener();
1447         m_aMenuItemHandlerVector.clear();
1448         m_pVCLMenu->Clear();
1449
1450         sal_uInt16          nId = 1;
1451
1452         // Fill menu bar with container contents
1453         FillMenuWithConfiguration( nId, m_pVCLMenu, m_aModuleIdentifier, rItemContainer, m_xURLTransformer );
1454
1455         // Refill menu manager again
1456         Reference< XDispatchProvider > xDispatchProvider;
1457         FillMenuManager( m_pVCLMenu, xFrame, xDispatchProvider, m_aModuleIdentifier, false );
1458
1459         // add itself as frame action listener
1460         m_xFrame->addFrameActionListener( Reference< XFrameActionListener >(this) );
1461     }
1462 }
1463
1464 void MenuBarManager::GetPopupController( PopupControllerCache& rPopupController )
1465 {
1466
1467     SolarMutexGuard aSolarMutexGuard;
1468
1469     for (auto const& menuItemHandler : m_aMenuItemHandlerVector)
1470     {
1471         if ( menuItemHandler->xPopupMenuController.is() )
1472         {
1473             Reference< XDispatchProvider > xDispatchProvider( menuItemHandler->xPopupMenuController, UNO_QUERY );
1474
1475             PopupControllerEntry aPopupControllerEntry;
1476             aPopupControllerEntry.m_xDispatchProvider = xDispatchProvider;
1477
1478             // Just use the main part of the URL for popup menu controllers
1479             sal_Int32     nSchemePart( 0 );
1480             OUString aMenuURL( menuItemHandler->aMenuItemURL );
1481
1482             nSchemePart = aMenuURL.indexOf( ':' );
1483             if (( nSchemePart > 0 ) &&
1484                 ( aMenuURL.getLength() > ( nSchemePart+1 )))
1485             {
1486                 OUString aMainURL( "vnd.sun.star.popup:" );
1487                 sal_Int32 nQueryPart  = aMenuURL.indexOf( '?', nSchemePart );
1488                 if ( nQueryPart > 0 )
1489                     aMainURL += aMenuURL.subView( nSchemePart, nQueryPart-nSchemePart );
1490                 else if ( nQueryPart == -1 )
1491                     aMainURL += aMenuURL.subView( nSchemePart+1 );
1492
1493                 rPopupController.emplace( aMainURL, aPopupControllerEntry );
1494             }
1495         }
1496         if ( menuItemHandler->xSubMenuManager.is() )
1497         {
1498             MenuBarManager* pMenuBarManager = static_cast<MenuBarManager*>(menuItemHandler->xSubMenuManager.get());
1499             if ( pMenuBarManager )
1500                 pMenuBarManager->GetPopupController( rPopupController );
1501         }
1502     }
1503 }
1504
1505 void MenuBarManager::AddMenu(MenuBarManager* pSubMenuManager,const OUString& _sItemCommand,sal_uInt16 _nItemId)
1506 {
1507     Reference< XStatusListener > xSubMenuManager( pSubMenuManager );
1508     m_xFrame->addFrameActionListener( Reference< XFrameActionListener >( xSubMenuManager, UNO_QUERY ));
1509
1510     Reference< XDispatch > xDispatch;
1511     std::unique_ptr<MenuItemHandler> pMenuItemHandler(new MenuItemHandler(
1512                                                 _nItemId,
1513                                                 xSubMenuManager,
1514                                                 xDispatch ));
1515     pMenuItemHandler->aMenuItemURL = _sItemCommand;
1516     m_aMenuItemHandlerVector.push_back( std::move(pMenuItemHandler) );
1517 }
1518
1519 sal_uInt16 MenuBarManager::FillItemCommand(OUString& _rItemCommand, Menu* _pMenu,sal_uInt16 _nIndex) const
1520 {
1521     sal_uInt16 nItemId = _pMenu->GetItemId( _nIndex );
1522
1523     _rItemCommand = _pMenu->GetItemCommand( nItemId );
1524     if ( _rItemCommand.isEmpty() )
1525     {
1526         _rItemCommand = "slot:" + OUString::number( nItemId );
1527         _pMenu->SetItemCommand( nItemId, _rItemCommand );
1528     }
1529     return nItemId;
1530 }
1531
1532 void MenuBarManager::SetHdl()
1533 {
1534     m_pVCLMenu->SetActivateHdl( LINK( this, MenuBarManager, Activate ));
1535     m_pVCLMenu->SetDeactivateHdl( LINK( this, MenuBarManager, Deactivate ));
1536     m_pVCLMenu->SetSelectHdl( LINK( this, MenuBarManager, Select ));
1537
1538     if ( !m_xURLTransformer.is() && m_xContext.is() )
1539         m_xURLTransformer.set( URLTransformer::create( m_xContext) );
1540 }
1541
1542 void MenuBarManager::FillMenuImages(Reference< XFrame > const & _xFrame, Menu* _pMenu,bool bShowMenuImages)
1543 {
1544     AddonsOptions aAddonOptions;
1545
1546     for ( sal_uInt16 nPos = 0; nPos < _pMenu->GetItemCount(); nPos++ )
1547     {
1548         sal_uInt16 nId = _pMenu->GetItemId( nPos );
1549         if ( _pMenu->GetItemType( nPos ) != MenuItemType::SEPARATOR )
1550         {
1551             // overwrite the show icons on menu option?
1552             MenuItemBits nBits = _pMenu->GetItemBits( nId ) & ( MenuItemBits::ICON | MenuItemBits::TEXT );
1553             bool bTmpShowMenuImages = ( bShowMenuImages && nBits != MenuItemBits::TEXT ) || nBits & MenuItemBits::ICON;
1554
1555             if ( bTmpShowMenuImages )
1556             {
1557                 OUString aMenuItemCommand = _pMenu->GetItemCommand( nId );
1558                 Image aImage = vcl::CommandInfoProvider::GetImageForCommand(aMenuItemCommand, _xFrame);
1559                 if ( !aImage )
1560                     aImage = Image(aAddonOptions.GetImageFromURL(aMenuItemCommand, false));
1561
1562                 _pMenu->SetItemImage( nId, aImage );
1563             }
1564             else
1565                 _pMenu->SetItemImage( nId, Image() );
1566         }
1567     }
1568 }
1569
1570 }
1571
1572 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */