1 /************************************************************** 2 * 3 * Licensed to the Apache Software Foundation (ASF) under one 4 * or more contributor license agreements. See the NOTICE file 5 * distributed with this work for additional information 6 * regarding copyright ownership. The ASF licenses this file 7 * to you under the Apache License, Version 2.0 (the 8 * "License"); you may not use this file except in compliance 9 * with the License. You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, 14 * software distributed under the License is distributed on an 15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 16 * KIND, either express or implied. See the License for the 17 * specific language governing permissions and limitations 18 * under the License. 19 * 20 *************************************************************/ 21 22 23 24 // MARKER(update_precomp.py): autogen include statement, do not remove 25 #include "precompiled_framework.hxx" 26 #include <uielement/toolbarmanager.hxx> 27 28 //_________________________________________________________________________________________________________________ 29 // my own includes 30 //_________________________________________________________________________________________________________________ 31 32 33 #ifndef __FRAMEWORK_UIELEMENT_TOOLBAR_HXX 34 #include <uielement/toolbar.hxx> 35 #endif 36 #ifndef __FRAMEWORK_UIELEMENT_GENERICTOOLBARCONTROLLER_HXX 37 #include <uielement/generictoolbarcontroller.hxx> 38 #endif 39 #include <threadhelp/resetableguard.hxx> 40 #include "services.h" 41 #include "general.h" 42 #include "properties.h" 43 #include <framework/imageproducer.hxx> 44 #include <framework/sfxhelperfunctions.hxx> 45 #include <classes/fwkresid.hxx> 46 #ifndef __FRAMEWORK_CLASES_RESOURCE_HRC_ 47 #include <classes/resource.hrc> 48 #endif 49 #include <framework/addonsoptions.hxx> 50 #include <uielement/toolbarmerger.hxx> 51 #include <framework/acceleratorinfo.hxx> 52 53 //_________________________________________________________________________________________________________________ 54 // interface includes 55 //_________________________________________________________________________________________________________________ 56 #include <com/sun/star/ui/ItemType.hpp> 57 #include <com/sun/star/frame/XDispatchProvider.hpp> 58 #include <com/sun/star/beans/XPropertySet.hpp> 59 #include <com/sun/star/awt/XDockableWindow.hpp> 60 #include <com/sun/star/frame/XLayoutManager.hpp> 61 #ifndef _COM_SUN_STAR_UI_XDOCKINGAREA_HPP_ 62 #include <com/sun/star/ui/DockingArea.hpp> 63 #endif 64 #include <com/sun/star/graphic/XGraphic.hpp> 65 #include <com/sun/star/lang/XMultiComponentFactory.hpp> 66 #include <com/sun/star/frame/XModuleManager.hpp> 67 #include <com/sun/star/frame/ToolbarControllerFactory.hpp> 68 #include <com/sun/star/ui/XUIElementSettings.hpp> 69 #include <com/sun/star/ui/XUIConfigurationPersistence.hpp> 70 #include <com/sun/star/ui/XModuleUIConfigurationManagerSupplier.hpp> 71 #include <com/sun/star/ui/XUIConfigurationManagerSupplier.hpp> 72 #include <com/sun/star/ui/ImageType.hpp> 73 #include <com/sun/star/ui/UIElementType.hpp> 74 #include <comphelper/sequence.hxx> 75 #include <com/sun/star/frame/status/Visibility.hpp> 76 #include <com/sun/star/lang/DisposedException.hpp> 77 78 //_________________________________________________________________________________________________________________ 79 // other includes 80 //_________________________________________________________________________________________________________________ 81 #include <svtools/imgdef.hxx> 82 #include <svtools/toolboxcontroller.hxx> 83 #include <unotools/cmdoptions.hxx> 84 #ifndef _TOOLKIT_HELPER_VCLUNOHELPER_HXX_ 85 #include <toolkit/helper/vclunohelper.hxx> 86 #endif 87 #include <comphelper/mediadescriptor.hxx> 88 #include <comphelper/processfactory.hxx> 89 #include <svtools/miscopt.hxx> 90 #include <svl/imageitm.hxx> 91 #include <svtools/framestatuslistener.hxx> 92 #include <vcl/svapp.hxx> 93 #include <vcl/menu.hxx> 94 #include <vcl/syswin.hxx> 95 #include <vcl/taskpanelist.hxx> 96 #include <rtl/logfile.hxx> 97 #include <svtools/menuoptions.hxx> 98 #include <unotools/cmdoptions.hxx> 99 #include <boost/bind.hpp> 100 #include <svtools/acceleratorexecute.hxx> 101 102 //_________________________________________________________________________________________________________________ 103 // namespaces 104 //_________________________________________________________________________________________________________________ 105 106 using rtl::OUString; 107 108 using namespace ::com::sun::star::awt; 109 using namespace ::com::sun::star::beans; 110 using namespace ::com::sun::star::uno; 111 using namespace ::com::sun::star::lang; 112 using namespace ::com::sun::star::frame; 113 using namespace ::com::sun::star::graphic; 114 using namespace ::com::sun::star::util; 115 using namespace ::com::sun::star::container; 116 using namespace ::com::sun::star::frame; 117 using namespace ::com::sun::star::ui; 118 using namespace ::com::sun::star; 119 120 namespace framework 121 { 122 123 static const char ITEM_DESCRIPTOR_COMMANDURL[] = "CommandURL"; 124 static const char ITEM_DESCRIPTOR_HELPURL[] = "HelpURL"; 125 static const char ITEM_DESCRIPTOR_TOOLTIP[] = "Tooltip"; 126 static const char ITEM_DESCRIPTOR_CONTAINER[] = "ItemDescriptorContainer"; 127 static const char ITEM_DESCRIPTOR_LABEL[] = "Label"; 128 static const char ITEM_DESCRIPTOR_TYPE[] = "Type"; 129 static const char ITEM_DESCRIPTOR_VISIBLE[] = "IsVisible"; 130 static const char ITEM_DESCRIPTOR_WIDTH[] = "Width"; 131 static const char ITEM_DESCRIPTOR_STYLE[] = "Style"; 132 133 static const sal_Int32 ITEM_DESCRIPTOR_COMMANDURL_LEN = 10; 134 static const sal_Int32 ITEM_DESCRIPTOR_HELPURL_LEN = 7; 135 static const sal_Int32 ITEM_DESCRIPTOR_TOOLTIP_LEN = 7; 136 static const sal_Int32 ITEM_DESCRIPTOR_CONTAINER_LEN = 23; 137 static const sal_Int32 ITEM_DESCRIPTOR_LABEL_LEN = 5; 138 static const sal_Int32 ITEM_DESCRIPTOR_TYPE_LEN = 4; 139 static const sal_Int32 ITEM_DESCRIPTOR_VISIBLE_LEN = 9; 140 static const sal_Int32 ITEM_DESCRIPTOR_WIDTH_LEN = 5; 141 static const sal_Int32 ITEM_DESCRIPTOR_STYLE_LEN = 5; 142 143 static const char HELPID_PREFIX[] = "helpid:"; 144 static const char HELPID_PREFIX_TESTTOOL[] = ".HelpId:"; 145 //static sal_Int32 HELPID_PREFIX_LENGTH = 7; 146 static const sal_uInt16 STARTID_CUSTOMIZE_POPUPMENU = 1000; 147 148 #define MENUPREFIX "private:resource/menubar/" 149 150 class ImageOrientationListener : public svt::FrameStatusListener 151 { 152 public: 153 ImageOrientationListener( const Reference< XStatusListener > rReceiver, 154 const Reference< XMultiServiceFactory > rServiceManager, 155 const Reference< XFrame > rFrame ); 156 virtual ~ImageOrientationListener(); 157 158 virtual void SAL_CALL statusChanged( const ::com::sun::star::frame::FeatureStateEvent& Event ) throw ( ::com::sun::star::uno::RuntimeException ); 159 160 private: 161 Reference< XStatusListener > m_xReceiver; 162 }; 163 164 ImageOrientationListener::ImageOrientationListener( 165 const Reference< XStatusListener > rReceiver, 166 const Reference< XMultiServiceFactory > rServiceManager, 167 const Reference< XFrame > rFrame ) : 168 FrameStatusListener( rServiceManager, rFrame ), 169 m_xReceiver( rReceiver ) 170 { 171 } 172 173 ImageOrientationListener::~ImageOrientationListener() 174 { 175 } 176 177 void SAL_CALL ImageOrientationListener::statusChanged( const FeatureStateEvent& Event ) 178 throw ( RuntimeException ) 179 { 180 if ( m_xReceiver.is() ) 181 m_xReceiver->statusChanged( Event ); 182 } 183 184 //***************************************************************************************************************** 185 186 static sal_Int16 getImageTypeFromBools( sal_Bool bBig, sal_Bool bHighContrast ) 187 { 188 sal_Int16 n( 0 ); 189 if ( bBig ) 190 n |= ::com::sun::star::ui::ImageType::SIZE_LARGE; 191 if ( bHighContrast ) 192 n |= ::com::sun::star::ui::ImageType::COLOR_HIGHCONTRAST; 193 return n; 194 } 195 196 static ::com::sun::star::uno::Reference< ::com::sun::star::frame::XLayoutManager > getLayoutManagerFromFrame( 197 ::com::sun::star::uno::Reference< ::com::sun::star::frame::XFrame >& rFrame ) 198 { 199 ::com::sun::star::uno::Reference< ::com::sun::star::frame::XLayoutManager > xLayoutManager; 200 201 Reference< XPropertySet > xPropSet( rFrame, UNO_QUERY ); 202 if ( xPropSet.is() ) 203 { 204 try 205 { 206 xPropSet->getPropertyValue( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "LayoutManager" ))) >>= xLayoutManager; 207 } 208 catch ( RuntimeException& ) 209 { 210 throw; 211 } 212 catch ( Exception& ) 213 { 214 } 215 } 216 217 return xLayoutManager; 218 } 219 220 //***************************************************************************************************************** 221 // XInterface, XTypeProvider, XServiceInfo 222 //***************************************************************************************************************** 223 DEFINE_XINTERFACE_6 ( ToolBarManager , 224 OWeakObject , 225 DIRECT_INTERFACE( ::com::sun::star::lang::XTypeProvider ), 226 DIRECT_INTERFACE( ::com::sun::star::lang::XComponent ), 227 DIRECT_INTERFACE( ::com::sun::star::frame::XFrameActionListener ), 228 DIRECT_INTERFACE( ::com::sun::star::ui::XUIConfigurationListener ), 229 DIRECT_INTERFACE( ::com::sun::star::frame::XStatusListener ), 230 DERIVED_INTERFACE( ::com::sun::star::lang::XEventListener, ::com::sun::star::frame::XFrameActionListener ) 231 ) 232 233 DEFINE_XTYPEPROVIDER_6 ( ToolBarManager , 234 ::com::sun::star::lang::XTypeProvider , 235 ::com::sun::star::lang::XComponent , 236 ::com::sun::star::ui::XUIConfigurationListener , 237 ::com::sun::star::frame::XFrameActionListener , 238 ::com::sun::star::frame::XStatusListener , 239 ::com::sun::star::lang::XEventListener 240 ) 241 242 ToolBarManager::ToolBarManager( const Reference< XMultiServiceFactory >& rServiceManager, 243 const Reference< XFrame >& rFrame, 244 const rtl::OUString& rResourceName, 245 ToolBar* pToolBar ) : 246 ThreadHelpBase( &Application::GetSolarMutex() ), 247 OWeakObject(), 248 m_bDisposed( sal_False ), 249 m_bIsHiContrast( pToolBar->GetSettings().GetStyleSettings().GetHighContrastMode() ), 250 m_bSmallSymbols( !SvtMiscOptions().AreCurrentSymbolsLarge() ), 251 m_bModuleIdentified( sal_False ), 252 m_bAddedToTaskPaneList( sal_True ), 253 m_bFrameActionRegistered( sal_False ), 254 m_bUpdateControllers( sal_False ), 255 m_bImageOrientationRegistered( sal_False ), 256 m_bImageMirrored( sal_False ), 257 m_bCanBeCustomized( sal_True ), 258 m_lImageRotation( 0 ), 259 m_pToolBar( pToolBar ), 260 m_aResourceName( rResourceName ), 261 m_xFrame( rFrame ), 262 m_aListenerContainer( m_aLock.getShareableOslMutex() ), 263 m_xServiceManager( rServiceManager ), 264 m_nSymbolsStyle( SvtMiscOptions().GetCurrentSymbolsStyle() ), 265 m_bAcceleratorCfg( sal_False ) 266 { 267 Window* pWindow = m_pToolBar; 268 while ( pWindow && !pWindow->IsSystemWindow() ) 269 pWindow = pWindow->GetParent(); 270 271 if ( pWindow ) 272 ((SystemWindow *)pWindow)->GetTaskPaneList()->AddWindow( m_pToolBar ); 273 274 Reference< XComponentContext > xContext(::comphelper::getProcessComponentContext()); 275 if ( xContext.is() ) 276 { 277 m_xToolbarControllerFactory = frame::ToolbarControllerFactory::create( xContext ); 278 279 m_xURLTransformer.set( xContext->getServiceManager()->createInstanceWithContext( 280 SERVICENAME_URLTRANSFORMER, xContext), UNO_QUERY ); 281 } 282 283 m_pToolBar->SetSelectHdl( LINK( this, ToolBarManager, Select) ); 284 m_pToolBar->SetActivateHdl( LINK( this, ToolBarManager, Activate) ); 285 m_pToolBar->SetDeactivateHdl( LINK( this, ToolBarManager, Deactivate) ); 286 m_pToolBar->SetClickHdl( LINK( this, ToolBarManager, Click ) ); 287 m_pToolBar->SetDropdownClickHdl( LINK( this, ToolBarManager, DropdownClick ) ); 288 m_pToolBar->SetDoubleClickHdl( LINK( this, ToolBarManager, DoubleClick ) ); 289 m_pToolBar->SetStateChangedHdl( LINK( this, ToolBarManager, StateChanged ) ); 290 m_pToolBar->SetDataChangedHdl( LINK( this, ToolBarManager, DataChanged ) ); 291 m_pToolBar->SetToolboxButtonSize( m_bSmallSymbols ? TOOLBOX_BUTTONSIZE_SMALL : TOOLBOX_BUTTONSIZE_LARGE ); 292 293 // enables a menu for clipped items and customization 294 SvtCommandOptions aCmdOptions; 295 sal_uInt16 nMenuType = TOOLBOX_MENUTYPE_CLIPPEDITEMS; 296 if ( !aCmdOptions.Lookup( SvtCommandOptions::CMDOPTION_DISABLED, ::rtl::OUString::createFromAscii( "CreateDialog" ))) 297 nMenuType |= TOOLBOX_MENUTYPE_CUSTOMIZE; 298 //added for issue33668 by shizhoubo 299 m_pToolBar->SetCommandHdl( LINK( this, ToolBarManager, Command ) ); 300 //end 301 m_pToolBar->SetMenuType( nMenuType ); 302 m_pToolBar->SetMenuButtonHdl( LINK( this, ToolBarManager, MenuButton ) ); 303 m_pToolBar->GetMenu()->SetSelectHdl( LINK( this, ToolBarManager, MenuSelect ) ); 304 m_pToolBar->GetMenu()->SetDeactivateHdl( LINK( this, ToolBarManager, MenuDeactivate ) ); 305 306 // set name for testtool, the useful part is after the last '/' 307 sal_Int32 idx = rResourceName.lastIndexOf('/'); 308 idx++; // will become 0 if '/' not found: use full string 309 ::rtl::OString aHelpIdAsString( HELPID_PREFIX_TESTTOOL ); 310 ::rtl::OUString aToolbarName = rResourceName.copy( idx ); 311 aHelpIdAsString += rtl::OUStringToOString( aToolbarName, RTL_TEXTENCODING_UTF8 );; 312 m_pToolBar->SetHelpId( aHelpIdAsString ); 313 314 m_aAsyncUpdateControllersTimer.SetTimeout( 50 ); 315 m_aAsyncUpdateControllersTimer.SetTimeoutHdl( LINK( this, ToolBarManager, AsyncUpdateControllersHdl ) ); 316 } 317 318 ToolBarManager::~ToolBarManager() 319 { 320 OSL_ASSERT( m_pToolBar == 0 ); 321 OSL_ASSERT( !m_bAddedToTaskPaneList ); 322 } 323 324 void ToolBarManager::Destroy() 325 { 326 ResetableGuard aGuard( m_aLock ); 327 if ( m_bAddedToTaskPaneList ) 328 { 329 Window* pWindow = m_pToolBar; 330 while ( pWindow && !pWindow->IsSystemWindow() ) 331 pWindow = pWindow->GetParent(); 332 333 if ( pWindow ) 334 ((SystemWindow *)pWindow)->GetTaskPaneList()->RemoveWindow( m_pToolBar ); 335 m_bAddedToTaskPaneList = sal_False; 336 } 337 338 // Delete the additional add-ons data 339 for ( sal_uInt16 i = 0; i < m_pToolBar->GetItemCount(); i++ ) 340 { 341 sal_uInt16 nItemId = m_pToolBar->GetItemId( i ); 342 if ( nItemId > 0 ) 343 delete static_cast< AddonsParams* >( m_pToolBar->GetItemData( nItemId )); 344 } 345 346 // Hide toolbar as lazy delete can destroy the toolbar much later. 347 m_pToolBar->Hide(); 348 /* #i99167# removed change for i93173 since there is some weird crash */ 349 // #i93173# delete toolbar lazily as we can still be in one of its handlers 350 m_pToolBar->doLazyDelete(); 351 352 Link aEmpty; 353 m_pToolBar->SetSelectHdl( aEmpty ); 354 m_pToolBar->SetActivateHdl( aEmpty ); 355 m_pToolBar->SetDeactivateHdl( aEmpty ); 356 m_pToolBar->SetClickHdl( aEmpty ); 357 m_pToolBar->SetDropdownClickHdl( aEmpty ); 358 m_pToolBar->SetDoubleClickHdl( aEmpty ); 359 m_pToolBar->SetStateChangedHdl( aEmpty ); 360 m_pToolBar->SetDataChangedHdl( aEmpty ); 361 362 // delete m_pToolBar; 363 m_pToolBar = 0; 364 } 365 366 ToolBox* ToolBarManager::GetToolBar() const 367 { 368 ResetableGuard aGuard( m_aLock ); 369 return m_pToolBar; 370 } 371 372 void ToolBarManager::CheckAndUpdateImages() 373 { 374 ResetableGuard aGuard( m_aLock ); 375 sal_Bool bRefreshImages = sal_False; 376 377 // Check if high contrast/normal mode have changed 378 if ( m_pToolBar->GetSettings().GetStyleSettings().GetHighContrastMode() ) 379 { 380 if ( !m_bIsHiContrast ) 381 { 382 bRefreshImages = sal_True; 383 m_bIsHiContrast = sal_True; 384 } 385 } 386 else if ( m_bIsHiContrast ) 387 { 388 bRefreshImages = sal_True; 389 m_bIsHiContrast = sal_False; 390 } 391 392 SvtMiscOptions aMiscOptions; 393 bool bCurrentSymbolsSmall = !aMiscOptions.AreCurrentSymbolsLarge(); 394 if ( m_bSmallSymbols != bCurrentSymbolsSmall ) 395 { 396 bRefreshImages = sal_True; 397 m_bSmallSymbols = bCurrentSymbolsSmall; 398 } 399 400 sal_Int16 nCurrentSymbolsStyle = aMiscOptions.GetCurrentSymbolsStyle(); 401 if ( m_nSymbolsStyle != nCurrentSymbolsStyle ) 402 { 403 bRefreshImages = sal_True; 404 m_nSymbolsStyle = nCurrentSymbolsStyle; 405 } 406 407 // Refresh images if requested 408 if ( bRefreshImages ) 409 RefreshImages(); 410 } 411 412 void ToolBarManager::RefreshImages() 413 { 414 ResetableGuard aGuard( m_aLock ); 415 416 sal_Bool bBigImages( SvtMiscOptions().AreCurrentSymbolsLarge() ); 417 for ( sal_uInt16 nPos = 0; nPos < m_pToolBar->GetItemCount(); nPos++ ) 418 { 419 sal_uInt16 nId( m_pToolBar->GetItemId( nPos ) ); 420 421 if ( nId > 0 ) 422 { 423 ::rtl::OUString aCommandURL = m_pToolBar->GetItemCommand( nId ); 424 Image aImage = GetImageFromURL( m_xFrame, aCommandURL, bBigImages, m_bIsHiContrast ); 425 // Try also to query for add-on images before giving up and use an 426 // empty image. 427 if ( !aImage ) 428 aImage = QueryAddonsImage( aCommandURL, bBigImages, m_bIsHiContrast ); 429 m_pToolBar->SetItemImage( nId, aImage ); 430 } 431 } 432 433 m_pToolBar->SetToolboxButtonSize( bBigImages ? TOOLBOX_BUTTONSIZE_LARGE : TOOLBOX_BUTTONSIZE_SMALL ); 434 ::Size aSize = m_pToolBar->CalcWindowSizePixel(); 435 m_pToolBar->SetOutputSizePixel( aSize ); 436 } 437 438 void ToolBarManager::UpdateImageOrientation() 439 { 440 ResetableGuard aGuard( m_aLock ); 441 442 if ( m_xUICommandLabels.is() ) 443 { 444 sal_Int32 i; 445 Sequence< rtl::OUString > aSeqMirrorCmd; 446 Sequence< rtl::OUString > aSeqRotateCmd; 447 m_xUICommandLabels->getByName( 448 rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( UICOMMANDDESCRIPTION_NAMEACCESS_COMMANDMIRRORIMAGELIST ))) >>= aSeqMirrorCmd; 449 m_xUICommandLabels->getByName( 450 rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( UICOMMANDDESCRIPTION_NAMEACCESS_COMMANDROTATEIMAGELIST ))) >>= aSeqRotateCmd; 451 452 CommandToInfoMap::iterator pIter; 453 for ( i = 0; i < aSeqMirrorCmd.getLength(); i++ ) 454 { 455 rtl::OUString aMirrorCmd = aSeqMirrorCmd[i]; 456 pIter = m_aCommandMap.find( aMirrorCmd ); 457 if ( pIter != m_aCommandMap.end() ) 458 pIter->second.bMirrored = sal_True; 459 } 460 for ( i = 0; i < aSeqRotateCmd.getLength(); i++ ) 461 { 462 rtl::OUString aRotateCmd = aSeqRotateCmd[i]; 463 pIter = m_aCommandMap.find( aRotateCmd ); 464 if ( pIter != m_aCommandMap.end() ) 465 pIter->second.bRotated = sal_True; 466 } 467 } 468 469 for ( sal_uInt16 nPos = 0; nPos < m_pToolBar->GetItemCount(); nPos++ ) 470 { 471 sal_uInt16 nId = m_pToolBar->GetItemId( nPos ); 472 if ( nId > 0 ) 473 { 474 rtl::OUString aCmd = m_pToolBar->GetItemCommand( nId ); 475 476 CommandToInfoMap::const_iterator pIter = m_aCommandMap.find( aCmd ); 477 if ( pIter != m_aCommandMap.end() ) 478 { 479 if ( pIter->second.bRotated ) 480 { 481 m_pToolBar->SetItemImageMirrorMode( nId, sal_False ); 482 m_pToolBar->SetItemImageAngle( nId, m_lImageRotation ); 483 } 484 if ( pIter->second.bMirrored ) 485 m_pToolBar->SetItemImageMirrorMode( nId, m_bImageMirrored ); 486 } 487 } 488 } 489 } 490 491 void ToolBarManager::UpdateControllers() 492 { 493 RTL_LOGFILE_CONTEXT( aLog, "framework (cd100003) ::ToolBarManager::UpdateControllers" ); 494 495 if ( !m_bUpdateControllers ) 496 { 497 m_bUpdateControllers = sal_True; 498 ToolBarControllerMap::iterator pIter = m_aControllerMap.begin(); 499 500 while ( pIter != m_aControllerMap.end() ) 501 { 502 try 503 { 504 Reference< XUpdatable > xUpdatable( pIter->second, UNO_QUERY ); 505 if ( xUpdatable.is() ) 506 xUpdatable->update(); 507 } 508 catch ( Exception& ) 509 { 510 } 511 ++pIter; 512 } 513 } 514 m_bUpdateControllers = sal_False; 515 } 516 //for update toolbar controller via Support Visible by shizhoubo 517 void ToolBarManager::UpdateController( ::com::sun::star::uno::Reference< ::com::sun::star::frame::XToolbarController > xController) 518 { 519 RTL_LOGFILE_CONTEXT( aLog, "framework (cd100003) ::ToolBarManager::UpdateControllers" ); 520 521 if ( !m_bUpdateControllers ) 522 { 523 m_bUpdateControllers = sal_True; 524 try 525 { if(xController.is()) 526 { 527 Reference< XUpdatable > xUpdatable( xController, UNO_QUERY ); 528 if ( xUpdatable.is() ) 529 xUpdatable->update(); 530 } 531 } 532 catch ( Exception& ) 533 { 534 } 535 536 /* m_bUpdateControllers = sal_True; 537 ToolBarControllerMap::iterator pIter = m_aControllerMap.begin(); 538 539 while ( pIter != m_aControllerMap.end() ) 540 { 541 try 542 { 543 Reference< XUpdatable > xUpdatable( pIter->second, UNO_QUERY ); 544 if ( xUpdatable.is() ) 545 xUpdatable->update(); 546 } 547 catch ( Exception& ) 548 { 549 } 550 ++pIter; 551 }*/ 552 553 } 554 m_bUpdateControllers = sal_False; 555 } 556 //end 557 void ToolBarManager::frameAction( const FrameActionEvent& Action ) 558 throw ( RuntimeException ) 559 { 560 ResetableGuard aGuard( m_aLock ); 561 if ( Action.Action == FrameAction_CONTEXT_CHANGED ) 562 m_aAsyncUpdateControllersTimer.Start(); 563 } 564 565 void SAL_CALL ToolBarManager::statusChanged( const ::com::sun::star::frame::FeatureStateEvent& Event ) 566 throw ( ::com::sun::star::uno::RuntimeException ) 567 { 568 ResetableGuard aGuard( m_aLock ); 569 if ( m_bDisposed ) 570 return; 571 572 if ( Event.FeatureURL.Complete.equalsAscii( ".uno:ImageOrientation" )) 573 { 574 SfxImageItem aItem( 1, 0 ); 575 aItem.PutValue( Event.State ); 576 577 m_lImageRotation = aItem.GetRotation(); 578 m_bImageMirrored = aItem.IsMirrored(); 579 UpdateImageOrientation(); 580 } 581 } 582 583 void SAL_CALL ToolBarManager::disposing( const EventObject& Source ) throw ( RuntimeException ) 584 { 585 { 586 ResetableGuard aGuard( m_aLock ); 587 if ( m_bDisposed ) 588 return; 589 } 590 591 RemoveControllers(); 592 593 { 594 ResetableGuard aGuard( m_aLock ); 595 if ( m_xDocImageManager.is() ) 596 { 597 try 598 { 599 m_xDocImageManager->removeConfigurationListener( 600 Reference< XUIConfigurationListener >( 601 static_cast< OWeakObject* >( this ), UNO_QUERY )); 602 } 603 catch ( Exception& ) 604 { 605 } 606 } 607 608 if ( m_xModuleImageManager.is() ) 609 { 610 try 611 { 612 m_xModuleImageManager->removeConfigurationListener( 613 Reference< XUIConfigurationListener >( 614 static_cast< OWeakObject* >( this ), UNO_QUERY )); 615 } 616 catch ( Exception& ) 617 { 618 } 619 } 620 621 if ( m_xImageOrientationListener.is() ) 622 { 623 ImageOrientationListener* pImageOrientation = 624 (ImageOrientationListener*)m_xImageOrientationListener.get(); 625 pImageOrientation->unbindListener(); 626 m_xImageOrientationListener.clear(); 627 } 628 629 m_xDocImageManager.clear(); 630 m_xModuleImageManager.clear(); 631 632 if ( Source.Source == Reference< XInterface >( m_xFrame, UNO_QUERY )) 633 m_xFrame.clear(); 634 635 m_xServiceManager.clear(); 636 } 637 } 638 639 // XComponent 640 void SAL_CALL ToolBarManager::dispose() throw( RuntimeException ) 641 { 642 Reference< XComponent > xThis( static_cast< OWeakObject* >(this), UNO_QUERY ); 643 644 EventObject aEvent( xThis ); 645 m_aListenerContainer.disposeAndClear( aEvent ); 646 647 { 648 ResetableGuard aGuard( m_aLock ); 649 650 // stop timer to prevent timer events after dispose 651 m_aAsyncUpdateControllersTimer.Stop(); 652 653 RemoveControllers(); 654 655 if ( m_xDocImageManager.is() ) 656 { 657 try 658 { 659 m_xDocImageManager->removeConfigurationListener( 660 Reference< XUIConfigurationListener >( 661 static_cast< OWeakObject* >( this ), UNO_QUERY )); 662 } 663 catch ( Exception& ) 664 { 665 } 666 } 667 m_xDocImageManager.clear(); 668 if ( m_xModuleImageManager.is() ) 669 { 670 try 671 { 672 m_xModuleImageManager->removeConfigurationListener( 673 Reference< XUIConfigurationListener >( 674 static_cast< OWeakObject* >( this ), UNO_QUERY )); 675 } 676 catch ( Exception& ) 677 { 678 } 679 } 680 m_xModuleImageManager.clear(); 681 682 ImplClearPopupMenu( m_pToolBar ); 683 684 // We have to destroy our toolbar instance now. 685 Destroy(); 686 687 if ( m_bFrameActionRegistered && m_xFrame.is() ) 688 { 689 try 690 { 691 m_xFrame->removeFrameActionListener( Reference< XFrameActionListener >( 692 static_cast< ::cppu::OWeakObject *>( this ), UNO_QUERY )); 693 } 694 catch ( Exception& ) 695 { 696 } 697 } 698 699 if ( m_xImageOrientationListener.is() ) 700 { 701 ImageOrientationListener* pImageOrientation = 702 (ImageOrientationListener*)m_xImageOrientationListener.get(); 703 pImageOrientation->unbindListener(); 704 m_xImageOrientationListener.clear(); 705 } 706 707 m_xFrame.clear(); 708 m_xServiceManager.clear(); 709 Reference< XComponent > xCompGAM( m_xGlobalAcceleratorManager, UNO_QUERY ); 710 if ( xCompGAM.is() ) 711 xCompGAM->dispose(); 712 m_xGlobalAcceleratorManager.clear(); 713 m_xModuleAcceleratorManager.clear(); 714 m_xDocAcceleratorManager.clear(); 715 716 m_bDisposed = sal_True; 717 } 718 } 719 720 void SAL_CALL ToolBarManager::addEventListener( const Reference< XEventListener >& xListener ) throw( RuntimeException ) 721 { 722 ResetableGuard aGuard( m_aLock ); 723 724 /* SAFE AREA ----------------------------------------------------------------------------------------------- */ 725 if ( m_bDisposed ) 726 throw DisposedException(); 727 728 m_aListenerContainer.addInterface( ::getCppuType( ( const Reference< XEventListener >* ) NULL ), xListener ); 729 } 730 731 void SAL_CALL ToolBarManager::removeEventListener( const Reference< XEventListener >& xListener ) throw( RuntimeException ) 732 { 733 m_aListenerContainer.removeInterface( ::getCppuType( ( const Reference< XEventListener >* ) NULL ), xListener ); 734 } 735 736 // XUIConfigurationListener 737 void SAL_CALL ToolBarManager::elementInserted( const ::com::sun::star::ui::ConfigurationEvent& Event ) throw (::com::sun::star::uno::RuntimeException) 738 { 739 impl_elementChanged(false,Event); 740 } 741 742 void SAL_CALL ToolBarManager::elementRemoved( const ::com::sun::star::ui::ConfigurationEvent& Event ) throw (::com::sun::star::uno::RuntimeException) 743 { 744 impl_elementChanged(true,Event); 745 } 746 void ToolBarManager::impl_elementChanged(bool _bRemove,const ::com::sun::star::ui::ConfigurationEvent& Event ) 747 { 748 ResetableGuard aGuard( m_aLock ); 749 750 /* SAFE AREA ----------------------------------------------------------------------------------------------- */ 751 if ( m_bDisposed ) 752 return; 753 754 Reference< XNameAccess > xNameAccess; 755 sal_Int16 nImageType = sal_Int16(); 756 sal_Int16 nCurrentImageType = getImageTypeFromBools( 757 SvtMiscOptions().AreCurrentSymbolsLarge(), 758 m_bIsHiContrast ); 759 760 if (( Event.aInfo >>= nImageType ) && 761 ( nImageType == nCurrentImageType ) && 762 ( Event.Element >>= xNameAccess )) 763 { 764 sal_Int16 nImageInfo( 1 ); 765 Reference< XInterface > xIfacDocImgMgr( m_xDocImageManager, UNO_QUERY ); 766 if ( xIfacDocImgMgr == Event.Source ) 767 nImageInfo = 0; 768 769 Sequence< rtl::OUString > aSeq = xNameAccess->getElementNames(); 770 for ( sal_Int32 i = 0; i < aSeq.getLength(); i++ ) 771 { 772 CommandToInfoMap::iterator pIter = m_aCommandMap.find( aSeq[i] ); 773 if ( pIter != m_aCommandMap.end() && ( pIter->second.nImageInfo >= nImageInfo )) 774 { 775 if ( _bRemove ) 776 { 777 Image aImage; 778 if (( pIter->second.nImageInfo == 0 ) && ( pIter->second.nImageInfo == nImageInfo )) 779 { 780 // Special case: An image from the document image manager has been removed. 781 // It is possible that we have a image at our module image manager. Before 782 // we can remove our image we have to ask our module image manager. 783 Sequence< rtl::OUString > aCmdURLSeq( 1 ); 784 Sequence< Reference< XGraphic > > aGraphicSeq; 785 aCmdURLSeq[0] = pIter->first; 786 aGraphicSeq = m_xModuleImageManager->getImages( nImageType, aCmdURLSeq ); 787 aImage = Image( aGraphicSeq[0] ); 788 } 789 790 setToolBarImage(aImage,pIter); 791 } // if ( _bRemove ) 792 else 793 { 794 Reference< XGraphic > xGraphic; 795 if ( xNameAccess->getByName( aSeq[i] ) >>= xGraphic ) 796 { 797 Image aImage( xGraphic ); 798 setToolBarImage(aImage,pIter); 799 } 800 pIter->second.nImageInfo = nImageInfo; 801 } 802 } 803 } 804 } 805 } 806 void ToolBarManager::setToolBarImage(const Image& _aImage,const CommandToInfoMap::const_iterator& _pIter) 807 { 808 const ::std::vector< sal_uInt16 >& _rIDs = _pIter->second.aIds; 809 m_pToolBar->SetItemImage( _pIter->second.nId, _aImage ); 810 ::std::for_each(_rIDs.begin(),_rIDs.end(),::boost::bind(&ToolBar::SetItemImage,m_pToolBar,_1,_aImage)); 811 } 812 813 void SAL_CALL ToolBarManager::elementReplaced( const ::com::sun::star::ui::ConfigurationEvent& Event ) throw (::com::sun::star::uno::RuntimeException) 814 { 815 impl_elementChanged(false,Event); 816 } 817 818 void ToolBarManager::RemoveControllers() 819 { 820 ResetableGuard aGuard( m_aLock ); 821 822 if ( m_bDisposed ) 823 return; 824 825 m_aSubToolBarControllerMap.clear(); 826 827 828 // i90033 829 // Remove item window pointers from the toolbar. They were 830 // destroyed by the dispose() at the XComponent. This is needed 831 // as VCL code later tries to access the item window data in certain 832 // dtors where the item window is already invalid! 833 for ( sal_uInt16 i = 0; i < m_pToolBar->GetItemCount(); i++ ) 834 { 835 sal_uInt16 nItemId = m_pToolBar->GetItemId( i ); 836 if ( nItemId > 0 ) 837 { 838 Reference< XComponent > xComponent( m_aControllerMap[ nItemId ], UNO_QUERY ); 839 if ( xComponent.is() ) 840 { 841 try 842 { 843 xComponent->dispose(); 844 } 845 catch ( Exception& ) 846 { 847 } 848 } 849 m_pToolBar->SetItemWindow(nItemId, 0); 850 } 851 } 852 m_aControllerMap.clear(); 853 } 854 855 uno::Sequence< beans::PropertyValue > ToolBarManager::GetPropsForCommand( const ::rtl::OUString& rCmdURL ) 856 { 857 Sequence< PropertyValue > aPropSeq; 858 859 // Retrieve properties for command 860 try 861 { 862 if ( !m_bModuleIdentified ) 863 { 864 Reference< XModuleManager > xModuleManager( m_xServiceManager->createInstance( SERVICENAME_MODULEMANAGER ), UNO_QUERY_THROW ); 865 Reference< XInterface > xIfac( m_xFrame, UNO_QUERY ); 866 867 m_bModuleIdentified = sal_True; 868 m_aModuleIdentifier = xModuleManager->identify( xIfac ); 869 870 if ( m_aModuleIdentifier.getLength() > 0 ) 871 { 872 Reference< XNameAccess > xNameAccess( m_xServiceManager->createInstance( SERVICENAME_UICOMMANDDESCRIPTION ), UNO_QUERY ); 873 if ( xNameAccess.is() ) 874 xNameAccess->getByName( m_aModuleIdentifier ) >>= m_xUICommandLabels; 875 } 876 } 877 878 if ( m_xUICommandLabels.is() ) 879 { 880 if ( rCmdURL.getLength() > 0 ) 881 m_xUICommandLabels->getByName( rCmdURL ) >>= aPropSeq; 882 } 883 } 884 catch ( Exception& ) 885 { 886 } 887 888 return aPropSeq; 889 } 890 891 ::rtl::OUString ToolBarManager::RetrieveLabelFromCommand( const ::rtl::OUString& aCmdURL ) 892 { 893 ::rtl::OUString aLabel; 894 Sequence< PropertyValue > aPropSeq; 895 896 // Retrieve popup menu labels 897 aPropSeq = GetPropsForCommand( aCmdURL ); 898 for ( sal_Int32 i = 0; i < aPropSeq.getLength(); i++ ) 899 { 900 if ( aPropSeq[i].Name.equalsAscii( "Name" )) 901 { 902 aPropSeq[i].Value >>= aLabel; 903 break; 904 } 905 } 906 return aLabel; 907 } 908 909 sal_Int32 ToolBarManager::RetrievePropertiesFromCommand( const ::rtl::OUString& aCmdURL ) 910 { 911 sal_Int32 nProperties(0); 912 Sequence< PropertyValue > aPropSeq; 913 914 // Retrieve popup menu labels 915 aPropSeq = GetPropsForCommand( aCmdURL ); 916 for ( sal_Int32 i = 0; i < aPropSeq.getLength(); i++ ) 917 { 918 if ( aPropSeq[i].Name.equalsAscii( "Properties" )) 919 { 920 aPropSeq[i].Value >>= nProperties; 921 break; 922 } 923 } 924 return nProperties; 925 } 926 927 void ToolBarManager::CreateControllers() 928 { 929 RTL_LOGFILE_CONTEXT( aLog, "framework (cd100003) ::ToolBarManager::CreateControllers" ); 930 931 Reference< XComponentContext > xComponentContext; 932 Reference< XPropertySet > xProps( m_xServiceManager, UNO_QUERY ); 933 Reference< XWindow > xToolbarWindow = VCLUnoHelper::GetInterface( m_pToolBar ); 934 935 css::util::URL aURL; 936 sal_Bool bHasDisabledEntries = SvtCommandOptions().HasEntries( SvtCommandOptions::CMDOPTION_DISABLED ); 937 SvtCommandOptions aCmdOptions; 938 939 if ( xProps.is() ) 940 xProps->getPropertyValue( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "DefaultContext" ))) >>= xComponentContext; 941 942 for ( sal_uInt16 i = 0; i < m_pToolBar->GetItemCount(); i++ ) 943 { 944 sal_uInt16 nId = m_pToolBar->GetItemId( i ); 945 if ( nId == 0 ) 946 continue; 947 948 rtl::OUString aLoadURL( RTL_CONSTASCII_USTRINGPARAM( ".uno:OpenUrl" )); 949 rtl::OUString aCommandURL( m_pToolBar->GetItemCommand( nId )); 950 sal_Bool bInit( sal_True ); 951 sal_Bool bCreate( sal_True ); 952 Reference< XStatusListener > xController; 953 CommandToInfoMap::iterator pCommandIter = m_aCommandMap.find( aCommandURL ); 954 sal_Int16 nWidth = ( pCommandIter != m_aCommandMap.end() ? pCommandIter->second.nWidth : 0 ); 955 956 svt::ToolboxController* pController( 0 ); 957 958 if ( bHasDisabledEntries ) 959 { 960 aURL.Complete = aCommandURL; 961 m_xURLTransformer->parseStrict( aURL ); 962 if ( aCmdOptions.Lookup( SvtCommandOptions::CMDOPTION_DISABLED, aURL.Path )) 963 { 964 m_aControllerMap[ nId ] = xController; 965 m_pToolBar->HideItem( nId ); 966 continue; 967 } 968 } 969 970 if ( m_xToolbarControllerFactory.is() && 971 m_xToolbarControllerFactory->hasController( aCommandURL, m_aModuleIdentifier )) 972 { 973 PropertyValue aPropValue; 974 std::vector< Any > aPropertyVector; 975 976 aPropValue.Name = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "ModuleIdentifier" )); 977 aPropValue.Value <<= m_aModuleIdentifier; 978 aPropertyVector.push_back( makeAny( aPropValue )); 979 aPropValue.Name = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Frame" )); 980 aPropValue.Value <<= m_xFrame; 981 aPropertyVector.push_back( makeAny( aPropValue )); 982 aPropValue.Name = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "ServiceManager" )); 983 aPropValue.Value <<= m_xServiceManager; 984 aPropertyVector.push_back( makeAny( aPropValue )); 985 aPropValue.Name = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "ParentWindow" )); 986 aPropValue.Value <<= xToolbarWindow; 987 aPropertyVector.push_back( makeAny( aPropValue )); 988 aPropValue.Name = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Identifier" )); 989 aPropValue.Value = uno::makeAny( nId ); 990 aPropertyVector.push_back( uno::makeAny( aPropValue ) ); 991 992 if ( nWidth > 0 ) 993 { 994 aPropValue.Name = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Width" )); 995 aPropValue.Value <<= nWidth; 996 aPropertyVector.push_back( makeAny( aPropValue )); 997 } 998 999 Sequence< Any > aArgs( comphelper::containerToSequence( aPropertyVector )); 1000 xController = Reference< XStatusListener >( m_xToolbarControllerFactory->createInstanceWithArgumentsAndContext( 1001 aCommandURL, aArgs, xComponentContext ), 1002 UNO_QUERY ); 1003 bInit = sal_False; // Initialization is done through the factory service 1004 } 1005 1006 if (( aCommandURL == aLoadURL ) && ( !m_pToolBar->IsItemVisible(nId))) 1007 bCreate = sal_False; 1008 1009 if ( !xController.is() && m_pToolBar && bCreate ) 1010 { 1011 pController = CreateToolBoxController( m_xFrame, m_pToolBar, nId, aCommandURL ); 1012 if ( !pController ) 1013 { 1014 if ( m_pToolBar->GetItemData( nId ) != 0 ) 1015 { 1016 // retrieve additional parameters 1017 ::rtl::OUString aControlType = static_cast< AddonsParams* >( m_pToolBar->GetItemData( nId ))->aControlType; 1018 1019 Reference< XStatusListener > xStatusListener( 1020 ToolBarMerger::CreateController( m_xServiceManager, 1021 m_xFrame, 1022 m_pToolBar, 1023 aCommandURL, 1024 nId, 1025 nWidth, 1026 aControlType ), UNO_QUERY ); 1027 1028 xController = xStatusListener; 1029 } 1030 else 1031 { 1032 MenuDescriptionMap::iterator it = m_aMenuMap.find( nId ); 1033 if ( it == m_aMenuMap.end() ) 1034 { 1035 xController = Reference< XStatusListener >( 1036 new GenericToolbarController( m_xServiceManager, m_xFrame, m_pToolBar, nId, aCommandURL )); 1037 1038 // Accessibility support: Set toggle button role for specific commands 1039 sal_Int32 nProps = RetrievePropertiesFromCommand( aCommandURL ); 1040 if ( nProps & UICOMMANDDESCRIPTION_PROPERTIES_TOGGLEBUTTON ) 1041 m_pToolBar->SetItemBits( nId, m_pToolBar->GetItemBits( nId ) | TIB_CHECKABLE ); 1042 } 1043 else 1044 xController = Reference< XStatusListener >( 1045 new MenuToolbarController( m_xServiceManager, m_xFrame, m_pToolBar, nId, aCommandURL, m_aModuleIdentifier, m_aMenuMap[ nId ] )); 1046 } 1047 } 1048 else if ( pController ) 1049 { 1050 xController = Reference< XStatusListener >( static_cast< ::cppu::OWeakObject *>( pController ), UNO_QUERY ); 1051 } 1052 } 1053 1054 // Associate ID and controller to be able to retrieve 1055 // the controller from the ID later. 1056 m_aControllerMap[ nId ] = xController; 1057 1058 // Fill sub-toolbars into our hash-map 1059 Reference< XSubToolbarController > xSubToolBar( xController, UNO_QUERY ); 1060 if ( xSubToolBar.is() && xSubToolBar->opensSubToolbar() ) 1061 { 1062 rtl::OUString aSubToolBarName = xSubToolBar->getSubToolbarName(); 1063 if ( aSubToolBarName.getLength() != 0 ) 1064 { 1065 SubToolBarToSubToolBarControllerMap::iterator pIter = 1066 m_aSubToolBarControllerMap.find( aSubToolBarName ); 1067 if ( pIter == m_aSubToolBarControllerMap.end() ) 1068 { 1069 SubToolBarControllerVector aSubToolBarVector; 1070 aSubToolBarVector.push_back( xSubToolBar ); 1071 m_aSubToolBarControllerMap.insert( 1072 SubToolBarToSubToolBarControllerMap::value_type( 1073 aSubToolBarName, aSubToolBarVector )); 1074 } 1075 else 1076 pIter->second.push_back( xSubToolBar ); 1077 } 1078 } 1079 1080 Reference< XInitialization > xInit( xController, UNO_QUERY ); 1081 if ( xInit.is() ) 1082 { 1083 if ( bInit ) 1084 { 1085 PropertyValue aPropValue; 1086 std::vector< Any > aPropertyVector; 1087 1088 aPropValue.Name = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Frame" )); 1089 aPropValue.Value <<= m_xFrame; 1090 aPropertyVector.push_back( makeAny( aPropValue )); 1091 aPropValue.Name = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "CommandURL" )); 1092 aPropValue.Value <<= aCommandURL; 1093 aPropertyVector.push_back( makeAny( aPropValue )); 1094 aPropValue.Name = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "ServiceManager" )); 1095 aPropValue.Value <<= m_xServiceManager; 1096 aPropertyVector.push_back( makeAny( aPropValue )); 1097 aPropValue.Name = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "ParentWindow" )); 1098 aPropValue.Value <<= xToolbarWindow; 1099 aPropertyVector.push_back( makeAny( aPropValue )); 1100 aPropValue.Name = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "ModuleIdentifier" )); 1101 aPropValue.Value <<= m_aModuleIdentifier; 1102 aPropertyVector.push_back( makeAny( aPropValue )); 1103 aPropValue.Name = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Identifier" )); 1104 aPropValue.Value = uno::makeAny( nId ); 1105 aPropertyVector.push_back( uno::makeAny( aPropValue ) ); 1106 1107 if ( nWidth > 0 ) 1108 { 1109 aPropValue.Name = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Width" )); 1110 aPropValue.Value <<= nWidth; 1111 aPropertyVector.push_back( makeAny( aPropValue )); 1112 } 1113 1114 Sequence< Any > aArgs( comphelper::containerToSequence( aPropertyVector )); 1115 xInit->initialize( aArgs ); 1116 //for Support Visiblitly by shizhoubo 1117 if (pController) 1118 { 1119 // rtl::OUString aCommandURL = pController->m_aCommandURL; 1120 if(aCommandURL == rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ".uno:SwitchXFormsDesignMode" )) || 1121 aCommandURL == rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ".uno:ViewDataSourceBrowser" )) || 1122 aCommandURL == rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ".uno:ParaLeftToRight" )) || 1123 aCommandURL == rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ".uno:ParaRightToLeft" )) 1124 ) 1125 pController->setFastPropertyValue_NoBroadcast(1,makeAny(sal_True)); 1126 } 1127 1128 //end 1129 } 1130 1131 // Request a item window from the toolbar controller and set it at the VCL toolbar 1132 Reference< XToolbarController > xTbxController( xController, UNO_QUERY ); 1133 if ( xTbxController.is() && xToolbarWindow.is() ) 1134 { 1135 Reference< XWindow > xWindow = xTbxController->createItemWindow( xToolbarWindow ); 1136 if ( xWindow.is() ) 1137 { 1138 Window* pItemWin = VCLUnoHelper::GetWindow( xWindow ); 1139 if ( pItemWin ) 1140 { 1141 WindowType nType = pItemWin->GetType(); 1142 if ( nType == WINDOW_LISTBOX || nType == WINDOW_MULTILISTBOX || nType == WINDOW_COMBOBOX ) 1143 pItemWin->SetAccessibleName( m_pToolBar->GetItemText( nId ) ); 1144 m_pToolBar->SetItemWindow( nId, pItemWin ); 1145 } 1146 } 1147 } 1148 } 1149 //for update Controller via support visiable state by shizhoubo 1150 Reference< XPropertySet > xPropSet( xController, UNO_QUERY ); 1151 if ( xPropSet.is() ) 1152 { 1153 try 1154 { 1155 sal_Bool bSupportVisiable = sal_True; 1156 Any a( xPropSet->getPropertyValue( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "SupportsVisiable" ))) ); 1157 a >>= bSupportVisiable; 1158 if ( bSupportVisiable ) 1159 { 1160 Reference< XToolbarController > xTbxController( xController, UNO_QUERY ); 1161 UpdateController(xTbxController); 1162 } 1163 } 1164 catch ( RuntimeException& ) 1165 { 1166 throw; 1167 } 1168 catch ( Exception& ) 1169 { 1170 } 1171 } 1172 //end 1173 1174 } 1175 1176 AddFrameActionListener(); 1177 AddImageOrientationListener(); 1178 } 1179 1180 void ToolBarManager::AddFrameActionListener() 1181 { 1182 if ( !m_bFrameActionRegistered && m_xFrame.is() ) 1183 { 1184 m_bFrameActionRegistered = sal_True; 1185 m_xFrame->addFrameActionListener( Reference< XFrameActionListener >( 1186 static_cast< ::cppu::OWeakObject *>( this ), UNO_QUERY )); 1187 } 1188 } 1189 1190 void ToolBarManager::AddImageOrientationListener() 1191 { 1192 if ( !m_bImageOrientationRegistered && m_xFrame.is() ) 1193 { 1194 m_bImageOrientationRegistered = sal_True; 1195 ImageOrientationListener* pImageOrientation = new ImageOrientationListener( 1196 Reference< XStatusListener >( static_cast< ::cppu::OWeakObject *>( this ), UNO_QUERY ), 1197 m_xServiceManager, 1198 m_xFrame ); 1199 m_xImageOrientationListener = Reference< XComponent >( static_cast< ::cppu::OWeakObject *>( 1200 pImageOrientation ), UNO_QUERY ); 1201 pImageOrientation->addStatusListener( 1202 rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ".uno:ImageOrientation" ))); 1203 pImageOrientation->bindListener(); 1204 } 1205 } 1206 1207 sal_uInt16 ToolBarManager::ConvertStyleToToolboxItemBits( sal_Int32 nStyle ) 1208 { 1209 sal_uInt16 nItemBits( 0 ); 1210 if ( nStyle & ::com::sun::star::ui::ItemStyle::RADIO_CHECK ) 1211 nItemBits |= TIB_RADIOCHECK; 1212 if ( nStyle & ::com::sun::star::ui::ItemStyle::ALIGN_LEFT ) 1213 nItemBits |= TIB_LEFT; 1214 if ( nStyle & ::com::sun::star::ui::ItemStyle::AUTO_SIZE ) 1215 nItemBits |= TIB_AUTOSIZE; 1216 if ( nStyle & ::com::sun::star::ui::ItemStyle::DROP_DOWN ) 1217 nItemBits |= TIB_DROPDOWN; 1218 if ( nStyle & ::com::sun::star::ui::ItemStyle::REPEAT ) 1219 nItemBits |= TIB_REPEAT; 1220 if ( nStyle & ::com::sun::star::ui::ItemStyle::DROPDOWN_ONLY ) 1221 nItemBits |= TIB_DROPDOWNONLY; 1222 if ( nStyle & ::com::sun::star::ui::ItemStyle::TEXT ) 1223 nItemBits |= TIB_TEXT_ONLY; 1224 if ( nStyle & ::com::sun::star::ui::ItemStyle::ICON ) 1225 nItemBits |= TIB_ICON_ONLY; 1226 1227 return nItemBits; 1228 } 1229 1230 void ToolBarManager::FillToolbar( const Reference< XIndexAccess >& rItemContainer ) 1231 { 1232 ::rtl::OString aTbxName = rtl::OUStringToOString( m_aResourceName, RTL_TEXTENCODING_ASCII_US ); 1233 1234 RTL_LOGFILE_CONTEXT( aLog, "framework (cd100003) ::ToolBarManager::FillToolbar" ); 1235 RTL_LOGFILE_CONTEXT_TRACE1( aLog, "framework (cd100003) ::ToolBarManager::FillToolbar %s", aTbxName.getStr() ); 1236 1237 ResetableGuard aGuard( m_aLock ); 1238 1239 if ( m_bDisposed ) 1240 return; 1241 1242 sal_uInt16 nId( 1 ); 1243 ::rtl::OUString aHelpIdPrefix( RTL_CONSTASCII_USTRINGPARAM( HELPID_PREFIX )); 1244 1245 Reference< XModuleManager > xModuleManager( Reference< XModuleManager >( 1246 m_xServiceManager->createInstance( SERVICENAME_MODULEMANAGER ), UNO_QUERY )); 1247 if ( !m_xDocImageManager.is() ) 1248 { 1249 Reference< XModel > xModel( GetModelFromFrame() ); 1250 if ( xModel.is() ) 1251 { 1252 Reference< XUIConfigurationManagerSupplier > xSupplier( xModel, UNO_QUERY ); 1253 if ( xSupplier.is() ) 1254 { 1255 m_xDocUICfgMgr.set( xSupplier->getUIConfigurationManager(), UNO_QUERY ); 1256 m_xDocImageManager = Reference< XImageManager >( m_xDocUICfgMgr->getImageManager(), UNO_QUERY ); 1257 m_xDocImageManager->addConfigurationListener( 1258 Reference< XUIConfigurationListener >( 1259 static_cast< OWeakObject* >( this ), UNO_QUERY )); 1260 } 1261 } 1262 } 1263 1264 try 1265 { 1266 if ( xModuleManager.is() ) 1267 m_aModuleIdentifier = xModuleManager->identify( Reference< XInterface >( m_xFrame, UNO_QUERY ) ); 1268 } 1269 catch( Exception& ) 1270 { 1271 } 1272 1273 if ( !m_xModuleImageManager.is() ) 1274 { 1275 Reference< XModuleUIConfigurationManagerSupplier > xModuleCfgMgrSupplier( m_xServiceManager->createInstance( 1276 SERVICENAME_MODULEUICONFIGURATIONMANAGERSUPPLIER ), 1277 UNO_QUERY ); 1278 m_xUICfgMgr = xModuleCfgMgrSupplier->getUIConfigurationManager( m_aModuleIdentifier ); 1279 m_xModuleImageManager = Reference< XImageManager >( m_xUICfgMgr->getImageManager(), UNO_QUERY ); 1280 m_xModuleImageManager->addConfigurationListener( Reference< XUIConfigurationListener >( 1281 static_cast< OWeakObject* >( this ), UNO_QUERY )); 1282 } 1283 1284 RemoveControllers(); 1285 1286 // reset and fill command map 1287 m_pToolBar->Clear(); 1288 m_aControllerMap.clear(); 1289 m_aCommandMap.clear(); 1290 1291 m_aMenuMap.clear(); 1292 1293 CommandInfo aCmdInfo; 1294 for ( sal_Int32 n = 0; n < rItemContainer->getCount(); n++ ) 1295 { 1296 Sequence< PropertyValue > aProp; 1297 rtl::OUString aCommandURL; 1298 rtl::OUString aLabel; 1299 rtl::OUString aHelpURL; 1300 rtl::OUString aTooltip; 1301 sal_uInt16 nType( ::com::sun::star::ui::ItemType::DEFAULT ); 1302 sal_uInt16 nWidth( 0 ); 1303 sal_Bool bIsVisible( sal_True ); 1304 sal_uInt32 nStyle( 0 ); 1305 1306 Reference< XIndexAccess > aMenuDesc; 1307 try 1308 { 1309 if ( rItemContainer->getByIndex( n ) >>= aProp ) 1310 { 1311 for ( int i = 0; i < aProp.getLength(); i++ ) 1312 { 1313 if ( aProp[i].Name.equalsAsciiL( ITEM_DESCRIPTOR_COMMANDURL, ITEM_DESCRIPTOR_COMMANDURL_LEN )) 1314 { 1315 aProp[i].Value >>= aCommandURL; 1316 if ( aCommandURL.compareToAscii(MENUPREFIX, RTL_CONSTASCII_LENGTH(MENUPREFIX) ) == 0 ) 1317 { 1318 try 1319 { 1320 Reference< XIndexAccess > xMenuContainer; 1321 if ( m_xDocUICfgMgr.is() && 1322 m_xDocUICfgMgr->hasSettings( aCommandURL ) ) 1323 xMenuContainer = m_xDocUICfgMgr->getSettings( aCommandURL, sal_False ); 1324 if ( !xMenuContainer.is() && 1325 m_xUICfgMgr.is() && 1326 m_xUICfgMgr->hasSettings( aCommandURL ) ) 1327 xMenuContainer = m_xUICfgMgr->getSettings( aCommandURL, sal_False ); 1328 if ( xMenuContainer.is() && xMenuContainer->getCount() ) 1329 { 1330 Sequence< PropertyValue > aProps; 1331 // drop down menu info is currently 1332 // the first ( and only ) menu 1333 // in the menusettings container 1334 xMenuContainer->getByIndex(0) >>= aProps; 1335 for ( sal_Int32 index=0; index<aProps.getLength(); ++index ) 1336 { 1337 if ( aProps[ index ].Name.equalsAsciiL( ITEM_DESCRIPTOR_CONTAINER, ITEM_DESCRIPTOR_CONTAINER_LEN )) 1338 1339 { 1340 aProps[ index ].Value >>= aMenuDesc; 1341 break; 1342 } 1343 } 1344 } 1345 } 1346 catch( Exception& ) 1347 { 1348 } 1349 } 1350 } 1351 else if ( aProp[i].Name.equalsAsciiL( ITEM_DESCRIPTOR_HELPURL, ITEM_DESCRIPTOR_HELPURL_LEN )) 1352 aProp[i].Value >>= aHelpURL; 1353 else if ( aProp[i].Name.equalsAsciiL( ITEM_DESCRIPTOR_TOOLTIP, ITEM_DESCRIPTOR_TOOLTIP_LEN )) 1354 aProp[i].Value >>= aTooltip; 1355 else if ( aProp[i].Name.equalsAsciiL( ITEM_DESCRIPTOR_LABEL, ITEM_DESCRIPTOR_LABEL_LEN )) 1356 aProp[i].Value >>= aLabel; 1357 else if ( aProp[i].Name.equalsAsciiL( ITEM_DESCRIPTOR_TYPE, ITEM_DESCRIPTOR_TYPE_LEN )) 1358 aProp[i].Value >>= nType; 1359 else if ( aProp[i].Name.equalsAsciiL( ITEM_DESCRIPTOR_VISIBLE, ITEM_DESCRIPTOR_VISIBLE_LEN )) 1360 aProp[i].Value >>= bIsVisible; 1361 else if ( aProp[i].Name.equalsAsciiL( ITEM_DESCRIPTOR_WIDTH, ITEM_DESCRIPTOR_WIDTH_LEN )) 1362 aProp[i].Value >>= nWidth; 1363 else if ( aProp[i].Name.equalsAsciiL( ITEM_DESCRIPTOR_STYLE, ITEM_DESCRIPTOR_STYLE_LEN )) 1364 aProp[i].Value >>= nStyle; 1365 } 1366 1367 if (( nType == ::com::sun::star::ui::ItemType::DEFAULT ) && ( aCommandURL.getLength() > 0 )) 1368 { 1369 ::rtl::OUString aString( RetrieveLabelFromCommand( aCommandURL )); 1370 1371 sal_uInt16 nItemBits = ConvertStyleToToolboxItemBits( nStyle ); 1372 if ( aMenuDesc.is() ) 1373 { 1374 m_aMenuMap[ nId ] = aMenuDesc; 1375 nItemBits |= TIB_DROPDOWNONLY; 1376 } 1377 m_pToolBar->InsertItem( nId, aString, nItemBits ); 1378 m_pToolBar->SetItemCommand( nId, aCommandURL ); 1379 if ( aTooltip.getLength() ) 1380 { 1381 m_pToolBar->SetQuickHelpText( nId, aTooltip ); 1382 } 1383 else 1384 { 1385 ::rtl::OUString sQuickHelp( aString ); 1386 ::rtl::OUString sShortCut; 1387 if( RetrieveShortcut( aCommandURL, sShortCut ) ) 1388 { 1389 sQuickHelp += rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( " (" ) ); 1390 sQuickHelp += sShortCut; 1391 sQuickHelp += rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ")" ) ); 1392 } 1393 1394 m_pToolBar->SetQuickHelpText( nId, sQuickHelp ); 1395 } 1396 1397 if ( aLabel.getLength() > 0 ) 1398 { 1399 m_pToolBar->SetItemText( nId, aLabel ); 1400 } 1401 else 1402 { 1403 m_pToolBar->SetItemText( nId, aString ); 1404 } 1405 m_pToolBar->EnableItem( nId, sal_True ); 1406 m_pToolBar->SetItemState( nId, STATE_NOCHECK ); 1407 1408 // Fill command map. It stores all our commands and from what 1409 // image manager we got our image. So we can decide if we have to use an 1410 // image from a notification message. 1411 CommandToInfoMap::iterator pIter = m_aCommandMap.find( aCommandURL ); 1412 if ( pIter == m_aCommandMap.end()) 1413 { 1414 aCmdInfo.nId = nId; 1415 aCmdInfo.nWidth = nWidth; 1416 m_aCommandMap.insert( CommandToInfoMap::value_type( aCommandURL, aCmdInfo )); 1417 } 1418 else 1419 { 1420 pIter->second.aIds.push_back( nId ); 1421 } 1422 1423 if ( !bIsVisible ) 1424 m_pToolBar->HideItem( nId ); 1425 1426 ++nId; 1427 } 1428 else if ( nType == ::com::sun::star::ui::ItemType::SEPARATOR_LINE ) 1429 { 1430 m_pToolBar->InsertSeparator(); 1431 } 1432 else if ( nType == ::com::sun::star::ui::ItemType::SEPARATOR_SPACE ) 1433 { 1434 m_pToolBar->InsertSpace(); 1435 } 1436 else if ( nType == ::com::sun::star::ui::ItemType::SEPARATOR_LINEBREAK ) 1437 { 1438 m_pToolBar->InsertBreak(); 1439 } 1440 } 1441 } 1442 catch ( ::com::sun::star::lang::IndexOutOfBoundsException& ) 1443 { 1444 break; 1445 } 1446 } 1447 1448 // Support add-on toolbar merging here. Working directly on the toolbar object is much 1449 // simpler and faster. 1450 const sal_uInt16 TOOLBAR_ITEM_STARTID = 1000; 1451 1452 MergeToolbarInstructionContainer aMergeInstructionContainer; 1453 1454 // Retrieve the toolbar name from the resource name 1455 ::rtl::OUString aToolbarName( m_aResourceName ); 1456 sal_Int32 nIndex = aToolbarName.lastIndexOf( '/' ); 1457 if (( nIndex > 0 ) && ( nIndex < aToolbarName.getLength() )) 1458 aToolbarName = aToolbarName.copy( nIndex+1 ); 1459 1460 AddonsOptions().GetMergeToolbarInstructions( aToolbarName, aMergeInstructionContainer ); 1461 1462 if ( !aMergeInstructionContainer.empty() ) 1463 { 1464 sal_uInt16 nItemId( TOOLBAR_ITEM_STARTID ); 1465 const sal_uInt32 nCount = aMergeInstructionContainer.size(); 1466 for ( sal_uInt32 i=0; i < nCount; i++ ) 1467 { 1468 MergeToolbarInstruction& rInstruction = aMergeInstructionContainer[i]; 1469 if ( ToolBarMerger::IsCorrectContext( rInstruction.aMergeContext, m_aModuleIdentifier )) 1470 { 1471 ReferenceToolbarPathInfo aRefPoint = ToolBarMerger::FindReferencePoint( m_pToolBar, rInstruction.aMergePoint ); 1472 1473 // convert the sequence< sequence< propertyvalue > > structure to 1474 // something we can better handle. A vector with item data 1475 AddonToolbarItemContainer aItems; 1476 ToolBarMerger::ConvertSeqSeqToVector( rInstruction.aMergeToolbarItems, aItems ); 1477 1478 if ( aRefPoint.bResult ) 1479 { 1480 ToolBarMerger::ProcessMergeOperation( m_xFrame, 1481 m_pToolBar, 1482 aRefPoint.nPos, 1483 nItemId, 1484 m_aCommandMap, 1485 m_aModuleIdentifier, 1486 rInstruction.aMergeCommand, 1487 rInstruction.aMergeCommandParameter, 1488 aItems ); 1489 } 1490 else 1491 { 1492 ToolBarMerger::ProcessMergeFallback( m_xFrame, 1493 m_pToolBar, 1494 aRefPoint.nPos, 1495 nItemId, 1496 m_aCommandMap, 1497 m_aModuleIdentifier, 1498 rInstruction.aMergeCommand, 1499 rInstruction.aMergeFallback, 1500 aItems ); 1501 } 1502 } 1503 } 1504 } 1505 1506 // Request images for all toolbar items. Must be done before CreateControllers as 1507 // some controllers need access to the image. 1508 RequestImages(); 1509 1510 // Create controllers after we set the images. There are controllers which needs 1511 // an image at the toolbar at creation time! 1512 CreateControllers(); 1513 1514 // Notify controllers that they are now correctly initialized and can start listening 1515 // toolbars that will open in popup mode will be updated immediately to avoid flickering 1516 if( m_pToolBar->WillUsePopupMode() ) 1517 UpdateControllers(); 1518 else if ( m_pToolBar->IsReallyVisible() ) 1519 m_aAsyncUpdateControllersTimer.Start(); 1520 1521 // Try to retrieve UIName from the container property set and set it as the title 1522 // if it is not empty. 1523 Reference< XPropertySet > xPropSet( rItemContainer, UNO_QUERY ); 1524 if ( xPropSet.is() ) 1525 { 1526 try 1527 { 1528 rtl::OUString aUIName; 1529 xPropSet->getPropertyValue( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "UIName" ))) >>= aUIName; 1530 if ( aUIName.getLength() > 0 ) 1531 m_pToolBar->SetText( aUIName ); 1532 } 1533 catch ( Exception& ) 1534 { 1535 } 1536 } 1537 } 1538 1539 void ToolBarManager::RequestImages() 1540 { 1541 RTL_LOGFILE_CONTEXT( aLog, "framework (cd100003) ::ToolBarManager::RequestImages" ); 1542 1543 // Request images from image manager 1544 Sequence< rtl::OUString > aCmdURLSeq( m_aCommandMap.size() ); 1545 Sequence< Reference< XGraphic > > aDocGraphicSeq; 1546 Sequence< Reference< XGraphic > > aModGraphicSeq; 1547 1548 sal_uInt32 i = 0; 1549 CommandToInfoMap::iterator pIter = m_aCommandMap.begin(); 1550 CommandToInfoMap::iterator pEnd = m_aCommandMap.end(); 1551 while ( pIter != pEnd ) 1552 { 1553 aCmdURLSeq[i++] = pIter->first; 1554 ++pIter; 1555 } 1556 1557 sal_Bool bBigImages( SvtMiscOptions().AreCurrentSymbolsLarge() ); 1558 m_bIsHiContrast = m_pToolBar->GetSettings().GetStyleSettings().GetHighContrastMode(); 1559 sal_Int16 p = getImageTypeFromBools( SvtMiscOptions().AreCurrentSymbolsLarge(), m_bIsHiContrast ); 1560 1561 if ( m_xDocImageManager.is() ) 1562 aDocGraphicSeq = m_xDocImageManager->getImages( p, aCmdURLSeq ); 1563 aModGraphicSeq = m_xModuleImageManager->getImages( p, aCmdURLSeq ); 1564 1565 i = 0; 1566 pIter = m_aCommandMap.begin(); 1567 while ( pIter != pEnd ) 1568 { 1569 rtl::OUString aCommandURL = aCmdURLSeq[i]; 1570 1571 Image aImage; 1572 if ( aDocGraphicSeq.getLength() > 0 ) 1573 aImage = Image( aDocGraphicSeq[i] ); 1574 if ( !aImage ) 1575 { 1576 aImage = Image( aModGraphicSeq[i] ); 1577 // Try also to query for add-on images before giving up and use an 1578 // empty image. 1579 if ( !aImage ) 1580 aImage = QueryAddonsImage( aCmdURLSeq[i], bBigImages, m_bIsHiContrast ); 1581 1582 pIter->second.nImageInfo = 1; // mark image as module based 1583 } 1584 else 1585 { 1586 pIter->second.nImageInfo = 0; // mark image as document based 1587 } 1588 setToolBarImage(aImage,pIter); 1589 ++pIter; 1590 ++i; 1591 } 1592 } 1593 1594 void ToolBarManager::notifyRegisteredControllers( const rtl::OUString& aUIElementName, const rtl::OUString& aCommand ) 1595 { 1596 ResetableGuard aGuard( m_aLock ); 1597 if ( !m_aSubToolBarControllerMap.empty() ) 1598 { 1599 SubToolBarToSubToolBarControllerMap::const_iterator pIter = 1600 m_aSubToolBarControllerMap.find( aUIElementName ); 1601 1602 if ( pIter != m_aSubToolBarControllerMap.end() ) 1603 { 1604 const SubToolBarControllerVector& rSubToolBarVector = pIter->second; 1605 if ( !rSubToolBarVector.empty() ) 1606 { 1607 SubToolBarControllerVector aNotifyVector = rSubToolBarVector; 1608 aGuard.unlock(); 1609 1610 const sal_uInt32 nCount = aNotifyVector.size(); 1611 for ( sal_uInt32 i=0; i < nCount; i++ ) 1612 { 1613 try 1614 { 1615 Reference< XSubToolbarController > xController = aNotifyVector[i]; 1616 if ( xController.is() ) 1617 xController->functionSelected( aCommand ); 1618 } 1619 catch ( RuntimeException& e ) 1620 { 1621 throw e; 1622 } 1623 catch ( Exception& ) 1624 { 1625 } 1626 } 1627 } 1628 } 1629 } 1630 } 1631 long ToolBarManager::HandleClick(void ( SAL_CALL XToolbarController::*_pClick )()) 1632 { 1633 ResetableGuard aGuard( m_aLock ); 1634 1635 if ( m_bDisposed ) 1636 return 1; 1637 1638 sal_uInt16 nId( m_pToolBar->GetCurItemId() ); 1639 ToolBarControllerMap::const_iterator pIter = m_aControllerMap.find( nId ); 1640 if ( pIter != m_aControllerMap.end() ) 1641 { 1642 Reference< XToolbarController > xController( pIter->second, UNO_QUERY ); 1643 1644 if ( xController.is() ) 1645 (xController.get()->*_pClick)( ); 1646 } // if ( pIter != m_aControllerMap.end() ) 1647 return 1; 1648 } 1649 1650 IMPL_LINK( ToolBarManager, Click, ToolBox*, EMPTYARG ) 1651 { 1652 return HandleClick(&XToolbarController::click); 1653 } 1654 1655 IMPL_LINK( ToolBarManager, DropdownClick, ToolBox*, EMPTYARG ) 1656 { 1657 ResetableGuard aGuard( m_aLock ); 1658 1659 if ( m_bDisposed ) 1660 return 1; 1661 1662 sal_uInt16 nId( m_pToolBar->GetCurItemId() ); 1663 ToolBarControllerMap::const_iterator pIter = m_aControllerMap.find( nId ); 1664 if ( pIter != m_aControllerMap.end() ) 1665 { 1666 Reference< XToolbarController > xController( pIter->second, UNO_QUERY ); 1667 1668 if ( xController.is() ) 1669 { 1670 Reference< XWindow > xWin = xController->createPopupWindow(); 1671 if ( xWin.is() ) 1672 xWin->setFocus(); 1673 } 1674 } 1675 return 1; 1676 } 1677 1678 IMPL_LINK( ToolBarManager, DoubleClick, ToolBox*, EMPTYARG ) 1679 { 1680 return HandleClick(&XToolbarController::doubleClick); 1681 } 1682 1683 void ToolBarManager::ImplClearPopupMenu( ToolBox *pToolBar ) 1684 { 1685 if ( m_bDisposed ) 1686 return; 1687 1688 PopupMenu *pMenu = pToolBar->GetMenu(); 1689 1690 // remove config entries from menu, so we have a clean menu to start with 1691 // remove submenu first 1692 PopupMenu* pItemMenu = pMenu->GetPopupMenu( 1 ); 1693 if( pItemMenu ) 1694 { 1695 pItemMenu->Clear(); 1696 delete pItemMenu; 1697 pItemMenu = NULL; 1698 pMenu->SetPopupMenu( 1, pItemMenu ); 1699 } 1700 1701 // remove all items that were not added by the toolbar itself 1702 sal_uInt16 i; 1703 for( i=0; i<pMenu->GetItemCount(); ) 1704 { 1705 if( pMenu->GetItemId( i ) < TOOLBOX_MENUITEM_START ) 1706 pMenu->RemoveItem( i ); 1707 else 1708 i++; 1709 } 1710 } 1711 1712 IMPL_LINK( ToolBarManager, MenuDeactivate, Menu*, pMenu ) 1713 { 1714 ResetableGuard aGuard( m_aLock ); 1715 1716 if ( m_bDisposed ) 1717 return 1; 1718 1719 if( pMenu != m_pToolBar->GetMenu() ) 1720 return 1; 1721 1722 ImplClearPopupMenu( m_pToolBar ); 1723 1724 return 0; 1725 } 1726 1727 Reference< XModel > ToolBarManager::GetModelFromFrame() const 1728 { 1729 Reference< XController > xController = m_xFrame->getController(); 1730 Reference< XModel > xModel; 1731 if ( xController.is() ) 1732 xModel = xController->getModel(); 1733 1734 return xModel; 1735 } 1736 1737 sal_Bool ToolBarManager::IsPluginMode() const 1738 { 1739 sal_Bool bPluginMode( sal_False ); 1740 1741 if ( m_xFrame.is() ) 1742 { 1743 Reference< XModel > xModel = GetModelFromFrame(); 1744 if ( xModel.is() ) 1745 { 1746 Sequence< PropertyValue > aSeq = xModel->getArgs(); 1747 comphelper::MediaDescriptor aMediaDescriptor( aSeq ); 1748 bPluginMode = aMediaDescriptor.getUnpackedValueOrDefault< sal_Bool >( 1749 comphelper::MediaDescriptor::PROP_VIEWONLY(), sal_False ); 1750 } 1751 } 1752 1753 return bPluginMode; 1754 } 1755 1756 bool ToolBarManager::MenuItemAllowed( sal_uInt16 ) const 1757 { 1758 return true; 1759 } 1760 1761 //added for i33668 by shizhoubo : 200804 1762 PopupMenu * ToolBarManager::GetToolBarCustomMeun(ToolBox* pToolBar) 1763 { 1764 PopupMenu *pMenu = pToolBar->GetMenu(); 1765 // remove all entries before inserting new ones 1766 ImplClearPopupMenu( pToolBar ); 1767 // No config menu entries if command ".uno:ConfigureDialog" is not enabled 1768 Reference< XDispatch > xDisp; 1769 com::sun::star::util::URL aURL; 1770 if ( m_xFrame.is() ) 1771 { 1772 Reference< XDispatchProvider > xProv( m_xFrame, UNO_QUERY ); 1773 aURL.Complete = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ".uno:ConfigureDialog" )); 1774 m_xURLTransformer->parseStrict( aURL ); 1775 if ( xProv.is() ) 1776 xDisp = xProv->queryDispatch( aURL, ::rtl::OUString(), 0 ); 1777 1778 if ( !xDisp.is() || IsPluginMode() ) 1779 return 0; 1780 } 1781 1782 // popup menu for quick customization 1783 sal_Bool bHideDisabledEntries = !SvtMenuOptions().IsEntryHidingEnabled(); 1784 PopupMenu aPopupMenu( FwkResId( POPUPMENU_TOOLBAR_QUICKCUSTOMIZATION )); 1785 1786 if ( m_pToolBar->IsCustomize() ) 1787 { 1788 sal_uInt16 nPos( 0 ); 1789 PopupMenu* pItemMenu( aPopupMenu.GetPopupMenu( 1 )); 1790 1791 sal_Bool bIsFloating( sal_False ); 1792 1793 DockingManager* pDockMgr = Window::GetDockingManager(); 1794 if ( pDockMgr ) 1795 bIsFloating = pDockMgr->IsFloating( m_pToolBar ); 1796 1797 if ( !bIsFloating ) 1798 { 1799 aPopupMenu.EnableItem( MENUITEM_TOOLBAR_DOCKTOOLBAR, sal_False ); 1800 aPopupMenu.EnableItem( MENUITEM_TOOLBAR_DOCKALLTOOLBAR, sal_False ); 1801 Reference< XDockableWindow > xDockable( VCLUnoHelper::GetInterface( m_pToolBar ), UNO_QUERY ); 1802 if( xDockable.is() ) 1803 aPopupMenu.CheckItem( MENUITEM_TOOLBAR_LOCKTOOLBARPOSITION, xDockable->isLocked() ); 1804 } 1805 else 1806 aPopupMenu.EnableItem( MENUITEM_TOOLBAR_LOCKTOOLBARPOSITION, sal_False ); 1807 1808 if ( !m_bCanBeCustomized ) 1809 { 1810 // Non-configurable toolbars should disable configuration menu items 1811 aPopupMenu.EnableItem( MENUITEM_TOOLBAR_VISIBLEBUTTON, sal_False ); 1812 aPopupMenu.EnableItem( MENUITEM_TOOLBAR_CUSTOMIZETOOLBAR, sal_False ); 1813 } 1814 1815 // Disable menu item CLOSE if the toolbar has no closer 1816 //added for issue64028 by shizhoubo 1817 if( !(pToolBar->GetFloatStyle() & WB_CLOSEABLE) ) 1818 aPopupMenu.EnableItem(MENUITEM_TOOLBAR_CLOSE, sal_False); 1819 //end 1820 1821 pItemMenu->SetMenuFlags (pItemMenu->GetMenuFlags () | 1822 MENU_FLAG_SHOWCHECKIMAGES); 1823 1824 for ( nPos = 0; nPos < m_pToolBar->GetItemCount(); ++nPos ) 1825 { 1826 if ( m_pToolBar->GetItemType(nPos) == TOOLBOXITEM_BUTTON ) 1827 { 1828 sal_uInt16 nId = m_pToolBar->GetItemId(nPos); 1829 ::rtl::OUString aCommandURL = m_pToolBar->GetItemCommand( nId ); 1830 pItemMenu->InsertItem( STARTID_CUSTOMIZE_POPUPMENU+nPos, m_pToolBar->GetItemText( nId ), MIB_CHECKABLE ); 1831 pItemMenu->CheckItem( STARTID_CUSTOMIZE_POPUPMENU+nPos, m_pToolBar->IsItemVisible( nId ) ); 1832 pItemMenu->SetItemCommand( STARTID_CUSTOMIZE_POPUPMENU+nPos, aCommandURL ); 1833 pItemMenu->SetItemImage( STARTID_CUSTOMIZE_POPUPMENU+nPos, 1834 GetImageFromURL( m_xFrame, 1835 aCommandURL, 1836 sal_False, 1837 m_bIsHiContrast )); 1838 } 1839 else 1840 { 1841 pItemMenu->InsertSeparator(); 1842 } 1843 } 1844 } 1845 else 1846 { 1847 sal_uInt16 nPos = aPopupMenu.GetItemPos( MENUITEM_TOOLBAR_CUSTOMIZETOOLBAR ); 1848 if ( nPos != MENU_ITEM_NOTFOUND ) 1849 aPopupMenu.RemoveItem( nPos ); 1850 } 1851 1852 // copy all menu items to the toolbar menu 1853 if( pMenu->GetItemCount() ) 1854 pMenu->InsertSeparator(); 1855 1856 sal_uInt16 i; 1857 for( i=0; i< aPopupMenu.GetItemCount(); i++) 1858 { 1859 sal_uInt16 nId = aPopupMenu.GetItemId( i ); 1860 if ( MenuItemAllowed( nId )) 1861 pMenu->CopyItem( aPopupMenu, i, MENU_APPEND ); 1862 } 1863 1864 // set submenu to toolbar menu 1865 if( aPopupMenu.GetPopupMenu( 1 ) ) 1866 { 1867 // create an own submenu to avoid auto-delete when resource menu is deleted 1868 PopupMenu *pItemMenu = new PopupMenu(); 1869 1870 pItemMenu->SetMenuFlags (pItemMenu->GetMenuFlags () | 1871 MENU_FLAG_SHOWCHECKIMAGES); 1872 1873 for( i=0; i< aPopupMenu.GetPopupMenu( 1 )->GetItemCount(); i++) 1874 pItemMenu->CopyItem( *aPopupMenu.GetPopupMenu( 1 ), i, MENU_APPEND ); 1875 1876 pMenu->SetPopupMenu( 1, pItemMenu ); 1877 } 1878 1879 if ( bHideDisabledEntries ) 1880 pMenu->RemoveDisabledEntries(); 1881 1882 return pMenu; 1883 } 1884 1885 // addd for 33668 by shizhoubo 1886 IMPL_LINK( ToolBarManager, Command, CommandEvent*, pCmdEvt ) 1887 { 1888 ResetableGuard aGuard( m_aLock ); 1889 1890 if ( m_bDisposed ) 1891 return 1; 1892 if ( pCmdEvt->GetCommand() != COMMAND_CONTEXTMENU ) 1893 return 0; 1894 1895 PopupMenu * pMenu = GetToolBarCustomMeun(m_pToolBar); 1896 if (pMenu) 1897 { 1898 // make sure all disabled entries will be shown 1899 pMenu->SetMenuFlags( pMenu->GetMenuFlags() | MENU_FLAG_ALWAYSSHOWDISABLEDENTRIES ); 1900 ::Point aPoint( pCmdEvt->GetMousePosPixel() ); 1901 pMenu->Execute( m_pToolBar, aPoint ); 1902 } 1903 1904 return 0; 1905 } 1906 //end 1907 1908 IMPL_LINK( ToolBarManager, MenuButton, ToolBox*, pToolBar ) 1909 { 1910 ResetableGuard aGuard( m_aLock ); 1911 1912 if ( m_bDisposed ) 1913 return 1; 1914 //modify for i33668 by shizhoubo:2008:04 1915 GetToolBarCustomMeun(pToolBar); 1916 //end 1917 return 0; 1918 } 1919 1920 IMPL_LINK( ToolBarManager, MenuSelect, Menu*, pMenu ) 1921 { 1922 // We have to hold a reference to ourself as it is possible that we will be disposed and 1923 // our refcount could be zero (destruction) otherwise. 1924 Reference< XInterface > xInterface( static_cast< OWeakObject* >( this ), UNO_QUERY ); 1925 1926 { 1927 // The guard must be in its own context as the we can get destroyed when our 1928 // own xInterface reference get destroyed! 1929 ResetableGuard aGuard( m_aLock ); 1930 1931 if ( m_bDisposed ) 1932 return 1; 1933 1934 switch ( pMenu->GetCurItemId() ) 1935 { 1936 case MENUITEM_TOOLBAR_CUSTOMIZETOOLBAR: 1937 { 1938 Reference< XDispatch > xDisp; 1939 com::sun::star::util::URL aURL; 1940 if ( m_xFrame.is() ) 1941 { 1942 Reference< XDispatchProvider > xProv( m_xFrame, UNO_QUERY ); 1943 aURL.Complete = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ".uno:ConfigureDialog" )); 1944 m_xURLTransformer->parseStrict( aURL ); 1945 if ( xProv.is() ) 1946 xDisp = xProv->queryDispatch( aURL, ::rtl::OUString(), 0 ); 1947 } 1948 1949 if ( xDisp.is() ) 1950 { 1951 Sequence< PropertyValue > aPropSeq( 1 ); 1952 1953 aPropSeq[ 0 ].Name = 1954 rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("ResourceURL")); 1955 aPropSeq[ 0 ].Value <<= m_aResourceName; 1956 1957 xDisp->dispatch( aURL, aPropSeq ); 1958 } 1959 break; 1960 } 1961 1962 case MENUITEM_TOOLBAR_DOCKTOOLBAR: 1963 { 1964 ExecuteInfo* pExecuteInfo = new ExecuteInfo; 1965 1966 pExecuteInfo->aToolbarResName = m_aResourceName; 1967 pExecuteInfo->nCmd = EXEC_CMD_DOCKTOOLBAR; 1968 pExecuteInfo->xLayoutManager = getLayoutManagerFromFrame( m_xFrame ); 1969 1970 Application::PostUserEvent( STATIC_LINK(0, ToolBarManager, ExecuteHdl_Impl), pExecuteInfo ); 1971 break; 1972 } 1973 1974 case MENUITEM_TOOLBAR_DOCKALLTOOLBAR: 1975 { 1976 ExecuteInfo* pExecuteInfo = new ExecuteInfo; 1977 1978 pExecuteInfo->aToolbarResName = m_aResourceName; 1979 pExecuteInfo->nCmd = EXEC_CMD_DOCKALLTOOLBARS; 1980 pExecuteInfo->xLayoutManager = getLayoutManagerFromFrame( m_xFrame ); 1981 1982 Application::PostUserEvent( STATIC_LINK(0, ToolBarManager, ExecuteHdl_Impl), pExecuteInfo ); 1983 break; 1984 } 1985 1986 case MENUITEM_TOOLBAR_LOCKTOOLBARPOSITION: 1987 { 1988 Reference< XLayoutManager > xLayoutManager = getLayoutManagerFromFrame( m_xFrame ); 1989 if ( xLayoutManager.is() ) 1990 { 1991 Reference< XDockableWindow > xDockable( VCLUnoHelper::GetInterface( m_pToolBar ), UNO_QUERY ); 1992 1993 if( xDockable->isLocked() ) 1994 xLayoutManager->unlockWindow( m_aResourceName ); 1995 else 1996 xLayoutManager->lockWindow( m_aResourceName ); 1997 } 1998 break; 1999 } 2000 2001 case MENUITEM_TOOLBAR_CLOSE: 2002 { 2003 ExecuteInfo* pExecuteInfo = new ExecuteInfo; 2004 2005 pExecuteInfo->aToolbarResName = m_aResourceName; 2006 pExecuteInfo->nCmd = EXEC_CMD_CLOSETOOLBAR; 2007 pExecuteInfo->xLayoutManager = getLayoutManagerFromFrame( m_xFrame ); 2008 pExecuteInfo->xWindow = VCLUnoHelper::GetInterface( m_pToolBar ); 2009 2010 Application::PostUserEvent( STATIC_LINK(0, ToolBarManager, ExecuteHdl_Impl), pExecuteInfo ); 2011 } 2012 2013 default: 2014 { 2015 sal_uInt16 nId = pMenu->GetCurItemId(); 2016 if(( nId > 0 ) && ( nId < TOOLBOX_MENUITEM_START )) 2017 { 2018 // toggle toolbar button visibility 2019 rtl::OUString aCommand = pMenu->GetItemCommand( nId ); 2020 2021 Reference< XLayoutManager > xLayoutManager = getLayoutManagerFromFrame( m_xFrame ); 2022 if ( xLayoutManager.is() ) 2023 { 2024 Reference< XUIElementSettings > xUIElementSettings( xLayoutManager->getElement( m_aResourceName ), UNO_QUERY ); 2025 if ( xUIElementSettings.is() ) 2026 { 2027 Reference< XIndexContainer > xItemContainer( xUIElementSettings->getSettings( sal_True ), UNO_QUERY ); 2028 sal_Int32 nCount = xItemContainer->getCount(); 2029 for ( sal_Int32 i = 0; i < nCount; i++ ) 2030 { 2031 Sequence< PropertyValue > aProp; 2032 sal_Int32 nVisibleIndex( -1 ); 2033 rtl::OUString aCommandURL; 2034 sal_Bool bVisible( sal_False ); 2035 2036 if ( xItemContainer->getByIndex( i ) >>= aProp ) 2037 { 2038 for ( sal_Int32 j = 0; j < aProp.getLength(); j++ ) 2039 { 2040 if ( aProp[j].Name.equalsAscii( ITEM_DESCRIPTOR_COMMANDURL )) 2041 { 2042 aProp[j].Value >>= aCommandURL; 2043 } 2044 else if ( aProp[j].Name.equalsAscii( ITEM_DESCRIPTOR_VISIBLE )) 2045 { 2046 aProp[j].Value >>= bVisible; 2047 nVisibleIndex = j; 2048 } 2049 } 2050 2051 if (( aCommandURL == aCommand ) && ( nVisibleIndex >= 0 )) 2052 { 2053 // We have found the requested item, toggle the visible flag 2054 // and write back the configuration settings to the toolbar 2055 aProp[nVisibleIndex].Value = makeAny( !bVisible ); 2056 try 2057 { 2058 xItemContainer->replaceByIndex( i, makeAny( aProp )); 2059 xUIElementSettings->setSettings( Reference< XIndexAccess >( xItemContainer, UNO_QUERY )); 2060 Reference< XPropertySet > xPropSet( xUIElementSettings, UNO_QUERY ); 2061 if ( xPropSet.is() ) 2062 { 2063 Reference< XUIConfigurationPersistence > xUICfgMgr; 2064 if (( xPropSet->getPropertyValue( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("ConfigurationSource" ))) >>= xUICfgMgr ) && ( xUICfgMgr.is() )) 2065 xUICfgMgr->store(); 2066 } 2067 } 2068 catch ( Exception& ) 2069 { 2070 } 2071 2072 break; 2073 } 2074 } 2075 } 2076 } 2077 } 2078 } 2079 break; 2080 } 2081 } 2082 2083 // remove all entries - deactivate is not reliable 2084 // The method checks if we are already disposed and in that case does nothing! 2085 ImplClearPopupMenu( m_pToolBar ); 2086 } 2087 2088 return 1; 2089 } 2090 2091 IMPL_LINK( ToolBarManager, Select, ToolBox*, EMPTYARG ) 2092 { 2093 if ( m_bDisposed ) 2094 return 1; 2095 2096 sal_Int16 nKeyModifier( (sal_Int16)m_pToolBar->GetModifier() ); 2097 sal_uInt16 nId( m_pToolBar->GetCurItemId() ); 2098 2099 ToolBarControllerMap::const_iterator pIter = m_aControllerMap.find( nId ); 2100 if ( pIter != m_aControllerMap.end() ) 2101 { 2102 Reference< XToolbarController > xController( pIter->second, UNO_QUERY ); 2103 2104 if ( xController.is() ) 2105 xController->execute( nKeyModifier ); 2106 } 2107 2108 return 1; 2109 } 2110 2111 IMPL_LINK( ToolBarManager, Highlight, ToolBox*, EMPTYARG ) 2112 { 2113 return 1; 2114 } 2115 2116 IMPL_LINK( ToolBarManager, Activate, ToolBox*, EMPTYARG ) 2117 { 2118 return 1; 2119 } 2120 2121 IMPL_LINK( ToolBarManager, Deactivate, ToolBox*, EMPTYARG ) 2122 { 2123 return 1; 2124 } 2125 2126 IMPL_LINK( ToolBarManager, StateChanged, StateChangedType*, pStateChangedType ) 2127 { 2128 if ( m_bDisposed ) 2129 return 1; 2130 2131 if ( *pStateChangedType == STATE_CHANGE_CONTROLBACKGROUND ) 2132 { 2133 // Check if we need to get new images for normal/high contrast mode 2134 CheckAndUpdateImages(); 2135 } 2136 else if ( *pStateChangedType == STATE_CHANGE_VISIBLE ) 2137 { 2138 if ( m_pToolBar->IsReallyVisible() ) 2139 m_aAsyncUpdateControllersTimer.Start(); 2140 } 2141 else if ( *pStateChangedType == STATE_CHANGE_INITSHOW ) 2142 { 2143 m_aAsyncUpdateControllersTimer.Start(); 2144 } 2145 return 1; 2146 } 2147 2148 IMPL_LINK( ToolBarManager, DataChanged, DataChangedEvent*, pDataChangedEvent ) 2149 { 2150 if ((( pDataChangedEvent->GetType() == DATACHANGED_SETTINGS ) || 2151 ( pDataChangedEvent->GetType() == DATACHANGED_DISPLAY )) && 2152 ( pDataChangedEvent->GetFlags() & SETTINGS_STYLE )) 2153 { 2154 // Check if we need to get new images for normal/high contrast mode 2155 CheckAndUpdateImages(); 2156 } 2157 2158 for ( sal_uInt16 nPos = 0; nPos < m_pToolBar->GetItemCount(); ++nPos ) 2159 { 2160 const sal_uInt16 nId = m_pToolBar->GetItemId(nPos); 2161 Window* pWindow = m_pToolBar->GetItemWindow( nId ); 2162 if ( pWindow ) 2163 { 2164 const DataChangedEvent& rDCEvt( *pDataChangedEvent ); 2165 pWindow->DataChanged( rDCEvt ); 2166 } 2167 } 2168 2169 if ( !m_pToolBar->IsFloatingMode() && 2170 m_pToolBar->IsVisible() ) 2171 { 2172 // Resize toolbar, layout manager is resize listener and will calc 2173 // the layout automatically. 2174 ::Size aSize( m_pToolBar->CalcWindowSizePixel() ); 2175 m_pToolBar->SetOutputSizePixel( aSize ); 2176 } 2177 2178 return 1; 2179 } 2180 2181 IMPL_LINK( ToolBarManager, AsyncUpdateControllersHdl, Timer *, EMPTYARG ) 2182 { 2183 // The guard must be in its own context as the we can get destroyed when our 2184 // own xInterface reference get destroyed! 2185 Reference< XComponent > xThis( static_cast< OWeakObject* >(this), UNO_QUERY ); 2186 2187 ResetableGuard aGuard( m_aLock ); 2188 2189 if ( m_bDisposed ) 2190 return 1; 2191 2192 // Request to update our controllers 2193 m_aAsyncUpdateControllersTimer.Stop(); 2194 UpdateControllers(); 2195 2196 return 0; 2197 } 2198 2199 IMPL_STATIC_LINK_NOINSTANCE( ToolBarManager, ExecuteHdl_Impl, ExecuteInfo*, pExecuteInfo ) 2200 { 2201 try 2202 { 2203 // Asynchronous execution as this can lead to our own destruction! 2204 if (( pExecuteInfo->nCmd == EXEC_CMD_CLOSETOOLBAR ) && 2205 ( pExecuteInfo->xLayoutManager.is() ) && 2206 ( pExecuteInfo->xWindow.is() )) 2207 { 2208 // Use docking window close to close the toolbar. The layout manager is 2209 // listener and will react correctly according to the context sensitive 2210 // flag of our toolbar. 2211 Window* pWin = VCLUnoHelper::GetWindow( pExecuteInfo->xWindow ); 2212 DockingWindow* pDockWin = dynamic_cast< DockingWindow* >( pWin ); 2213 if ( pDockWin ) 2214 pDockWin->Close(); 2215 } 2216 else if (( pExecuteInfo->nCmd == EXEC_CMD_DOCKTOOLBAR ) && 2217 ( pExecuteInfo->xLayoutManager.is() )) 2218 { 2219 ::com::sun::star::awt::Point aPoint; 2220 aPoint.X = aPoint.Y = SAL_MAX_INT32; 2221 pExecuteInfo->xLayoutManager->dockWindow( pExecuteInfo->aToolbarResName, 2222 DockingArea_DOCKINGAREA_DEFAULT, 2223 aPoint ); 2224 } 2225 else if (( pExecuteInfo->nCmd == EXEC_CMD_DOCKALLTOOLBARS ) && 2226 ( pExecuteInfo->xLayoutManager.is() )) 2227 { 2228 pExecuteInfo->xLayoutManager->dockAllWindows( UIElementType::TOOLBAR ); 2229 } 2230 } 2231 catch ( Exception& ) 2232 { 2233 } 2234 2235 delete pExecuteInfo; 2236 return 0; 2237 } 2238 2239 Image ToolBarManager::QueryAddonsImage( const ::rtl::OUString& aCommandURL, bool bBigImages, bool bHiContrast ) 2240 { 2241 Image aImage = framework::AddonsOptions().GetImageFromURL( aCommandURL, bBigImages, bHiContrast ); 2242 return aImage; 2243 } 2244 2245 bool ToolBarManager::impl_RetrieveShortcutsFromConfiguration( 2246 const Reference< XAcceleratorConfiguration >& rAccelCfg, 2247 const rtl::OUString& rCommand, 2248 rtl::OUString& rShortCut ) 2249 { 2250 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "framework", "Ocke.Janssen@sun.com", "ToolBarManager::impl_RetrieveShortcutsFromConfiguration" ); 2251 if ( rAccelCfg.is() ) 2252 { 2253 try 2254 { 2255 com::sun::star::awt::KeyEvent aKeyEvent; 2256 Sequence< OUString > aCommands(1); 2257 aCommands[0] = rCommand; 2258 2259 Sequence< Any > aSeqKeyCode( rAccelCfg->getPreferredKeyEventsForCommandList( aCommands ) ); 2260 if( aSeqKeyCode.getLength() == 1 ) 2261 { 2262 if ( aSeqKeyCode[0] >>= aKeyEvent ) 2263 { 2264 rShortCut = svt::AcceleratorExecute::st_AWTKey2VCLKey( aKeyEvent ).GetName(); 2265 return true; 2266 } 2267 } 2268 } 2269 catch ( IllegalArgumentException& ) 2270 { 2271 } 2272 } 2273 2274 return false; 2275 } 2276 2277 bool ToolBarManager::RetrieveShortcut( const rtl::OUString& rCommandURL, rtl::OUString& rShortCut ) 2278 { 2279 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "framework", "Ocke.Janssen@sun.com", "ToolBarManager::RetrieveShortcuts" ); 2280 if ( m_bModuleIdentified ) 2281 { 2282 Reference< XAcceleratorConfiguration > xDocAccelCfg( m_xDocAcceleratorManager ); 2283 Reference< XAcceleratorConfiguration > xModuleAccelCfg( m_xModuleAcceleratorManager ); 2284 Reference< XAcceleratorConfiguration > xGlobalAccelCfg( m_xGlobalAcceleratorManager ); 2285 2286 if ( !m_bAcceleratorCfg ) 2287 { 2288 // Retrieve references on demand 2289 m_bAcceleratorCfg = sal_True; 2290 if ( !xDocAccelCfg.is() ) 2291 { 2292 Reference< XController > xController = m_xFrame->getController(); 2293 Reference< XModel > xModel; 2294 if ( xController.is() ) 2295 { 2296 xModel = xController->getModel(); 2297 if ( xModel.is() ) 2298 { 2299 Reference< XUIConfigurationManagerSupplier > xSupplier( xModel, UNO_QUERY ); 2300 if ( xSupplier.is() ) 2301 { 2302 Reference< XUIConfigurationManager > xDocUICfgMgr( xSupplier->getUIConfigurationManager(), UNO_QUERY ); 2303 if ( xDocUICfgMgr.is() ) 2304 { 2305 xDocAccelCfg = Reference< XAcceleratorConfiguration >( xDocUICfgMgr->getShortCutManager(), UNO_QUERY ); 2306 m_xDocAcceleratorManager = xDocAccelCfg; 2307 } 2308 } 2309 } 2310 } 2311 } 2312 2313 if ( !xModuleAccelCfg.is() ) 2314 { 2315 Reference< XModuleUIConfigurationManagerSupplier > xModuleCfgMgrSupplier( m_xServiceManager->createInstance( 2316 SERVICENAME_MODULEUICONFIGURATIONMANAGERSUPPLIER ), 2317 UNO_QUERY ); 2318 try 2319 { 2320 Reference< XUIConfigurationManager > xUICfgMgr = xModuleCfgMgrSupplier->getUIConfigurationManager( m_aModuleIdentifier ); 2321 if ( xUICfgMgr.is() ) 2322 { 2323 xModuleAccelCfg = Reference< XAcceleratorConfiguration >( xUICfgMgr->getShortCutManager(), UNO_QUERY ); 2324 m_xModuleAcceleratorManager = xModuleAccelCfg; 2325 } 2326 } 2327 catch ( RuntimeException& ) 2328 { 2329 throw; 2330 } 2331 catch ( Exception& ) 2332 { 2333 } 2334 } 2335 2336 if ( !xGlobalAccelCfg.is() ) 2337 { 2338 xGlobalAccelCfg = Reference< XAcceleratorConfiguration >( m_xServiceManager->createInstance( 2339 SERVICENAME_GLOBALACCELERATORCONFIGURATION ), 2340 UNO_QUERY ); 2341 m_xGlobalAcceleratorManager = xGlobalAccelCfg; 2342 } 2343 } 2344 2345 bool bFound = false; 2346 2347 if ( m_xGlobalAcceleratorManager.is() ) 2348 bFound = impl_RetrieveShortcutsFromConfiguration( xGlobalAccelCfg, rCommandURL, rShortCut ); 2349 if ( !bFound && m_xModuleAcceleratorManager.is() ) 2350 bFound = impl_RetrieveShortcutsFromConfiguration( xModuleAccelCfg, rCommandURL, rShortCut ); 2351 if ( !bFound && m_xDocAcceleratorManager.is() ) 2352 impl_RetrieveShortcutsFromConfiguration( xGlobalAccelCfg, rCommandURL, rShortCut ); 2353 2354 if( bFound ) 2355 return true; 2356 } 2357 return false; 2358 } 2359 2360 } 2361 2362 2363 2364