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