framework/source/uielement/toolbarsmenucontroller.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: toolbarsmenucontroller.cxx,v $
  10  * $Revision: 1.21.40.1 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_framework.hxx"
  33 #include <uielement/toolbarsmenucontroller.hxx>
  34
  35 #include <algorithm>
  36
  37 //_________________________________________________________________________________________________________________
  38 //      my own includes
  39 //_________________________________________________________________________________________________________________
  40 #include <threadhelp/resetableguard.hxx>
  41 #include "services.h"
  42 #ifndef __FRAMEWORK_CLASSES_RESOURCE_HRC_
  43 #include <classes/resource.hrc>
  44 #endif
  45 #include <classes/fwkresid.hxx>
  46 #include <uiconfiguration/windowstateconfiguration.hxx>
  47 #include <helper/imageproducer.hxx>
  48 #include <classes/sfxhelperfunctions.hxx>
  49
  50 //_________________________________________________________________________________________________________________
  51 //      interface includes
  52 //_________________________________________________________________________________________________________________
  53 #include <com/sun/star/awt/XDevice.hpp>
  54 #include <com/sun/star/beans/PropertyValue.hpp>
  55 #include <com/sun/star/awt/MenuItemStyle.hpp>
  56 #include <com/sun/star/frame/XDispatchProvider.hpp>
  57 #include <com/sun/star/container/XNameContainer.hpp>
  58 #include <com/sun/star/beans/XPropertySet.hpp>
  59 #include <com/sun/star/frame/XLayoutManager.hpp>
  60 #include <com/sun/star/ui/XUIElementSettings.hpp>
  61 #include <com/sun/star/ui/XModuleUIConfigurationManagerSupplier.hpp>
  62 #include <com/sun/star/ui/XUIConfigurationManagerSupplier.hpp>
  63 #include <com/sun/star/ui/UIElementType.hpp>
  64 #include <com/sun/star/lang/DisposedException.hpp>
  65
  66 //_________________________________________________________________________________________________________________
  67 //      includes of other projects
  68 //_________________________________________________________________________________________________________________
  69
  70 #ifndef _VCL_MENU_HXX_
  71 #include <vcl/menu.hxx>
  72 #endif
  73 #include <vcl/svapp.hxx>
  74 #include <vcl/i18nhelp.hxx>
  75 #include <vcl/image.hxx>
  76 #include <tools/urlobj.hxx>
  77 #include <rtl/ustrbuf.hxx>
  78 #ifndef _TOOLKIT_HELPER_VCLUNOHELPER_HXX_
  79 #include <toolkit/unohlp.hxx>
  80 #endif
  81 #include <vcl/window.hxx>
  82 #include <svtools/menuoptions.hxx>
  83 #include <svtools/cmdoptions.hxx>
  84 #include <dispatch/uieventloghelper.hxx>
  85 #include <rtl/logfile.hxx>
  86 #include <svtools/miscopt.hxx>
  87
  88 //_________________________________________________________________________________________________________________
  89 //      Defines
  90 //_________________________________________________________________________________________________________________
  91 //
  92
  93 using namespace ::com::sun::star;
  94 using namespace ::com::sun::star::uno;
  95 using namespace ::com::sun::star::lang;
  96 using namespace ::com::sun::star::frame;
  97 using namespace ::com::sun::star::beans;
  98 using namespace ::com::sun::star::util;
  99 using namespace ::com::sun::star::container;
 100 using namespace ::com::sun::star::frame;
 101 using namespace ::com::sun::star::ui;
 102
 103 static const char CONFIGURE_TOOLBARS_CMD[]      = "ConfigureDialog";
 104 static const char CONFIGURE_TOOLBARS[]          = ".uno:ConfigureDialog";
 105 static const char CMD_COLORBAR[]                = ".uno:ColorControl";
 106 static const char CMD_HYPERLINKBAR[]            = ".uno:InsertHyperlink";
 107 static const char CMD_FORMULABAR[]              = ".uno:InsertFormula";
 108 static const char CMD_INPUTLINEBAR[]            = ".uno:InputLineVisible";
 109 static const char CMD_RESTOREVISIBILITY[]       = ".cmd:RestoreVisibility";
 110 static const char ITEM_DESCRIPTOR_RESOURCEURL[] = "ResourceURL";
 111 static const char ITEM_DESCRIPTOR_UINAME[]              = "UIName";
 112 static const char STATIC_PRIVATE_TB_RESOURCE[]  = "private:resource/toolbar/";
 113
 114 static const char STATIC_CMD_PART[]             = ".uno:AvailableToolbars?Toolbar:string=";
 115 static const char STATIC_INTERNAL_CMD_PART[]    = ".cmd:";
 116
 117 namespace framework
 118 {
 119
 120 typedef std::hash_map< rtl::OUString, rtl::OUString, OUStringHashCode, ::std::equal_to< ::rtl::OUString > > ToolbarHashMap;
 121
 122 struct ToolBarEntry
 123 {
 124     rtl::OUString           aUIName;
 125     rtl::OUString           aCommand;
 126     sal_Bool                bVisible;
 127     sal_Bool                bContextSensitive;
 128     const CollatorWrapper*  pCollatorWrapper;
 129 };
 130
 131 sal_Bool CompareToolBarEntry( const ToolBarEntry& aOne, const ToolBarEntry& aTwo )
 132 {
 133     sal_Int32 nComp = aOne.pCollatorWrapper->compareString( aOne.aUIName, aTwo.aUIName );
 134
 135     if ( nComp < 0 )
 136         return sal_True;
 137     else if ( nComp > 0 )
 138         return sal_False;
 139     else
 140         return sal_False;
 141 }
 142
 143 Reference< XLayoutManager > getLayoutManagerFromFrame( const Reference< XFrame >& rFrame )
 144 {
 145     Reference< XPropertySet >   xPropSet( rFrame, UNO_QUERY );
 146     Reference< XLayoutManager > xLayoutManager;
 147
 148     try
 149     {
 150         xPropSet->getPropertyValue( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "LayoutManager" ))) >>= xLayoutManager;
 151     }
 152     catch ( UnknownPropertyException& )
 153     {
 154     }
 155
 156     return xLayoutManager;
 157 }
 158
 159 struct ToolBarInfo
 160 {
 161     rtl::OUString aToolBarResName;
 162     rtl::OUString aToolBarUIName;
 163 };
 164
 165 DEFINE_XSERVICEINFO_MULTISERVICE        (   ToolbarsMenuController                                  ,
 166                                             OWeakObject                             ,
 167                                             SERVICENAME_POPUPMENUCONTROLLER                 ,
 168                                             IMPLEMENTATIONNAME_TOOLBARSMENUCONTROLLER
 169                                         )
 170
 171 DEFINE_INIT_SERVICE                     (   ToolbarsMenuController, {} )
 172
 173 ToolbarsMenuController::ToolbarsMenuController( const ::com::sun::star::uno::Reference< ::com::sun::star::lang::XMultiServiceFactory >& xServiceManager ) :
 174     PopupMenuControllerBase( xServiceManager ),
 175     m_aPropUIName( RTL_CONSTASCII_USTRINGPARAM( "UIName" )),
 176     m_aPropResourceURL( RTL_CONSTASCII_USTRINGPARAM( "ResourceURL" )),
 177     m_bModuleIdentified( sal_False ),
 178     m_bResetActive( sal_False ),
 179     m_aIntlWrapper( xServiceManager, Application::GetSettings().GetLocale() )
 180 {
 181 }
 182
 183 ToolbarsMenuController::~ToolbarsMenuController()
 184 {
 185 }
 186
 187 void ToolbarsMenuController::addCommand(
 188     Reference< css::awt::XPopupMenu >& rPopupMenu, const rtl::OUString& rCommandURL, USHORT nHelpId, const rtl::OUString& rLabel )
 189 {
 190     USHORT        nItemId    = m_xPopupMenu->getItemCount()+1;
 191
 192     rtl::OUString aLabel;
 193     if ( rLabel.getLength() == 0 )
 194         aLabel = getUINameFromCommand( rCommandURL );
 195     else
 196         aLabel = rLabel;
 197
 198     rPopupMenu->insertItem( nItemId, aLabel, 0, nItemId );
 199     Reference< awt::XMenuExtended > xMenuExtended( m_xPopupMenu, UNO_QUERY );
 200     xMenuExtended->setCommand( nItemId, rCommandURL );
 201
 202     bool bInternal = ( rCommandURL.indexOf( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( STATIC_INTERNAL_CMD_PART ))) == 0);
 203     if ( !bInternal )
 204     {
 205         if ( !getDispatchFromCommandURL( rCommandURL ).is() )
 206             m_xPopupMenu->enableItem( nItemId, sal_False );
 207     }
 208
 209     vos::OGuard aSolarMutexGuard( Application::GetSolarMutex() );
 210
 211     Image                aImage;
 212     const StyleSettings& rSettings = Application::GetSettings().GetStyleSettings();
 213
 214     if ( rSettings.GetUseImagesInMenus() )
 215         aImage = GetImageFromURL( m_xFrame, rCommandURL, FALSE, rSettings.GetHighContrastMode() );
 216
 217     VCLXPopupMenu* pPopupMenu = (VCLXPopupMenu *)VCLXPopupMenu::GetImplementation( rPopupMenu );
 218     if ( pPopupMenu )
 219     {
 220         PopupMenu* pVCLPopupMenu = (PopupMenu *)pPopupMenu->GetMenu();
 221         if ( !!aImage )
 222             pVCLPopupMenu->SetItemImage( nItemId, aImage );
 223         pVCLPopupMenu->SetHelpId( nItemId, nHelpId );
 224     }
 225
 226     m_aCommandVector.push_back( rCommandURL );
 227 }
 228
 229 Reference< XDispatch > ToolbarsMenuController::getDispatchFromCommandURL( const rtl::OUString& rCommandURL )
 230 {
 231     URL                          aTargetURL;
 232     Sequence<PropertyValue>          aArgs;
 233     Reference< XURLTransformer > xURLTransformer;
 234     Reference< XFrame >          xFrame;
 235
 236     {
 237         vos::OGuard aSolarMutexGuard( Application::GetSolarMutex() );
 238         xURLTransformer = m_xURLTransformer;
 239         xFrame = m_xFrame;
 240     }
 241
 242     aTargetURL.Complete = rCommandURL;
 243     xURLTransformer->parseStrict( aTargetURL );
 244     Reference< XDispatchProvider > xDispatchProvider( xFrame, UNO_QUERY );
 245     if ( xDispatchProvider.is() )
 246         return xDispatchProvider->queryDispatch( aTargetURL, ::rtl::OUString(), 0 );
 247     else
 248         return Reference< XDispatch >();
 249 }
 250
 251 // private function
 252 rtl::OUString ToolbarsMenuController::getUINameFromCommand( const rtl::OUString& rCommandURL )
 253 {
 254     rtl::OUString aLabel;
 255
 256     if ( !m_bModuleIdentified  )
 257     {
 258         try
 259         {
 260             Reference< XModuleManager > xModuleManager( m_xServiceManager->createInstance( SERVICENAME_MODULEMANAGER ), UNO_QUERY_THROW );
 261             m_aModuleIdentifier = xModuleManager->identify( m_xFrame );
 262             Reference< XNameAccess > xNameAccess( m_xServiceManager->createInstance(
 263                                                                     SERVICENAME_UICOMMANDDESCRIPTION ),
 264                                                                 UNO_QUERY );
 265             xNameAccess->getByName( m_aModuleIdentifier ) >>= m_xUICommandDescription;
 266         }
 267         catch ( Exception& )
 268         {
 269         }
 270     }
 271
 272     if ( m_xUICommandDescription.is() )
 273     {
 274         try
 275         {
 276             Sequence< PropertyValue > aPropSeq;
 277             rtl::OUString             aStr;
 278             if ( m_xUICommandDescription->getByName( rCommandURL ) >>= aPropSeq )
 279             {
 280                 for ( sal_Int32 i = 0; i < aPropSeq.getLength(); i++ )
 281                 {
 282                     if ( aPropSeq[i].Name.equalsAscii( "Label" ))
 283                     {
 284                         aPropSeq[i].Value >>= aStr;
 285                         break;
 286                     }
 287                 }
 288             }
 289             aLabel = aStr;
 290         }
 291         catch ( Exception& )
 292         {
 293         }
 294     }
 295
 296     return aLabel;
 297 }
 298
 299 static void fillHashMap( const Sequence< Sequence< ::com::sun::star::beans::PropertyValue > >& rSeqToolBars,
 300                          ToolbarHashMap& rHashMap )
 301 {
 302     for ( sal_Int32 i = 0; i < rSeqToolBars.getLength(); i++ )
 303     {
 304         rtl::OUString aResourceURL;
 305         rtl::OUString aUIName;
 306         const PropertyValue* pProperties = rSeqToolBars[i].getConstArray();
 307         for ( sal_Int32 j = 0; j < rSeqToolBars[i].getLength(); j++ )
 308         {
 309             if ( pProperties[j].Name.equalsAscii( ITEM_DESCRIPTOR_RESOURCEURL) )
 310                 pProperties[j].Value >>= aResourceURL;
 311             else if ( pProperties[j].Name.equalsAscii( ITEM_DESCRIPTOR_UINAME) )
 312                 pProperties[j].Value >>= aUIName;
 313         }
 314
 315         if ( aResourceURL.getLength() > 0 &&
 316              rHashMap.find( aResourceURL ) == rHashMap.end() )
 317             rHashMap.insert( ToolbarHashMap::value_type( aResourceURL, aUIName ));
 318     }
 319 }
 320
 321 // private function
 322 Sequence< Sequence< com::sun::star::beans::PropertyValue > > ToolbarsMenuController::getLayoutManagerToolbars( const Reference< ::com::sun::star::frame::XLayoutManager >& rLayoutManager )
 323 {
 324     std::vector< ToolBarInfo > aToolBarArray;
 325     Sequence< Reference< XUIElement > > aUIElements = rLayoutManager->getElements();
 326     for ( sal_Int32 i = 0; i < aUIElements.getLength(); i++ )
 327     {
 328         Reference< XUIElement > xUIElement( aUIElements[i] );
 329         Reference< XPropertySet > xPropSet( aUIElements[i], UNO_QUERY );
 330         if ( xPropSet.is() && xUIElement.is() )
 331         {
 332             try
 333             {
 334                 rtl::OUString   aResName;
 335                 sal_Int16       nType( -1 );
 336                 xPropSet->getPropertyValue( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Type" ))) >>= nType;
 337                 xPropSet->getPropertyValue( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "ResourceURL" ))) >>= aResName;
 338
 339                 if (( nType == ::com::sun::star::ui::UIElementType::TOOLBAR ) &&
 340                     ( aResName.getLength() > 0 ))
 341                 {
 342                     ToolBarInfo aToolBarInfo;
 343
 344                     aToolBarInfo.aToolBarResName = aResName;
 345
 346                     vos::OGuard aGuard( Application::GetSolarMutex() );
 347                     Reference< css::awt::XWindow > xWindow( xUIElement->getRealInterface(), UNO_QUERY );
 348                     Window* pWindow = VCLUnoHelper::GetWindow( xWindow );
 349                     if ( pWindow )
 350                         aToolBarInfo.aToolBarUIName = pWindow->GetText();
 351
 352                     aToolBarArray.push_back( aToolBarInfo );
 353                 }
 354             }
 355             catch ( Exception& )
 356             {
 357             }
 358         }
 359     }
 360
 361     Sequence< com::sun::star::beans::PropertyValue > aTbSeq( 2 );
 362     aTbSeq[0].Name = m_aPropUIName;
 363     aTbSeq[1].Name = m_aPropResourceURL;
 364
 365     Sequence< Sequence< com::sun::star::beans::PropertyValue > > aSeq( aToolBarArray.size() );
 366     const sal_uInt32 nCount = aToolBarArray.size();
 367     for ( sal_uInt32 i = 0; i < nCount; i++ )
 368     {
 369         aTbSeq[0].Value <<= aToolBarArray[i].aToolBarUIName;
 370         aTbSeq[1].Value <<= aToolBarArray[i].aToolBarResName;
 371         aSeq[i] = aTbSeq;
 372     }
 373
 374     return aSeq;
 375 }
 376
 377 sal_Bool ToolbarsMenuController::isContextSensitiveToolbarNonVisible()
 378 {
 379     return m_bResetActive;
 380 }
 381
 382 void ToolbarsMenuController::fillPopupMenu( Reference< css::awt::XPopupMenu >& rPopupMenu )
 383 {
 384     if( SvtMiscOptions().DisableUICustomization() )
 385         return;
 386
 387     vos::OGuard aSolarMutexGuard( Application::GetSolarMutex() );
 388     resetPopupMenu( rPopupMenu );
 389
 390     m_aCommandVector.clear();
 391
 392     // Retrieve layout manager for additional information
 393     rtl::OUString                   aEmptyString;
 394     Reference< awt::XMenuExtended > xMenuExtended( rPopupMenu, UNO_QUERY );
 395     Reference< XLayoutManager >     xLayoutManager( getLayoutManagerFromFrame( m_xFrame ));
 396
 397     m_bResetActive = sal_False;
 398     if ( xLayoutManager.is() )
 399     {
 400         ToolbarHashMap aToolbarHashMap;
 401
 402         if ( m_xDocCfgMgr.is() )
 403         {
 404             Sequence< Sequence< com::sun::star::beans::PropertyValue > > aSeqDocToolBars =
 405                 m_xDocCfgMgr->getUIElementsInfo( UIElementType::TOOLBAR );
 406             fillHashMap( aSeqDocToolBars, aToolbarHashMap );
 407         }
 408
 409         if ( m_xModuleCfgMgr.is() )
 410         {
 411             Sequence< Sequence< com::sun::star::beans::PropertyValue > > aSeqToolBars =
 412                 m_xModuleCfgMgr->getUIElementsInfo( UIElementType::TOOLBAR );
 413             fillHashMap( aSeqToolBars, aToolbarHashMap );
 414         }
 415
 416         std::vector< ToolBarEntry > aSortedTbs;
 417         rtl::OUString               aStaticCmdPart( RTL_CONSTASCII_USTRINGPARAM( STATIC_CMD_PART ));
 418
 419         Sequence< Sequence< com::sun::star::beans::PropertyValue > > aSeqFrameToolBars = getLayoutManagerToolbars( xLayoutManager );
 420         fillHashMap( aSeqFrameToolBars, aToolbarHashMap );
 421
 422         ToolbarHashMap::const_iterator pIter = aToolbarHashMap.begin();
 423         while ( pIter != aToolbarHashMap.end() )
 424         {
 425             rtl::OUString aUIName = pIter->second;
 426             sal_Bool      bHideFromMenu( sal_False );
 427             sal_Bool      bContextSensitive( sal_False );
 428             sal_Bool      bVisible( sal_False );
 429             if ( aUIName.getLength() == 0 &&
 430                  m_xPersistentWindowState.is() )
 431             {
 432                 try
 433                 {
 434                     Sequence< PropertyValue > aWindowState;
 435                     Any                       a( m_xPersistentWindowState->getByName( pIter->first ));
 436
 437                     if ( a >>= aWindowState )
 438                     {
 439                         for ( sal_Int32 i = 0; i < aWindowState.getLength(); i++ )
 440                         {
 441                             if ( aWindowState[i].Name.equalsAscii( WINDOWSTATE_PROPERTY_UINAME ))
 442                                 aWindowState[i].Value >>= aUIName;
 443                             else if ( aWindowState[i].Name.equalsAscii( WINDOWSTATE_PROPERTY_HIDEFROMENU ))
 444                                 aWindowState[i].Value >>= bHideFromMenu;
 445                             else if ( aWindowState[i].Name.equalsAscii( WINDOWSTATE_PROPERTY_CONTEXT ))
 446                                 aWindowState[i].Value >>= bContextSensitive;
 447                             else if ( aWindowState[i].Name.equalsAscii( WINDOWSTATE_PROPERTY_VISIBLE ))
 448                                 aWindowState[i].Value >>= bVisible;
 449                         }
 450                     }
 451                 }
 452                 catch ( Exception& )
 453                 {
 454                 }
 455
 456                 // Check if we have to enable/disable "Reset" menu item
 457                 if ( bContextSensitive && !bVisible )
 458                     m_bResetActive = sal_True;
 459
 460             }
 461
 462             if (( aUIName.getLength() > 0 ) && ( !bHideFromMenu ))
 463             {
 464                 ToolBarEntry aTbEntry;
 465                 aTbEntry.aUIName = aUIName;
 466                 aTbEntry.aCommand = pIter->first;
 467                 aTbEntry.bVisible = xLayoutManager->isElementVisible( pIter->first );
 468                 aTbEntry.bContextSensitive = bContextSensitive;
 469                 aTbEntry.pCollatorWrapper = m_aIntlWrapper.getCaseCollator();
 470                 aSortedTbs.push_back( aTbEntry );
 471             }
 472             pIter++;
 473         }
 474
 475         // sort toolbars
 476         std::sort( aSortedTbs.begin(), aSortedTbs.end(), CompareToolBarEntry );
 477
 478         sal_Int16 nIndex( 1 );
 479         const sal_uInt32 nCount = aSortedTbs.size();
 480         for ( sal_uInt32 i = 0; i < nCount; i++ )
 481         {
 482             USHORT nItemCount = m_xPopupMenu->getItemCount();
 483             m_xPopupMenu->insertItem( nIndex, aSortedTbs[i].aUIName, css::awt::MenuItemStyle::CHECKABLE, nItemCount );
 484             if ( aSortedTbs[i].bVisible )
 485                 m_xPopupMenu->checkItem( nIndex, sal_True );
 486
 487             {
 488                 vos::OGuard     aGuard( Application::GetSolarMutex() );
 489                 VCLXPopupMenu* pXPopupMenu = (VCLXPopupMenu *)VCLXMenu::GetImplementation( m_xPopupMenu );
 490                 PopupMenu*     pVCLPopupMenu = (PopupMenu *)pXPopupMenu->GetMenu();
 491
 492                 pVCLPopupMenu->SetUserValue( nIndex, ULONG( aSortedTbs[i].bContextSensitive ? 1L : 0L ));
 493             }
 494
 495             // use VCL popup menu pointer to set vital information that are not part of the awt implementation
 496             rtl::OUStringBuffer aStrBuf( aStaticCmdPart );
 497
 498             sal_Int32 n = aSortedTbs[i].aCommand.lastIndexOf( '/' );
 499             if (( n > 0 ) && (( n+1 ) < aSortedTbs[i].aCommand.getLength() ))
 500                 aStrBuf.append( aSortedTbs[i].aCommand.copy( n+1 ));
 501
 502             rtl::OUString aCmd( aStrBuf.makeStringAndClear() );
 503
 504             // Store complete uno-command so it can also be dispatched. This is necessary to support
 505             // the test tool!
 506             xMenuExtended->setCommand( nIndex, aCmd );
 507             ++nIndex;
 508         }
 509
 510         // Create commands for non-toolbars
 511         if ( m_aModuleIdentifier.equalsAscii( "com.sun.star.text.TextDocument" ) ||
 512              m_aModuleIdentifier.equalsAscii( "com.sun.star.text.WebDocument" ) ||
 513              m_aModuleIdentifier.equalsAscii( "com.sun.star.text.GlobalDocument" ) ||
 514              m_aModuleIdentifier.equalsAscii( "com.sun.star.drawing.DrawingDocument" ) ||
 515              m_aModuleIdentifier.equalsAscii( "com.sun.star.presentation.PresentationDocument" ) ||
 516              m_aModuleIdentifier.equalsAscii( "com.sun.star.sheet.SpreadsheetDocument" ))
 517         {
 518             addCommand( m_xPopupMenu, rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( CMD_HYPERLINKBAR )), 10360, aEmptyString );
 519             if ( m_aModuleIdentifier.equalsAscii( "com.sun.star.drawing.DrawingDocument" ) ||
 520                  m_aModuleIdentifier.equalsAscii( "com.sun.star.presentation.PresentationDocument" ))
 521                 addCommand( m_xPopupMenu, rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( CMD_COLORBAR )), 10417, aEmptyString );
 522             else if ( m_aModuleIdentifier.equalsAscii( "com.sun.star.sheet.SpreadsheetDocument" ))
 523                 addCommand( m_xPopupMenu, rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( CMD_INPUTLINEBAR )), 26241, aEmptyString );
 524             else
 525                 addCommand( m_xPopupMenu, rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( CMD_FORMULABAR )), 20128, aEmptyString );
 526         }
 527
 528         sal_Bool          bAddCommand( sal_True );
 529         SvtCommandOptions aCmdOptions;
 530         rtl::OUString     aConfigureToolbar( RTL_CONSTASCII_USTRINGPARAM( CONFIGURE_TOOLBARS ));
 531
 532         if ( aCmdOptions.HasEntries( SvtCommandOptions::CMDOPTION_DISABLED ))
 533         {
 534             if ( aCmdOptions.Lookup( SvtCommandOptions::CMDOPTION_DISABLED,
 535                                      rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( CONFIGURE_TOOLBARS_CMD ))))
 536                 bAddCommand = sal_False;
 537         }
 538
 539         if ( bAddCommand )
 540         {
 541             // Create command for configure
 542             if ( m_xPopupMenu->getItemCount() > 0 )
 543             {
 544                 USHORT        nItemCount = m_xPopupMenu->getItemCount();
 545                 m_xPopupMenu->insertSeparator( nItemCount+1 );
 546             }
 547
 548             addCommand( m_xPopupMenu, aConfigureToolbar, 5904, aEmptyString );
 549         }
 550
 551         // Add separator if no configure has been added
 552         if ( !bAddCommand )
 553         {
 554             // Create command for configure
 555             if ( m_xPopupMenu->getItemCount() > 0 )
 556             {
 557                 USHORT        nItemCount = m_xPopupMenu->getItemCount();
 558                 m_xPopupMenu->insertSeparator( nItemCount+1 );
 559             }
 560         }
 561
 562         String aLabelStr = String( FwkResId( STR_RESTORE_TOOLBARS ));
 563         rtl::OUString aRestoreCmd( RTL_CONSTASCII_USTRINGPARAM( CMD_RESTOREVISIBILITY ));
 564         addCommand( m_xPopupMenu, aRestoreCmd, 9999, aLabelStr );
 565     }
 566 }
 567
 568 // XEventListener
 569 void SAL_CALL ToolbarsMenuController::disposing( const EventObject& ) throw ( RuntimeException )
 570 {
 571     Reference< css::awt::XMenuListener > xHolder(( OWeakObject *)this, UNO_QUERY );
 572
 573     ResetableGuard aLock( m_aLock );
 574     m_xFrame.clear();
 575     m_xDispatch.clear();
 576     m_xDocCfgMgr.clear();
 577     m_xModuleCfgMgr.clear();
 578     m_xServiceManager.clear();
 579
 580     if ( m_xPopupMenu.is() )
 581         m_xPopupMenu->removeMenuListener( Reference< css::awt::XMenuListener >(( OWeakObject *)this, UNO_QUERY ));
 582     m_xPopupMenu.clear();
 583 }
 584
 585 // XStatusListener
 586 void SAL_CALL ToolbarsMenuController::statusChanged( const FeatureStateEvent& Event ) throw ( RuntimeException )
 587 {
 588     rtl::OUString aFeatureURL( Event.FeatureURL.Complete );
 589
 590     // All other status events will be processed here
 591     sal_Bool bSetCheckmark      = sal_False;
 592     sal_Bool bCheckmark                 = sal_False;
 593
 594     ResetableGuard aLock( m_aLock );
 595     Reference< css::awt::XPopupMenu > xPopupMenu( m_xPopupMenu );
 596     aLock.unlock();
 597
 598     if ( xPopupMenu.is() )
 599     {
 600         vos::OGuard     aGuard( Application::GetSolarMutex() );
 601         VCLXPopupMenu* pXPopupMenu = (VCLXPopupMenu *)VCLXMenu::GetImplementation( xPopupMenu );
 602         PopupMenu*     pVCLPopupMenu = (PopupMenu *)pXPopupMenu->GetMenu();
 603
 604         for ( USHORT i = 0; i < pVCLPopupMenu->GetItemCount(); i++ )
 605         {
 606             USHORT nId = pVCLPopupMenu->GetItemId( i );
 607             if ( nId == 0 )
 608                 continue;
 609
 610             rtl::OUString aCmd = pVCLPopupMenu->GetItemCommand( nId );
 611             if ( aCmd == aFeatureURL )
 612             {
 613                 // Enable/disable item
 614                 pVCLPopupMenu->EnableItem( nId, Event.IsEnabled );
 615
 616                 // Checkmark
 617                 if ( Event.State >>= bCheckmark )
 618                     bSetCheckmark = sal_True;
 619
 620                 if ( bSetCheckmark )
 621                     pVCLPopupMenu->CheckItem( nId, bCheckmark );
 622                 else
 623                 {
 624                     rtl::OUString aItemText;
 625
 626                     if ( Event.State >>= aItemText )
 627                         pVCLPopupMenu->SetItemText( nId, aItemText );
 628                 }
 629             }
 630         }
 631     }
 632 }
 633
 634 // XMenuListener
 635 void SAL_CALL ToolbarsMenuController::select( const css::awt::MenuEvent& rEvent ) throw (RuntimeException)
 636 {
 637     Reference< css::awt::XPopupMenu >   xPopupMenu;
 638     Reference< XMultiServiceFactory >   xServiceManager;
 639     Reference< XURLTransformer >        xURLTransformer;
 640     Reference< XFrame >                 xFrame;
 641     Reference< XNameAccess >            xPersistentWindowState;
 642
 643     ResetableGuard aLock( m_aLock );
 644     xPopupMenu             = m_xPopupMenu;
 645     xServiceManager        = m_xServiceManager;
 646     xURLTransformer        = m_xURLTransformer;
 647     xFrame                 = m_xFrame;
 648     xPersistentWindowState = m_xPersistentWindowState;
 649     aLock.unlock();
 650
 651     if ( xPopupMenu.is() )
 652     {
 653         VCLXPopupMenu* pPopupMenu = (VCLXPopupMenu *)VCLXPopupMenu::GetImplementation( xPopupMenu );
 654         if ( pPopupMenu )
 655         {
 656             vos::OGuard aSolarMutexGuard( Application::GetSolarMutex() );
 657             PopupMenu* pVCLPopupMenu = (PopupMenu *)pPopupMenu->GetMenu();
 658
 659             rtl::OUString aCmd( pVCLPopupMenu->GetItemCommand( rEvent.MenuId ));
 660             if ( aCmd.indexOf( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( STATIC_INTERNAL_CMD_PART ))) == 0 )
 661             {
 662                 // Command to restore the visibility of all context sensitive toolbars
 663                 Reference< XNameReplace > xNameReplace( xPersistentWindowState, UNO_QUERY );
 664                 if ( xPersistentWindowState.is() && xNameReplace.is() )
 665                 {
 666                     try
 667                     {
 668                         Sequence< rtl::OUString > aElementNames = xPersistentWindowState->getElementNames();
 669                         sal_Int32 nCount = aElementNames.getLength();
 670                         bool      bRefreshToolbars( false );
 671
 672                         for ( sal_Int32 i = 0; i < nCount; i++ )
 673                         {
 674                             try
 675                             {
 676                                 rtl::OUString aElementName = aElementNames[i];
 677                                 Sequence< PropertyValue > aWindowState;
 678
 679                                 if ( xPersistentWindowState->getByName( aElementName ) >>= aWindowState )
 680                                 {
 681                                     sal_Bool  bVisible( sal_False );
 682                                     sal_Bool  bContextSensitive( sal_False );
 683                                     sal_Int32 nVisibleIndex( -1 );
 684                                     for ( sal_Int32 j = 0; j < aWindowState.getLength(); j++ )
 685                                     {
 686                                         if ( aWindowState[j].Name.equalsAscii( WINDOWSTATE_PROPERTY_VISIBLE ))
 687                                         {
 688                                             aWindowState[j].Value >>= bVisible;
 689                                             nVisibleIndex = j;
 690                                         }
 691                                         else if ( aWindowState[j].Name.equalsAscii( WINDOWSTATE_PROPERTY_CONTEXT ))
 692                                             aWindowState[j].Value >>= bContextSensitive;
 693                                     }
 694
 695                                     if ( !bVisible && bContextSensitive && nVisibleIndex >= 0 )
 696                                     {
 697                                         // Default is: Every context sensitive toolbar is visible
 698                                         aWindowState[nVisibleIndex].Value <<= sal_True;
 699                                         xNameReplace->replaceByName( aElementName, makeAny( aWindowState ));
 700                                         bRefreshToolbars = true;
 701                                     }
 702                                 }
 703                             }
 704                             catch ( NoSuchElementException& )
 705                             {
 706                             }
 707                         }
 708
 709                         if ( bRefreshToolbars )
 710                         {
 711                             Reference< XLayoutManager > xLayoutManager( getLayoutManagerFromFrame( xFrame ));
 712                             if ( xLayoutManager.is() )
 713                             {
 714                                 Reference< XPropertySet > xPropSet( xLayoutManager, UNO_QUERY );
 715                                 if ( xPropSet.is() )
 716                                 {
 717                                     try
 718                                     {
 719                                         xPropSet->setPropertyValue( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "RefreshContextToolbarVisibility" )), makeAny( sal_True ));
 720                                     }
 721                                     catch ( RuntimeException& )
 722                                     {
 723                                     }
 724                                     catch ( Exception& )
 725                                     {
 726                                     }
 727                                 }
 728                             }
 729                             RefreshToolbars( xFrame );
 730                         }
 731                     }
 732                     catch ( RuntimeException& )
 733                     {
 734                         throw;
 735                     }
 736                     catch ( Exception& )
 737                     {
 738                     }
 739                 }
 740             }
 741             else if ( aCmd.indexOf( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( STATIC_CMD_PART ))) < 0 )
 742             {
 743                 URL                     aTargetURL;
 744                 Sequence<PropertyValue> aArgs;
 745
 746                 aTargetURL.Complete = aCmd;
 747                 xURLTransformer->parseStrict( aTargetURL );
 748                 Reference< XDispatchProvider > xDispatchProvider( m_xFrame, UNO_QUERY );
 749                 if ( xDispatchProvider.is() )
 750                 {
 751                     Reference< XDispatch > xDispatch = xDispatchProvider->queryDispatch(
 752                                                             aTargetURL, ::rtl::OUString(), 0 );
 753
 754                     ExecuteInfo* pExecuteInfo = new ExecuteInfo;
 755                     pExecuteInfo->xDispatch     = xDispatch;
 756                     pExecuteInfo->aTargetURL    = aTargetURL;
 757                     pExecuteInfo->aArgs         = aArgs;
 758                     if(::comphelper::UiEventsLogger::isEnabled()) //#i88653#
 759                         UiEventLogHelper(::rtl::OUString::createFromAscii("ToolbarsMenuController")).log(m_xServiceManager, m_xFrame, aTargetURL, aArgs);
 760                     Application::PostUserEvent( STATIC_LINK(0, ToolbarsMenuController, ExecuteHdl_Impl), pExecuteInfo );
 761                 }
 762             }
 763             else
 764             {
 765                 Reference< XLayoutManager > xLayoutManager( getLayoutManagerFromFrame( xFrame ));
 766                 if ( xLayoutManager.is() )
 767                 {
 768                     // Extract toolbar name from the combined uno-command.
 769                     sal_Int32 nIndex = aCmd.indexOf( '=' );
 770                     if (( nIndex > 0 ) && (( nIndex+1 ) < aCmd.getLength() ))
 771                     {
 772                         rtl::OUStringBuffer aBuf( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( STATIC_PRIVATE_TB_RESOURCE )));
 773                         aBuf.append( aCmd.copy( nIndex+1 ));
 774
 775                         sal_Bool      bShow( !pVCLPopupMenu->IsItemChecked( rEvent.MenuId ));
 776                         rtl::OUString aToolBarResName( aBuf.makeStringAndClear() );
 777                         if ( bShow )
 778                         {
 779                             xLayoutManager->createElement( aToolBarResName );
 780                             xLayoutManager->showElement( aToolBarResName );
 781                         }
 782                         else
 783                         {
 784                             // closing means:
 785                             // hide and destroy element
 786                             xLayoutManager->hideElement( aToolBarResName );
 787                             xLayoutManager->destroyElement( aToolBarResName );
 788                         }
 789                     }
 790                 }
 791             }
 792         }
 793     }
 794 }
 795
 796 void SAL_CALL ToolbarsMenuController::activate( const css::awt::MenuEvent& ) throw (RuntimeException)
 797 {
 798     std::vector< rtl::OUString >   aCmdVector;
 799     Reference< XDispatchProvider > xDispatchProvider( m_xFrame, UNO_QUERY );
 800     Reference< XURLTransformer >   xURLTransformer( m_xURLTransformer );
 801     {
 802         ResetableGuard aLock( m_aLock );
 803         fillPopupMenu( m_xPopupMenu );
 804         aCmdVector = m_aCommandVector;
 805     }
 806
 807     // Update status for all commands inside our toolbars popup menu
 808     const sal_uInt32 nCount = aCmdVector.size();
 809     for ( sal_uInt32 i = 0; i < nCount; i++ )
 810     {
 811         bool bInternal = ( aCmdVector[i].indexOf( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( STATIC_INTERNAL_CMD_PART ))) == 0);
 812
 813         if ( !bInternal )
 814         {
 815             URL aTargetURL;
 816             aTargetURL.Complete = aCmdVector[i];
 817             xURLTransformer->parseStrict( aTargetURL );
 818             Reference< XDispatch > xDispatch = xDispatchProvider->queryDispatch( aTargetURL, ::rtl::OUString(), 0 );
 819             if ( xDispatch.is() )
 820             {
 821                 xDispatch->addStatusListener( SAL_STATIC_CAST( XStatusListener*, this ), aTargetURL );
 822                 xDispatch->removeStatusListener( SAL_STATIC_CAST( XStatusListener*, this ), aTargetURL );
 823             }
 824         }
 825         else if ( aCmdVector[i].equalsAscii( CMD_RESTOREVISIBILITY ))
 826         {
 827             // Special code to determine the enable/disable state of this command
 828             FeatureStateEvent aFeatureStateEvent;
 829             aFeatureStateEvent.FeatureURL.Complete = aCmdVector[i];
 830             aFeatureStateEvent.IsEnabled = isContextSensitiveToolbarNonVisible();
 831             statusChanged( aFeatureStateEvent );
 832         }
 833     }
 834 }
 835
 836 // XPopupMenuController
 837 void SAL_CALL ToolbarsMenuController::setPopupMenu( const Reference< css::awt::XPopupMenu >& xPopupMenu ) throw ( RuntimeException )
 838 {
 839     ResetableGuard aLock( m_aLock );
 840
 841     if ( m_bDisposed )
 842         throw DisposedException();
 843
 844     if ( m_xFrame.is() && !m_xPopupMenu.is() )
 845     {
 846         // Create popup menu on demand
 847         vos::OGuard aSolarMutexGuard( Application::GetSolarMutex() );
 848
 849         m_xPopupMenu = xPopupMenu;
 850         m_xPopupMenu->addMenuListener( Reference< css::awt::XMenuListener >( (OWeakObject*)this, UNO_QUERY ));
 851         fillPopupMenu( m_xPopupMenu );
 852     }
 853 }
 854
 855 // XInitialization
 856 void SAL_CALL ToolbarsMenuController::initialize( const Sequence< Any >& aArguments ) throw ( Exception, RuntimeException )
 857 {
 858     ResetableGuard aLock( m_aLock );
 859     sal_Bool bInitalized( m_bInitialized );
 860     if ( !bInitalized )
 861     {
 862         PopupMenuControllerBase::initialize(aArguments);
 863
 864         if ( m_bInitialized )
 865         {
 866             Reference< XModuleManager > xModuleManager( m_xServiceManager->createInstance(
 867                                                             SERVICENAME_MODULEMANAGER ),
 868                                                         UNO_QUERY );
 869             Reference< XNameAccess > xPersistentWindowStateSupplier( m_xServiceManager->createInstance(
 870                                                                         SERVICENAME_WINDOWSTATECONFIGURATION ),
 871                                                                      UNO_QUERY );
 872
 873             // Retrieve persistent window state reference for our module
 874             if ( xPersistentWindowStateSupplier.is() && xModuleManager.is() )
 875             {
 876                 rtl::OUString aModuleIdentifier;
 877                 try
 878                 {
 879                     aModuleIdentifier = xModuleManager->identify( m_xFrame );
 880                     xPersistentWindowStateSupplier->getByName( aModuleIdentifier ) >>= m_xPersistentWindowState;
 881
 882                     Reference< XModuleUIConfigurationManagerSupplier > xModuleCfgSupplier;
 883                     if ( m_xServiceManager.is() )
 884                         xModuleCfgSupplier = Reference< XModuleUIConfigurationManagerSupplier >(
 885                             m_xServiceManager->createInstance( SERVICENAME_MODULEUICONFIGURATIONMANAGERSUPPLIER ), UNO_QUERY );
 886                     m_xModuleCfgMgr = xModuleCfgSupplier->getUIConfigurationManager( aModuleIdentifier );
 887
 888                     Reference< XController > xController = m_xFrame->getController();
 889                     Reference< XModel >      xModel;
 890                     if ( xController.is() )
 891                         xModel = xController->getModel();
 892                     if ( xModel.is() )
 893                     {
 894                         Reference< XUIConfigurationManagerSupplier > xUIConfigurationManagerSupplier( xModel, UNO_QUERY );
 895                         if ( xUIConfigurationManagerSupplier.is() )
 896                             m_xDocCfgMgr = xUIConfigurationManagerSupplier->getUIConfigurationManager();
 897                     }
 898                     m_aModuleIdentifier = aModuleIdentifier;
 899                 }
 900                 catch ( Exception& )
 901                 {
 902                 }
 903             }
 904         }
 905     }
 906 }
 907
 908 IMPL_STATIC_LINK_NOINSTANCE( ToolbarsMenuController, ExecuteHdl_Impl, ExecuteInfo*, pExecuteInfo )
 909 {
 910     try
 911     {
 912         // Asynchronous execution as this can lead to our own destruction!
 913         // Framework can recycle our current frame and the layout manager disposes all user interface
 914         // elements if a component gets detached from its frame!
 915         if ( pExecuteInfo->xDispatch.is() )
 916         {
 917             pExecuteInfo->xDispatch->dispatch( pExecuteInfo->aTargetURL, pExecuteInfo->aArgs );
 918         }
 919     }
 920     catch ( Exception& )
 921     {
 922     }
 923
 924     delete pExecuteInfo;
 925     return 0;
 926 }
 927
 928 }