framework/source/uielement/newmenucontroller.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: newmenucontroller.cxx,v $
  10  * $Revision: 1.12.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/newmenucontroller.hxx>
  34
  35 //_________________________________________________________________________________________________________________
  36 //      my own includes
  37 //_________________________________________________________________________________________________________________
  38 #include <threadhelp/resetableguard.hxx>
  39 #include "services.h"
  40 #ifndef __FRAMEWORK_CLASSES_RESOURCE_HRC_
  41 #include <classes/resource.hrc>
  42 #endif
  43 #include <classes/fwkresid.hxx>
  44 #include <classes/bmkmenu.hxx>
  45 #include <helper/imageproducer.hxx>
  46 #include <xml/menuconfiguration.hxx>
  47
  48 //_________________________________________________________________________________________________________________
  49 //      interface includes
  50 //_________________________________________________________________________________________________________________
  51 #include <com/sun/star/awt/XDevice.hpp>
  52 #include <com/sun/star/beans/PropertyValue.hpp>
  53 #include <com/sun/star/awt/MenuItemStyle.hpp>
  54 #include <com/sun/star/ui/XModuleUIConfigurationManagerSupplier.hpp>
  55 #include <com/sun/star/ui/XUIConfigurationManagerSupplier.hpp>
  56 #include <com/sun/star/frame/XModuleManager.hpp>
  57 #include <com/sun/star/container/XNameAccess.hpp>
  58 #include <com/sun/star/document/CorruptedFilterConfigurationException.hpp>
  59
  60 //_________________________________________________________________________________________________________________
  61 //      includes of other projects
  62 //_________________________________________________________________________________________________________________
  63 #include <vcl/svapp.hxx>
  64 #include <vcl/i18nhelp.hxx>
  65 #include <tools/urlobj.hxx>
  66 #include <rtl/ustrbuf.hxx>
  67 #include <cppuhelper/implbase1.hxx>
  68 #include <osl/file.hxx>
  69 #include <svtools/menuoptions.hxx>
  70 #include <svtools/acceleratorexecute.hxx>
  71 #include <svtools/moduleoptions.hxx>
  72 #include <dispatch/uieventloghelper.hxx>
  73
  74 //_________________________________________________________________________________________________________________
  75 //      Defines
  76 //_________________________________________________________________________________________________________________
  77 //
  78
  79 using namespace com::sun::star::uno;
  80 using namespace com::sun::star::lang;
  81 using namespace com::sun::star::frame;
  82 using namespace com::sun::star::beans;
  83 using namespace com::sun::star::util;
  84 using namespace com::sun::star::container;
  85 using namespace com::sun::star::ui;
  86
  87 static const char SFX_REFERER_USER[] = "private:user";
  88
  89 namespace framework
  90 {
  91
  92 DEFINE_XSERVICEINFO_MULTISERVICE        (   NewMenuController                           ,
  93                                             OWeakObject                                 ,
  94                                             SERVICENAME_POPUPMENUCONTROLLER                     ,
  95                                             IMPLEMENTATIONNAME_NEWMENUCONTROLLER
  96                                         )
  97
  98 DEFINE_INIT_SERVICE                     (   NewMenuController, {} )
  99
 100 void NewMenuController::setMenuImages( PopupMenu* pPopupMenu, sal_Bool bSetImages, sal_Bool bHiContrast )
 101 {
 102     USHORT nItemCount = pPopupMenu->GetItemCount();
 103     Image               aImage;
 104     Reference< XFrame > xFrame( m_xFrame );
 105
 106     for ( USHORT i = 0; i < nItemCount; i++ )
 107     {
 108         USHORT nItemId = pPopupMenu->GetItemId( sal::static_int_cast<USHORT>( i ));
 109         if ( nItemId != 0 )
 110         {
 111             if ( bSetImages )
 112             {
 113                 sal_Bool        bImageSet( sal_False );
 114                 ::rtl::OUString aImageId;
 115
 116                 AddInfoForId::const_iterator pInfo = m_aAddInfoForItem.find( nItemId );
 117                 if ( pInfo != m_aAddInfoForItem.end() )
 118                     aImageId = pInfo->second.aImageId; // Retrieve image id for menu item
 119
 120                 if ( aImageId.getLength() > 0 )
 121                 {
 122                     aImage = GetImageFromURL( xFrame, aImageId, FALSE, bHiContrast );
 123                     if ( !!aImage )
 124                     {
 125                         bImageSet = sal_True;
 126                         pPopupMenu->SetItemImage( nItemId, aImage );
 127                     }
 128                 }
 129
 130                 if ( !bImageSet )
 131                 {
 132                     String aCmd( pPopupMenu->GetItemCommand( nItemId ) );
 133                     if ( aCmd.Len() )
 134                         aImage = GetImageFromURL( xFrame, aCmd, FALSE, bHiContrast );
 135
 136                     if ( !!aImage )
 137                         pPopupMenu->SetItemImage( nItemId, aImage );
 138                 }
 139             }
 140             else
 141                 pPopupMenu->SetItemImage( nItemId, aImage );
 142         }
 143     }
 144 }
 145
 146 void NewMenuController::determineAndSetNewDocAccel( PopupMenu* pPopupMenu, const KeyCode& rKeyCode )
 147 {
 148     USHORT        nCount( pPopupMenu->GetItemCount() );
 149     USHORT        nId( 0 );
 150     sal_Bool      bFound( sal_False );
 151     rtl::OUString aCommand;
 152
 153     if ( m_aEmptyDocURL.getLength() > 0 )
 154     {
 155         // Search for the empty document URL
 156
 157         for ( sal_uInt32 i = 0; i < sal_uInt32( nCount ); i++ )
 158         {
 159             nId = pPopupMenu->GetItemId( USHORT( i ));
 160             if ( nId != 0 && pPopupMenu->GetItemType( nId ) != MENUITEM_SEPARATOR )
 161             {
 162                 aCommand = pPopupMenu->GetItemCommand( nId );
 163                 if ( aCommand.indexOf( m_aEmptyDocURL ) == 0 )
 164                 {
 165                     pPopupMenu->SetAccelKey( nId, rKeyCode );
 166                     bFound = sal_True;
 167                     break;
 168                 }
 169             }
 170         }
 171     }
 172
 173     if ( !bFound )
 174     {
 175         // Search for the default module name
 176         rtl::OUString aDefaultModuleName( SvtModuleOptions().GetDefaultModuleName() );
 177         if ( aDefaultModuleName.getLength() > 0 )
 178         {
 179             for ( sal_uInt32 i = 0; i < sal_uInt32( nCount ); i++ )
 180             {
 181                 nId = pPopupMenu->GetItemId( USHORT( i ));
 182                 if ( nId != 0 && pPopupMenu->GetItemType( nId ) != MENUITEM_SEPARATOR )
 183                 {
 184                     aCommand = pPopupMenu->GetItemCommand( nId );
 185                     if ( aCommand.indexOf( aDefaultModuleName ) >= 0 )
 186                     {
 187                         pPopupMenu->SetAccelKey( nId, rKeyCode );
 188                         break;
 189                     }
 190                 }
 191             }
 192         }
 193     }
 194 }
 195
 196 void NewMenuController::setAccelerators( PopupMenu* pPopupMenu )
 197 {
 198     if ( m_bModuleIdentified )
 199     {
 200         Reference< XAcceleratorConfiguration > xDocAccelCfg( m_xDocAcceleratorManager );
 201         Reference< XAcceleratorConfiguration > xModuleAccelCfg( m_xModuleAcceleratorManager );
 202         Reference< XAcceleratorConfiguration > xGlobalAccelCfg( m_xGlobalAcceleratorManager );
 203
 204         if ( !m_bAcceleratorCfg )
 205         {
 206             // Retrieve references on demand
 207             m_bAcceleratorCfg = sal_True;
 208             if ( !xDocAccelCfg.is() )
 209             {
 210                 Reference< XController > xController = m_xFrame->getController();
 211                 Reference< XModel > xModel;
 212                 if ( xController.is() )
 213                 {
 214                     xModel = xController->getModel();
 215                     if ( xModel.is() )
 216                     {
 217                         Reference< XUIConfigurationManagerSupplier > xSupplier( xModel, UNO_QUERY );
 218                         if ( xSupplier.is() )
 219                         {
 220                             Reference< XUIConfigurationManager > xDocUICfgMgr( xSupplier->getUIConfigurationManager(), UNO_QUERY );
 221                             if ( xDocUICfgMgr.is() )
 222                             {
 223                                 xDocAccelCfg = Reference< XAcceleratorConfiguration >( xDocUICfgMgr->getShortCutManager(), UNO_QUERY );
 224                                 m_xDocAcceleratorManager = xDocAccelCfg;
 225                             }
 226                         }
 227                     }
 228                 }
 229             }
 230
 231             if ( !xModuleAccelCfg.is() )
 232             {
 233                 Reference< XModuleUIConfigurationManagerSupplier > xModuleCfgMgrSupplier( m_xServiceManager->createInstance(
 234                                                                                             SERVICENAME_MODULEUICONFIGURATIONMANAGERSUPPLIER ),
 235                                                                                         UNO_QUERY );
 236                 Reference< XUIConfigurationManager > xUICfgMgr = xModuleCfgMgrSupplier->getUIConfigurationManager( m_aModuleIdentifier );
 237                 if ( xUICfgMgr.is() )
 238                 {
 239                     xModuleAccelCfg = Reference< XAcceleratorConfiguration >( xUICfgMgr->getShortCutManager(), UNO_QUERY );
 240                     m_xModuleAcceleratorManager = xModuleAccelCfg;
 241                 }
 242             }
 243
 244             if ( !xGlobalAccelCfg.is() )
 245             {
 246                 xGlobalAccelCfg = Reference< XAcceleratorConfiguration >( m_xServiceManager->createInstance(
 247                                                                             SERVICENAME_GLOBALACCELERATORCONFIGURATION ),
 248                                                                           UNO_QUERY );
 249                 m_xGlobalAcceleratorManager = xGlobalAccelCfg;
 250             }
 251         }
 252
 253         KeyCode                         aEmptyKeyCode;
 254         sal_uInt32                      nItemCount( pPopupMenu->GetItemCount() );
 255         std::vector< KeyCode >          aMenuShortCuts;
 256         std::vector< rtl::OUString >    aCmds;
 257         std::vector< sal_uInt32 >       aIds;
 258         for ( sal_uInt32 i = 0; i < nItemCount; i++ )
 259         {
 260             USHORT nId( pPopupMenu->GetItemId( USHORT( i )));
 261             if ( nId & ( pPopupMenu->GetItemType( nId ) != MENUITEM_SEPARATOR ))
 262             {
 263                 aIds.push_back( nId );
 264                 aMenuShortCuts.push_back( aEmptyKeyCode );
 265                 aCmds.push_back( pPopupMenu->GetItemCommand( nId ));
 266             }
 267         }
 268
 269         sal_uInt32 nSeqCount( aIds.size() );
 270
 271         if ( m_bNewMenu )
 272             nSeqCount+=1;
 273
 274         Sequence< rtl::OUString > aSeq( nSeqCount );
 275
 276         // Add a special command for our "New" menu.
 277         if ( m_bNewMenu )
 278         {
 279             aSeq[nSeqCount-1] = m_aCommandURL;
 280             aMenuShortCuts.push_back( aEmptyKeyCode );
 281         }
 282
 283         const sal_uInt32 nCount = aCmds.size();
 284         for ( sal_uInt32 i = 0; i < nCount; i++ )
 285             aSeq[i] = aCmds[i];
 286
 287         if ( m_xGlobalAcceleratorManager.is() )
 288             retrieveShortcutsFromConfiguration( xGlobalAccelCfg, aSeq, aMenuShortCuts );
 289         if ( m_xModuleAcceleratorManager.is() )
 290             retrieveShortcutsFromConfiguration( xModuleAccelCfg, aSeq, aMenuShortCuts );
 291         if ( m_xDocAcceleratorManager.is() )
 292             retrieveShortcutsFromConfiguration( xGlobalAccelCfg, aSeq, aMenuShortCuts );
 293
 294         const sal_uInt32 nCount2 = aIds.size();
 295         for ( sal_uInt32 i = 0; i < nCount2; i++ )
 296             pPopupMenu->SetAccelKey( USHORT( aIds[i] ), aMenuShortCuts[i] );
 297
 298         // Special handling for "New" menu short-cut should be set at the
 299         // document which will be opened using it.
 300         if ( m_bNewMenu )
 301         {
 302             if ( aMenuShortCuts[nSeqCount-1] != aEmptyKeyCode )
 303                 determineAndSetNewDocAccel( pPopupMenu, aMenuShortCuts[nSeqCount-1] );
 304         }
 305     }
 306 }
 307
 308 void NewMenuController::retrieveShortcutsFromConfiguration(
 309     const Reference< XAcceleratorConfiguration >& rAccelCfg,
 310     const Sequence< rtl::OUString >& rCommands,
 311     std::vector< KeyCode >& aMenuShortCuts )
 312 {
 313     if ( rAccelCfg.is() )
 314     {
 315         try
 316         {
 317             com::sun::star::awt::KeyEvent aKeyEvent;
 318             Sequence< Any > aSeqKeyCode = rAccelCfg->getPreferredKeyEventsForCommandList( rCommands );
 319             for ( sal_Int32 i = 0; i < aSeqKeyCode.getLength(); i++ )
 320             {
 321                 if ( aSeqKeyCode[i] >>= aKeyEvent )
 322                     aMenuShortCuts[i] = svt::AcceleratorExecute::st_AWTKey2VCLKey( aKeyEvent );
 323             }
 324         }
 325         catch ( IllegalArgumentException& )
 326         {
 327         }
 328     }
 329 }
 330
 331 NewMenuController::NewMenuController( const ::com::sun::star::uno::Reference< ::com::sun::star::lang::XMultiServiceFactory >& xServiceManager ) :
 332     PopupMenuControllerBase( xServiceManager ),
 333     m_bShowImages( sal_True ),
 334     m_bHiContrast( sal_False ),
 335     m_bNewMenu( sal_False ),
 336     m_bModuleIdentified( sal_False ),
 337     m_bAcceleratorCfg( sal_False ),
 338     m_aTargetFrame( RTL_CONSTASCII_USTRINGPARAM( "_default" ))
 339 {
 340 }
 341
 342 NewMenuController::~NewMenuController()
 343 {
 344 }
 345
 346 // private function
 347 void NewMenuController::fillPopupMenu( Reference< css::awt::XPopupMenu >& rPopupMenu )
 348 {
 349     VCLXPopupMenu* pPopupMenu    = (VCLXPopupMenu *)VCLXMenu::GetImplementation( rPopupMenu );
 350     PopupMenu*     pVCLPopupMenu = 0;
 351
 352     vos::OGuard aSolarMutexGuard( Application::GetSolarMutex() );
 353
 354     resetPopupMenu( rPopupMenu );
 355     if ( pPopupMenu )
 356         pVCLPopupMenu = (PopupMenu *)pPopupMenu->GetMenu();
 357
 358     if ( pVCLPopupMenu )
 359     {
 360         MenuConfiguration aMenuCfg( m_xServiceManager );
 361         BmkMenu* pSubMenu( 0 );
 362
 363         if ( m_bNewMenu )
 364             pSubMenu = (BmkMenu*)aMenuCfg.CreateBookmarkMenu( m_xFrame, BOOKMARK_NEWMENU );
 365         else
 366             pSubMenu = (BmkMenu*)aMenuCfg.CreateBookmarkMenu( m_xFrame, BOOKMARK_WIZARDMENU );
 367
 368         // copy entries as we have to use the provided popup menu
 369         *pVCLPopupMenu = *pSubMenu;
 370
 371         Image           aImage;
 372         AddInfo         aAddInfo;
 373
 374         // retrieve additional parameters from bookmark menu and
 375         // store it in a hash_map.
 376         for ( USHORT i = 0; i < pSubMenu->GetItemCount(); i++ )
 377         {
 378             USHORT nItemId = pSubMenu->GetItemId( sal::static_int_cast<USHORT>( i ) );
 379             if (( nItemId != 0 ) &&
 380                 ( pSubMenu->GetItemType( nItemId ) != MENUITEM_SEPARATOR ))
 381             {
 382                 MenuConfiguration::Attributes* pBmkAttributes = (MenuConfiguration::Attributes *)(pSubMenu->GetUserValue( nItemId ));
 383                 if ( pBmkAttributes != 0 )
 384                 {
 385                     aAddInfo.aTargetFrame = pBmkAttributes->aTargetFrame;
 386                     aAddInfo.aImageId     = pBmkAttributes->aImageId;
 387
 388                     m_aAddInfoForItem.insert( AddInfoForId::value_type( nItemId, aAddInfo ));
 389                 }
 390             }
 391         }
 392
 393         if ( m_bShowImages )
 394             setMenuImages( pVCLPopupMenu, m_bShowImages, m_bHiContrast );
 395
 396         delete pSubMenu;
 397     }
 398 }
 399
 400 // XEventListener
 401 void SAL_CALL NewMenuController::disposing( const EventObject& ) throw ( RuntimeException )
 402 {
 403     Reference< css::awt::XMenuListener > xHolder(( OWeakObject *)this, UNO_QUERY );
 404
 405     ResetableGuard aLock( m_aLock );
 406     m_xFrame.clear();
 407     m_xDispatch.clear();
 408     m_xServiceManager.clear();
 409
 410     if ( m_xPopupMenu.is() )
 411         m_xPopupMenu->removeMenuListener( Reference< css::awt::XMenuListener >(( OWeakObject *)this, UNO_QUERY ));
 412     m_xPopupMenu.clear();
 413 }
 414
 415 // XStatusListener
 416 void SAL_CALL NewMenuController::statusChanged( const FeatureStateEvent& ) throw ( RuntimeException )
 417 {
 418 }
 419
 420 // XMenuListener
 421 void SAL_CALL NewMenuController::select( const css::awt::MenuEvent& rEvent ) throw (RuntimeException)
 422 {
 423     Reference< css::awt::XPopupMenu > xPopupMenu;
 424     Reference< XDispatch >            xDispatch;
 425     Reference< XDispatchProvider >    xDispatchProvider;
 426     Reference< XMultiServiceFactory > xServiceManager;
 427     Reference< XURLTransformer >      xURLTransformer;
 428
 429     ResetableGuard aLock( m_aLock );
 430     xPopupMenu          = m_xPopupMenu;
 431     xDispatchProvider   = Reference< XDispatchProvider >( m_xFrame, UNO_QUERY );
 432     xServiceManager     = m_xServiceManager;
 433     xURLTransformer     = m_xURLTransformer;
 434     aLock.unlock();
 435
 436     css::util::URL aTargetURL;
 437     Sequence< PropertyValue > aArgsList( 1 );
 438
 439     if ( xPopupMenu.is() && xDispatchProvider.is() )
 440     {
 441         VCLXPopupMenu* pPopupMenu = (VCLXPopupMenu *)VCLXPopupMenu::GetImplementation( xPopupMenu );
 442         if ( pPopupMenu )
 443         {
 444             {
 445                 vos::OGuard aSolarMutexGuard( Application::GetSolarMutex() );
 446                 PopupMenu* pVCLPopupMenu = (PopupMenu *)pPopupMenu->GetMenu();
 447                 aTargetURL.Complete = pVCLPopupMenu->GetItemCommand( rEvent.MenuId );
 448             }
 449
 450             xURLTransformer->parseStrict( aTargetURL );
 451
 452             aArgsList[0].Name = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Referer" ));
 453             aArgsList[0].Value = makeAny( ::rtl::OUString::createFromAscii( SFX_REFERER_USER ));
 454
 455             rtl::OUString aTargetFrame( m_aTargetFrame );
 456             AddInfoForId::const_iterator pItem = m_aAddInfoForItem.find( rEvent.MenuId );
 457             if ( pItem != m_aAddInfoForItem.end() )
 458                 aTargetFrame = pItem->second.aTargetFrame;
 459
 460             xDispatch = xDispatchProvider->queryDispatch( aTargetURL, aTargetFrame, 0 );
 461         }
 462     }
 463
 464     if ( xDispatch.is() )
 465     {
 466         // Call dispatch asychronously as we can be destroyed while dispatch is
 467         // executed. VCL is not able to survive this as it wants to call listeners
 468         // after select!!!
 469         NewDocument* pNewDocument = new NewDocument;
 470         pNewDocument->xDispatch  = xDispatch;
 471         pNewDocument->aTargetURL = aTargetURL;
 472         pNewDocument->aArgSeq    = aArgsList;
 473         if(::comphelper::UiEventsLogger::isEnabled()) //#i88653#
 474             UiEventLogHelper(::rtl::OUString::createFromAscii("NewMenuController")).log(m_xServiceManager, m_xFrame, aTargetURL, aArgsList);
 475         Application::PostUserEvent( STATIC_LINK(0, NewMenuController, ExecuteHdl_Impl), pNewDocument );
 476     }
 477 }
 478
 479 void SAL_CALL NewMenuController::activate( const css::awt::MenuEvent& ) throw (RuntimeException)
 480 {
 481     vos::OGuard aSolarMutexGuard( Application::GetSolarMutex() );
 482     if ( m_xFrame.is() && m_xPopupMenu.is() )
 483     {
 484         VCLXPopupMenu* pPopupMenu = (VCLXPopupMenu *)VCLXPopupMenu::GetImplementation( m_xPopupMenu );
 485         if ( pPopupMenu )
 486         {
 487             const StyleSettings& rSettings = Application::GetSettings().GetStyleSettings();
 488             sal_Bool bShowImages( rSettings.GetUseImagesInMenus() );
 489             sal_Bool bHiContrast( rSettings.GetHighContrastMode() );
 490
 491             PopupMenu* pVCLPopupMenu = (PopupMenu *)pPopupMenu->GetMenu();
 492
 493             if (( m_bShowImages != bShowImages ) ||
 494                 ( m_bHiContrast != bHiContrast ))
 495             {
 496                 m_bShowImages = bShowImages;
 497                 m_bHiContrast = bHiContrast;
 498
 499                 setMenuImages( pVCLPopupMenu, m_bShowImages, m_bHiContrast );
 500             }
 501
 502             setAccelerators( pVCLPopupMenu );
 503         }
 504     }
 505 }
 506
 507 // XPopupMenuController
 508 void NewMenuController::impl_setPopupMenu()
 509 {
 510
 511     if ( m_xPopupMenu.is() )
 512         fillPopupMenu( m_xPopupMenu );
 513
 514     // Identify module that we are attach to. It's our context that we need to know.
 515     Reference< XModuleManager > xModuleManager( m_xServiceManager->createInstance( SERVICENAME_MODULEMANAGER ),UNO_QUERY );
 516     if ( xModuleManager.is() )
 517     {
 518         try
 519         {
 520             m_aModuleIdentifier = xModuleManager->identify( m_xFrame );
 521             m_bModuleIdentified = sal_True;
 522
 523             Reference< XNameAccess > xNameAccess( xModuleManager, UNO_QUERY );
 524             if (( m_aModuleIdentifier.getLength() > 0 ) && xNameAccess.is() )
 525             {
 526                 Sequence< PropertyValue > aSeq;
 527
 528                 if ( xNameAccess->getByName( m_aModuleIdentifier ) >>= aSeq )
 529                 {
 530                     for ( sal_Int32 y = 0; y < aSeq.getLength(); y++ )
 531                     {
 532                         if ( aSeq[y].Name.equalsAscii("ooSetupFactoryEmptyDocumentURL") )
 533                         {
 534                             aSeq[y].Value >>= m_aEmptyDocURL;
 535                             break;
 536                         }
 537                     }
 538                 }
 539             }
 540         }
 541         catch ( RuntimeException& e )
 542         {
 543             throw e;
 544         }
 545         catch ( Exception& )
 546         {
 547         }
 548     }
 549 }
 550
 551 // XInitialization
 552 void SAL_CALL NewMenuController::initialize( const Sequence< Any >& aArguments ) throw ( Exception, RuntimeException )
 553 {
 554     ResetableGuard aLock( m_aLock );
 555
 556     sal_Bool bInitalized( m_bInitialized );
 557     if ( !bInitalized )
 558     {
 559         PopupMenuControllerBase::initialize( aArguments );
 560
 561         if ( m_bInitialized )
 562         {
 563             const StyleSettings& rSettings = Application::GetSettings().GetStyleSettings();
 564
 565             m_bShowImages   = rSettings.GetUseImagesInMenus();
 566             m_bHiContrast   = rSettings.GetHighContrastMode();
 567
 568             m_bNewMenu      = m_aCommandURL.equalsAscii( ".uno:AddDirect" );
 569         }
 570     }
 571 }
 572
 573 IMPL_STATIC_LINK_NOINSTANCE( NewMenuController, ExecuteHdl_Impl, NewDocument*, pNewDocument )
 574 {
 575 /*  i62706: Don't catch all exceptions. We hide all problems here and are not able
 576             to handle them on higher levels.
 577     try
 578     {
 579 */
 580         // Asynchronous execution as this can lead to our own destruction!
 581         // Framework can recycle our current frame and the layout manager disposes all user interface
 582         // elements if a component gets detached from its frame!
 583         pNewDocument->xDispatch->dispatch( pNewDocument->aTargetURL, pNewDocument->aArgSeq );
 584 /*
 585     }
 586     catch (const ::com::sun::star::document::CorruptedFilterConfigurationException& exFilters)
 587     {
 588         throw exFilters;
 589     }
 590     catch (const Exception& )
 591     {
 592     }
 593 */
 594     delete pNewDocument;
 595     return 0;
 596 }
 597
 598 }