framework/source/fwe/classes/addonmenu.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 <framework/addonmenu.hxx>
  21 #include <framework/addonsoptions.hxx>
  22 #include <general.h>
  23 #include <framework/imageproducer.hxx>
  24 #include <framework/menuconfiguration.hxx>
  25 #include <services.h>
  26
  27 #include <com/sun/star/uno/Reference.hxx>
  28 #include <com/sun/star/util/URL.hpp>
  29 #include <com/sun/star/util/XURLTransformer.hpp>
  30 #include <com/sun/star/frame/ModuleManager.hpp>
  31 #include <com/sun/star/frame/XModuleManager.hpp>
  32
  33 #include <tools/config.hxx>
  34 #include <vcl/svapp.hxx>
  35 #include <svtools/menuoptions.hxx>
  36 #include <svl/solar.hrc>
  37
  38 using namespace ::com::sun::star::uno;
  39 using namespace ::com::sun::star::lang;
  40 using namespace ::com::sun::star::frame;
  41 using namespace ::com::sun::star::beans;
  42
  43 // Please look at sfx2/inc/sfxsids.hrc the values are defined there. Due to build dependencies
  44 // we cannot include the header file.
  45 const sal_uInt16 SID_HELPMENU            = (SID_SFX_START + 410);
  46
  47 namespace framework
  48 {
  49
  50 AddonMenu::AddonMenu( const ::com::sun::star::uno::Reference< ::com::sun::star::frame::XFrame >& rFrame ) :
  51     m_xFrame( rFrame )
  52 {
  53 }
  54
  55 AddonMenu::~AddonMenu()
  56 {
  57     for ( sal_uInt16 i = 0; i < GetItemCount(); i++ )
  58     {
  59         if ( GetItemType( i ) != MenuItemType::SEPARATOR )
  60         {
  61             sal_uInt16 nId = GetItemId( i );
  62             delete GetPopupMenu( nId );
  63         }
  64     }
  65 }
  66
  67 // Check if command URL string has the unique prefix to identify addon popup menus
  68 bool AddonPopupMenu::IsCommandURLPrefix( const OUString& aCmdURL )
  69 {
  70     return aCmdURL.startsWith( ADDONSPOPUPMENU_URL_PREFIX_STR );
  71 }
  72
  73 AddonPopupMenu::AddonPopupMenu( const com::sun::star::uno::Reference< com::sun::star::frame::XFrame >& rFrame ) :
  74     AddonMenu( rFrame )
  75 {
  76 }
  77
  78 AddonPopupMenu::~AddonPopupMenu()
  79 {
  80 }
  81
  82 static OUString GetModuleIdentifier(const Reference<XComponentContext>& rContext,
  83     const Reference< XFrame >& rFrame)
  84 {
  85     Reference< XModuleManager > xModuleManager(ModuleManager::create(rContext));
  86     if ( xModuleManager.is() )
  87     {
  88         try
  89         {
  90             return xModuleManager->identify( rFrame );
  91         }
  92         catch ( Exception& )
  93         {
  94         }
  95     }
  96     return OUString();
  97 }
  98
  99 bool AddonMenuManager::HasAddonMenuElements()
 100 {
 101     return AddonsOptions().HasAddonsMenu();
 102 }
 103
 104 // Factory method to create different Add-On menu types
 105 PopupMenu* AddonMenuManager::CreatePopupMenuType( MenuType eMenuType, const Reference< XFrame >& rFrame )
 106 {
 107     if ( eMenuType == ADDON_MENU )
 108         return new AddonMenu( rFrame );
 109     else if ( eMenuType == ADDON_POPUPMENU )
 110         return new AddonPopupMenu( rFrame );
 111     else
 112         return NULL;
 113 }
 114
 115 // Create the Add-Ons menu
 116 AddonMenu* AddonMenuManager::CreateAddonMenu( const Reference< XFrame >& rFrame,
 117                                               const Reference< XComponentContext >& rContext )
 118 {
 119     AddonsOptions aOptions;
 120     AddonMenu*  pAddonMenu      = NULL;
 121     sal_uInt16      nUniqueMenuId   = ADDONMENU_ITEMID_START;
 122
 123     const Sequence< Sequence< PropertyValue > >& rAddonMenuEntries = aOptions.GetAddonsMenu();
 124     if ( rAddonMenuEntries.getLength() > 0 )
 125     {
 126         pAddonMenu = static_cast<AddonMenu *>(AddonMenuManager::CreatePopupMenuType( ADDON_MENU, rFrame ));
 127         ::rtl::OUString aModuleIdentifier = GetModuleIdentifier( rContext, rFrame );
 128         AddonMenuManager::BuildMenu( pAddonMenu, ADDON_MENU, MENU_APPEND, nUniqueMenuId, rAddonMenuEntries, rFrame, aModuleIdentifier );
 129
 130         // Don't return an empty Add-On menu
 131         if ( pAddonMenu->GetItemCount() == 0 )
 132         {
 133             delete pAddonMenu;
 134             pAddonMenu = NULL;
 135         }
 136     }
 137
 138     return pAddonMenu;
 139 }
 140
 141 // Returns the next insert position from nPos.
 142 sal_uInt16 AddonMenuManager::GetNextPos( sal_uInt16 nPos )
 143 {
 144     return ( nPos == MENU_APPEND ) ? MENU_APPEND : ( nPos+1 );
 145 }
 146
 147 static sal_uInt16 FindMenuId( Menu* pMenu, const OUString& aCommand )
 148 {
 149     sal_uInt16 nPos = 0;
 150     OUString aCmd;
 151     for ( nPos = 0; nPos < pMenu->GetItemCount(); nPos++ )
 152     {
 153         sal_uInt16 nId = pMenu->GetItemId( nPos );
 154         aCmd = pMenu->GetItemCommand( nId );
 155         if ( aCmd == aCommand )
 156             return nId;
 157     }
 158
 159     return USHRT_MAX;
 160 }
 161
 162 // Merge the Add-Ons help menu items into the given menu bar at a defined pos
 163 void AddonMenuManager::MergeAddonHelpMenu( const Reference< XFrame >& rFrame,
 164                                            MenuBar* pMergeMenuBar,
 165                                            const Reference<XComponentContext>& rContext )
 166 {
 167     if ( pMergeMenuBar )
 168     {
 169         PopupMenu* pHelpMenu = pMergeMenuBar->GetPopupMenu( SID_HELPMENU );
 170         if ( !pHelpMenu )
 171         {
 172             sal_uInt16 nId = FindMenuId(pMergeMenuBar, OUString(".uno:HelpMenu"));
 173             if ( nId != USHRT_MAX )
 174                 pHelpMenu = pMergeMenuBar->GetPopupMenu( nId );
 175         }
 176
 177         if ( pHelpMenu )
 178         {
 179             // Add-Ons help menu items should be inserted after the "registration" menu item
 180             sal_uInt16 nItemCount       = pHelpMenu->GetItemCount();
 181             sal_uInt16 nInsSepAfterPos  = MENU_APPEND;
 182             sal_uInt16 nUniqueMenuId    = ADDONMENU_ITEMID_START;
 183             AddonsOptions aOptions;
 184
 185             // try to detect the about menu item with the command URL
 186             sal_uInt16 nId = FindMenuId(pHelpMenu, OUString(".uno:About"));
 187             sal_uInt16 nInsPos = pHelpMenu->GetItemPos( nId );
 188
 189             const Sequence< Sequence< PropertyValue > >& rAddonHelpMenuEntries = aOptions.GetAddonsHelpMenu();
 190
 191             if ( nInsPos < nItemCount && pHelpMenu->GetItemType( nInsPos ) != MenuItemType::SEPARATOR )
 192                 nInsSepAfterPos = nInsPos;
 193
 194             ::rtl::OUString aModuleIdentifier = GetModuleIdentifier(rContext, rFrame);
 195             AddonMenuManager::BuildMenu( pHelpMenu, ADDON_MENU, nInsPos, nUniqueMenuId, rAddonHelpMenuEntries, rFrame, aModuleIdentifier );
 196
 197             if ( pHelpMenu->GetItemCount() > nItemCount )
 198             {
 199                 if ( nInsSepAfterPos < MENU_APPEND )
 200                 {
 201                     nInsSepAfterPos += ( pHelpMenu->GetItemCount() - nItemCount );
 202                     if ( pHelpMenu->GetItemType( nInsSepAfterPos ) != MenuItemType::SEPARATOR )
 203                         pHelpMenu->InsertSeparator(OString(), nInsSepAfterPos);
 204                 }
 205                 pHelpMenu->InsertSeparator(OString(), nItemCount);
 206             }
 207         }
 208     }
 209 }
 210
 211 // Merge the addon popup menus into the given menu bar at the provided pos.
 212 void AddonMenuManager::MergeAddonPopupMenus( const Reference< XFrame >& rFrame,
 213                                              sal_uInt16               nMergeAtPos,
 214                                              MenuBar*             pMergeMenuBar,
 215                                              const Reference< XComponentContext >& rContext )
 216 {
 217     if ( pMergeMenuBar )
 218     {
 219         AddonsOptions   aAddonsOptions;
 220         sal_uInt16          nInsertPos = nMergeAtPos;
 221
 222         OUString                              aTitle;
 223         OUString                              aURL;
 224         OUString                              aTarget;
 225         OUString                              aImageId;
 226         OUString                              aContext;
 227         Sequence< Sequence< PropertyValue > > aAddonSubMenu;
 228         sal_uInt16                            nUniqueMenuId = ADDONMENU_ITEMID_START;
 229         OUString                              aModuleIdentifier = GetModuleIdentifier(rContext, rFrame);
 230
 231         const Sequence< Sequence< PropertyValue > >&    rAddonMenuEntries = aAddonsOptions.GetAddonsMenuBarPart();
 232         for ( sal_Int32 i = 0; i < rAddonMenuEntries.getLength(); i++ )
 233         {
 234             AddonMenuManager::GetMenuEntry( rAddonMenuEntries[i],
 235                                             aTitle,
 236                                             aURL,
 237                                             aTarget,
 238                                             aImageId,
 239                                             aContext,
 240                                             aAddonSubMenu );
 241             if ( !aTitle.isEmpty() &&
 242                  !aURL.isEmpty()   &&
 243                  aAddonSubMenu.getLength() > 0 &&
 244                  AddonMenuManager::IsCorrectContext( aModuleIdentifier, aContext ))
 245             {
 246                 sal_uInt16          nId             = nUniqueMenuId++;
 247                 AddonPopupMenu* pAddonPopupMenu = static_cast<AddonPopupMenu *>(AddonMenuManager::CreatePopupMenuType( ADDON_POPUPMENU, rFrame ));
 248
 249                 AddonMenuManager::BuildMenu( pAddonPopupMenu, ADDON_MENU, MENU_APPEND, nUniqueMenuId, aAddonSubMenu, rFrame, aModuleIdentifier );
 250
 251                 if ( pAddonPopupMenu->GetItemCount() > 0 )
 252                 {
 253                     pAddonPopupMenu->SetCommandURL( aURL );
 254                     pMergeMenuBar->InsertItem( nId, aTitle, MenuItemBits::NONE, OString(), nInsertPos++ );
 255                     pMergeMenuBar->SetPopupMenu( nId, pAddonPopupMenu );
 256
 257                     // Store the command URL into the VCL menu bar for later identification
 258                     pMergeMenuBar->SetItemCommand( nId, aURL );
 259                 }
 260                 else
 261                     delete pAddonPopupMenu;
 262             }
 263         }
 264     }
 265 }
 266
 267 // Insert the menu and sub menu entries into pCurrentMenu with the aAddonMenuDefinition provided
 268 void AddonMenuManager::BuildMenu( PopupMenu*                            pCurrentMenu,
 269                                   MenuType                              nSubMenuType,
 270                                   sal_uInt16                            nInsPos,
 271                                   sal_uInt16&                           nUniqueMenuId,
 272                                   const Sequence< Sequence< PropertyValue > >& aAddonMenuDefinition,
 273                                   const Reference< XFrame >&            rFrame,
 274                                   const ::rtl::OUString&               rModuleIdentifier )
 275 {
 276     Sequence< Sequence< PropertyValue > >   aAddonSubMenu;
 277     bool                                    bInsertSeparator    = false;
 278     sal_uInt32                              i                   = 0;
 279     sal_uInt32                              nElements           = 0;
 280     sal_uInt32                              nCount              = aAddonMenuDefinition.getLength();
 281     AddonsOptions                           aAddonsOptions;
 282
 283     OUString aTitle;
 284     OUString aURL;
 285     OUString aTarget;
 286     OUString aImageId;
 287     OUString aContext;
 288
 289     for ( i = 0; i < nCount; ++i )
 290     {
 291         GetMenuEntry( aAddonMenuDefinition[i], aTitle, aURL, aTarget, aImageId, aContext, aAddonSubMenu );
 292
 293         if ( !IsCorrectContext( rModuleIdentifier, aContext ) || ( aTitle.isEmpty() && aURL.isEmpty() ))
 294             continue;
 295
 296         if ( aURL == "private:separator" )
 297             bInsertSeparator = true;
 298         else
 299         {
 300             PopupMenu* pSubMenu = NULL;
 301             if ( aAddonSubMenu.getLength() > 0 )
 302             {
 303                 pSubMenu = AddonMenuManager::CreatePopupMenuType( nSubMenuType, rFrame );
 304                 AddonMenuManager::BuildMenu( pSubMenu, nSubMenuType, MENU_APPEND, nUniqueMenuId, aAddonSubMenu, rFrame, rModuleIdentifier );
 305
 306                 // Don't create a menu item for an empty sub menu
 307                 if ( pSubMenu->GetItemCount() == 0 )
 308                 {
 309                     delete pSubMenu;
 310                     pSubMenu =  NULL;
 311                     continue;
 312                 }
 313             }
 314
 315             if ( bInsertSeparator && nElements > 0 )
 316             {
 317                 // Insert a separator only when we insert a new element afterwards and we
 318                 // have already one before us
 319                 nElements = 0;
 320                 bInsertSeparator = false;
 321                 pCurrentMenu->InsertSeparator(OString(), nInsPos);
 322                 nInsPos = AddonMenuManager::GetNextPos( nInsPos );
 323             }
 324
 325             sal_uInt16 nId = nUniqueMenuId++;
 326             pCurrentMenu->InsertItem(nId, aTitle, MenuItemBits::NONE, OString(), nInsPos);
 327             nInsPos = AddonMenuManager::GetNextPos( nInsPos );
 328
 329             ++nElements;
 330
 331             // Store values from configuration to the New and Wizard menu entries to enable
 332             // sfx2 based code to support high contrast mode correctly!
 333             sal_uIntPtr nAttributePtr = MenuAttributes::CreateAttribute(aTarget, aImageId);
 334             pCurrentMenu->SetUserValue(nId, nAttributePtr, MenuAttributes::ReleaseAttribute);
 335             pCurrentMenu->SetItemCommand( nId, aURL );
 336
 337             if ( pSubMenu )
 338                 pCurrentMenu->SetPopupMenu( nId, pSubMenu );
 339         }
 340     }
 341 }
 342
 343 // Retrieve the menu entry property values from a sequence
 344 void AddonMenuManager::GetMenuEntry( const Sequence< PropertyValue >& rAddonMenuEntry,
 345                                      OUString& rTitle,
 346                                      OUString& rURL,
 347                                      OUString& rTarget,
 348                                      OUString& rImageId,
 349                                      OUString& rContext,
 350                                      Sequence< Sequence< PropertyValue > >& rAddonSubMenu )
 351 {
 352     // Reset submenu parameter
 353     rAddonSubMenu   = Sequence< Sequence< PropertyValue > >();
 354
 355     for ( int i = 0; i < rAddonMenuEntry.getLength(); i++ )
 356     {
 357         OUString aMenuEntryPropName = rAddonMenuEntry[i].Name;
 358         if ( aMenuEntryPropName == ADDONSMENUITEM_STRING_URL )
 359             rAddonMenuEntry[i].Value >>= rURL;
 360         else if ( aMenuEntryPropName == ADDONSMENUITEM_STRING_TITLE )
 361             rAddonMenuEntry[i].Value >>= rTitle;
 362         else if ( aMenuEntryPropName == ADDONSMENUITEM_STRING_TARGET )
 363             rAddonMenuEntry[i].Value >>= rTarget;
 364         else if ( aMenuEntryPropName == ADDONSMENUITEM_STRING_IMAGEIDENTIFIER )
 365             rAddonMenuEntry[i].Value >>= rImageId;
 366         else if ( aMenuEntryPropName == ADDONSMENUITEM_STRING_SUBMENU )
 367             rAddonMenuEntry[i].Value >>= rAddonSubMenu;
 368         else if ( aMenuEntryPropName == ADDONSMENUITEM_STRING_CONTEXT )
 369             rAddonMenuEntry[i].Value >>= rContext;
 370     }
 371 }
 372
 373 // Check if the context string matches the provided xModel context
 374 bool AddonMenuManager::IsCorrectContext( const OUString& rModuleIdentifier, const OUString& rContext )
 375 {
 376     if ( rContext.isEmpty() )
 377         return true;
 378
 379     if ( !rModuleIdentifier.isEmpty() )
 380     {
 381         sal_Int32 nIndex = rContext.indexOf( rModuleIdentifier );
 382         return ( nIndex >= 0 );
 383     }
 384
 385     return false;
 386 }
 387
 388 }
 389
 390 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */