framework/source/uielement/statusbarmanager.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <uielement/statusbarmanager.hxx>
  21 #include <uielement/genericstatusbarcontroller.hxx>
  22
  23 #include <framework/sfxhelperfunctions.hxx>
  24 #include <framework/addonsoptions.hxx>
  25 #include <uielement/statusbarmerger.hxx>
  26 #include <uielement/statusbaritem.hxx>
  27 #include <macros/generic.hxx>
  28 #include <macros/xinterface.hxx>
  29 #include <macros/xtypeprovider.hxx>
  30 #include <stdtypes.h>
  31 #include "services.h"
  32 #include "general.h"
  33 #include "properties.h"
  34 #include <helper/mischelper.hxx>
  35
  36 #include <com/sun/star/frame/XFrame.hpp>
  37 #include <com/sun/star/frame/theStatusbarControllerFactory.hpp>
  38 #include <com/sun/star/ui/ItemStyle.hpp>
  39 #include <com/sun/star/ui/ItemType.hpp>
  40 #include <com/sun/star/lang/XMultiComponentFactory.hpp>
  41 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
  42 #include <com/sun/star/beans/XPropertySet.hpp>
  43 #include <com/sun/star/awt/Command.hpp>
  44 #include <com/sun/star/ui/XStatusbarItem.hdl>
  45 #include <comphelper/processfactory.hxx>
  46 #include <toolkit/helper/vclunohelper.hxx>
  47 #include <svtools/statusbarcontroller.hxx>
  48
  49 #include <vcl/status.hxx>
  50 #include <vcl/svapp.hxx>
  51 #include <vcl/settings.hxx>
  52
  53 #include <functional>
  54
  55 using namespace ::com::sun::star;
  56
  57 // Property names of a menu/menu item ItemDescriptor
  58 static const char ITEM_DESCRIPTOR_COMMANDURL[]  = "CommandURL";
  59 static const char ITEM_DESCRIPTOR_HELPURL[]     = "HelpURL";
  60 static const char ITEM_DESCRIPTOR_OFFSET[]      = "Offset";
  61 static const char ITEM_DESCRIPTOR_STYLE[]       = "Style";
  62 static const char ITEM_DESCRIPTOR_WIDTH[]       = "Width";
  63 static const char ITEM_DESCRIPTOR_TYPE[]        = "Type";
  64
  65 namespace framework
  66 {
  67
  68 namespace
  69 {
  70
  71 template< class MAP >
  72 struct lcl_UpdateController : public std::unary_function< typename MAP::value_type, void >
  73 {
  74     void operator()( typename MAP::value_type &rElement ) const
  75     {
  76         try
  77         {
  78             if ( rElement.second.is() )
  79                 rElement.second->update();
  80         }
  81         catch ( uno::Exception& )
  82         {
  83         }
  84     }
  85 };
  86
  87 template< class MAP >
  88 struct lcl_RemoveController : public std::unary_function< typename MAP::value_type, void >
  89 {
  90     void operator()( typename MAP::value_type &rElement ) const
  91     {
  92         try
  93         {
  94             if ( rElement.second.is() )
  95                 rElement.second->dispose();
  96         }
  97         catch ( uno::Exception& )
  98         {
  99         }
 100     }
 101 };
 102
 103 static sal_uInt16 impl_convertItemStyleToItemBits( sal_Int16 nStyle )
 104 {
 105     sal_uInt16 nItemBits( 0 );
 106
 107     if (( nStyle & ::com::sun::star::ui::ItemStyle::ALIGN_RIGHT ) == ::com::sun::star::ui::ItemStyle::ALIGN_RIGHT )
 108         nItemBits |= SIB_RIGHT;
 109     else if ( nStyle & ::com::sun::star::ui::ItemStyle::ALIGN_LEFT )
 110         nItemBits |= SIB_LEFT;
 111     else
 112         nItemBits |= SIB_CENTER;
 113
 114     if (( nStyle & ::com::sun::star::ui::ItemStyle::DRAW_FLAT ) == ::com::sun::star::ui::ItemStyle::DRAW_FLAT )
 115         nItemBits |= SIB_FLAT;
 116     else if ( nStyle & ::com::sun::star::ui::ItemStyle::DRAW_OUT3D )
 117         nItemBits |= SIB_OUT;
 118     else
 119         nItemBits |= SIB_IN;
 120
 121     if (( nStyle & ::com::sun::star::ui::ItemStyle::AUTO_SIZE ) == ::com::sun::star::ui::ItemStyle::AUTO_SIZE )
 122         nItemBits |= SIB_AUTOSIZE;
 123     if ( nStyle & ::com::sun::star::ui::ItemStyle::OWNER_DRAW )
 124         nItemBits |= SIB_USERDRAW;
 125
 126     return nItemBits;
 127 }
 128
 129 }
 130
 131 StatusBarManager::StatusBarManager(
 132     const uno::Reference< uno::XComponentContext >& rxContext,
 133     const uno::Reference< frame::XFrame >& rFrame,
 134     const OUString& rResourceName,
 135     StatusBar* pStatusBar ) :
 136     m_bDisposed( false ),
 137     m_bFrameActionRegistered( false ),
 138     m_bUpdateControllers( false ),
 139     m_bModuleIdentified( false ),
 140     m_pStatusBar( pStatusBar ),
 141     m_aResourceName( rResourceName ),
 142     m_xFrame( rFrame ),
 143     m_aListenerContainer( m_mutex ),
 144     m_xContext( rxContext )
 145 {
 146
 147     m_xStatusbarControllerFactory = frame::theStatusbarControllerFactory::get(
 148         ::comphelper::getProcessComponentContext());
 149
 150     m_pStatusBar->AdjustItemWidthsForHiDPI(true);
 151     m_pStatusBar->SetClickHdl( LINK( this, StatusBarManager, Click ) );
 152     m_pStatusBar->SetDoubleClickHdl( LINK( this, StatusBarManager, DoubleClick ) );
 153 }
 154
 155 StatusBarManager::~StatusBarManager()
 156 {
 157 }
 158
 159 StatusBar* StatusBarManager::GetStatusBar() const
 160 {
 161     SolarMutexGuard g;
 162     return m_pStatusBar;
 163 }
 164
 165 void StatusBarManager::frameAction( const frame::FrameActionEvent& Action )
 166 throw ( uno::RuntimeException, std::exception )
 167 {
 168     SolarMutexGuard g;
 169     if ( Action.Action == frame::FrameAction_CONTEXT_CHANGED )
 170         UpdateControllers();
 171 }
 172
 173 void SAL_CALL StatusBarManager::disposing( const lang::EventObject& Source ) throw ( uno::RuntimeException, std::exception )
 174 {
 175     {
 176         SolarMutexGuard g;
 177         if ( m_bDisposed )
 178             return;
 179     }
 180
 181     RemoveControllers();
 182
 183     {
 184         SolarMutexGuard g;
 185         if ( Source.Source == uno::Reference< uno::XInterface >( m_xFrame, uno::UNO_QUERY ))
 186             m_xFrame.clear();
 187
 188         m_xContext.clear();
 189     }
 190 }
 191
 192 // XComponent
 193 void SAL_CALL StatusBarManager::dispose() throw( uno::RuntimeException, std::exception )
 194 {
 195     uno::Reference< lang::XComponent > xThis(
 196         static_cast< OWeakObject* >(this), uno::UNO_QUERY );
 197
 198     lang::EventObject aEvent( xThis );
 199     m_aListenerContainer.disposeAndClear( aEvent );
 200
 201     {
 202         SolarMutexGuard g;
 203         if ( m_bDisposed )
 204             return;
 205
 206         RemoveControllers();
 207
 208         // destroy the item data
 209         for ( sal_uInt16 n = 0; n < m_pStatusBar->GetItemCount(); n++ )
 210         {
 211             AddonStatusbarItemData *pUserData = static_cast< AddonStatusbarItemData *>(
 212                 m_pStatusBar->GetItemData( m_pStatusBar->GetItemId( n ) ) );
 213             if ( pUserData )
 214                 delete pUserData;
 215         }
 216
 217         m_pStatusBar.disposeAndClear();
 218
 219         if ( m_bFrameActionRegistered && m_xFrame.is() )
 220         {
 221             try
 222             {
 223                 m_xFrame->removeFrameActionListener( uno::Reference< frame::XFrameActionListener >(
 224                                                         static_cast< ::cppu::OWeakObject *>( this ),
 225                                                         uno::UNO_QUERY ));
 226             }
 227             catch ( const uno::Exception& )
 228             {
 229             }
 230         }
 231
 232         m_xFrame.clear();
 233         m_xContext.clear();
 234
 235         m_bDisposed = true;
 236     }
 237 }
 238
 239 void SAL_CALL StatusBarManager::addEventListener( const uno::Reference< lang::XEventListener >& xListener ) throw( uno::RuntimeException, std::exception )
 240 {
 241     SolarMutexGuard g;
 242
 243     /* SAFE AREA ----------------------------------------------------------------------------------------------- */
 244     if ( m_bDisposed )
 245         throw lang::DisposedException();
 246
 247     m_aListenerContainer.addInterface( cppu::UnoType<lang::XEventListener>::get(), xListener );
 248 }
 249
 250 void SAL_CALL StatusBarManager::removeEventListener( const uno::Reference< lang::XEventListener >& xListener ) throw( uno::RuntimeException, std::exception )
 251 {
 252     m_aListenerContainer.removeInterface( cppu::UnoType<lang::XEventListener>::get(), xListener );
 253 }
 254
 255 // XUIConfigurationListener
 256 void SAL_CALL StatusBarManager::elementInserted( const css::ui::ConfigurationEvent& ) throw ( uno::RuntimeException, std::exception )
 257 {
 258     SolarMutexGuard g;
 259
 260     if ( m_bDisposed )
 261         return;
 262 }
 263
 264 void SAL_CALL StatusBarManager::elementRemoved( const css::ui::ConfigurationEvent& ) throw ( uno::RuntimeException, std::exception )
 265 {
 266     SolarMutexGuard g;
 267
 268     if ( m_bDisposed )
 269         return;
 270 }
 271
 272 void SAL_CALL StatusBarManager::elementReplaced( const css::ui::ConfigurationEvent& ) throw ( uno::RuntimeException, std::exception )
 273 {
 274     SolarMutexGuard g;
 275
 276     if ( m_bDisposed )
 277         return;
 278 }
 279
 280 void StatusBarManager::UpdateControllers()
 281 {
 282     if ( !m_bUpdateControllers )
 283     {
 284         m_bUpdateControllers = true;
 285         std::for_each( m_aControllerMap.begin(),
 286                        m_aControllerMap.end(),
 287                        lcl_UpdateController< StatusBarControllerMap >() );
 288     }
 289     m_bUpdateControllers = false;
 290 }
 291
 292 void StatusBarManager::RemoveControllers()
 293 {
 294     SolarMutexGuard g;
 295
 296     if ( m_bDisposed )
 297         return;
 298
 299     std::for_each( m_aControllerMap.begin(),
 300                    m_aControllerMap.end(),
 301                    lcl_RemoveController< StatusBarControllerMap >() );
 302     m_aControllerMap.clear();
 303 }
 304
 305 OUString StatusBarManager::RetrieveLabelFromCommand( const OUString& aCmdURL )
 306 {
 307     return framework::RetrieveLabelFromCommand(aCmdURL, m_xContext, m_xUICommandLabels,m_xFrame,m_aModuleIdentifier,m_bModuleIdentified,"Name");
 308 }
 309
 310 void StatusBarManager::CreateControllers()
 311 {
 312     uno::Reference< awt::XWindow > xStatusbarWindow = VCLUnoHelper::GetInterface( m_pStatusBar );
 313
 314     for ( sal_uInt16 i = 0; i < m_pStatusBar->GetItemCount(); i++ )
 315     {
 316         sal_uInt16 nId = m_pStatusBar->GetItemId( i );
 317         if ( nId == 0 )
 318             continue;
 319
 320         OUString aCommandURL( m_pStatusBar->GetItemCommand( nId ));
 321         bool bInit( true );
 322         uno::Reference< frame::XStatusbarController > xController;
 323         AddonStatusbarItemData *pItemData = static_cast< AddonStatusbarItemData *>( m_pStatusBar->GetItemData( nId ) );
 324         uno::Reference< ui::XStatusbarItem > xStatusbarItem(
 325             static_cast< cppu::OWeakObject *>( new StatusbarItem( m_pStatusBar, pItemData, nId, aCommandURL ) ),
 326             uno::UNO_QUERY );
 327
 328         beans::PropertyValue aPropValue;
 329         std::vector< uno::Any > aPropVector;
 330
 331         aPropValue.Name     = "CommandURL";
 332         aPropValue.Value    <<= aCommandURL;
 333         aPropVector.push_back( uno::makeAny( aPropValue ) );
 334
 335         aPropValue.Name     = "ModuleIdentifier";
 336         aPropValue.Value    <<= m_aModuleIdentifier;
 337         aPropVector.push_back( uno::makeAny( aPropValue ) );
 338
 339         aPropValue.Name     = "Frame";
 340         aPropValue.Value    <<= m_xFrame;
 341         aPropVector.push_back( uno::makeAny( aPropValue ) );
 342
 343         // TODO remove this
 344         aPropValue.Name     = "ServiceManager";
 345         aPropValue.Value    = uno::makeAny( uno::Reference<lang::XMultiServiceFactory>(m_xContext->getServiceManager(), uno::UNO_QUERY_THROW) );
 346         aPropVector.push_back( uno::makeAny( aPropValue ) );
 347
 348         aPropValue.Name     = "ParentWindow";
 349         aPropValue.Value    <<= xStatusbarWindow;
 350         aPropVector.push_back( uno::makeAny( aPropValue ) );
 351
 352         // TODO still needing with the css::ui::XStatusbarItem?
 353         aPropValue.Name     = "Identifier";
 354         aPropValue.Value    <<= nId;
 355         aPropVector.push_back( uno::makeAny( aPropValue ) );
 356
 357         aPropValue.Name     = "StatusbarItem";
 358         aPropValue.Value    <<= xStatusbarItem;
 359         aPropVector.push_back( uno::makeAny( aPropValue ) );
 360
 361         uno::Sequence< uno::Any > aArgs( comphelper::containerToSequence( aPropVector ) );
 362
 363         // 1) UNO Statusbar controllers, registered in Controllers.xcu
 364         if ( m_xStatusbarControllerFactory.is() &&
 365              m_xStatusbarControllerFactory->hasController( aCommandURL, m_aModuleIdentifier ))
 366         {
 367             xController = uno::Reference< frame::XStatusbarController >(
 368                             m_xStatusbarControllerFactory->createInstanceWithArgumentsAndContext(
 369                                 aCommandURL, aArgs, m_xContext ),
 370                             uno::UNO_QUERY );
 371             bInit = false; // Initialization is done through the factory service
 372         }
 373
 374         if ( !xController.is() )
 375         {
 376             svt::StatusbarController* pController( 0 );
 377
 378             // 2) Old SFX2 Statusbar controllers
 379             pController = CreateStatusBarController( m_xFrame, m_pStatusBar, nId, aCommandURL );
 380             if ( !pController )
 381             {
 382                 // 3) Is Add-on? Generic statusbar controller
 383                 if ( pItemData )
 384                 {
 385                     pController = new GenericStatusbarController( m_xContext,
 386                                                                   m_xFrame,
 387                                                                   xStatusbarItem,
 388                                                                   pItemData );
 389                 }
 390                 else
 391                 {
 392                     // 4) Default Statusbar controller
 393                     pController = new svt::StatusbarController( m_xContext, m_xFrame, aCommandURL, nId );
 394                 }
 395             }
 396
 397             if ( pController )
 398                 xController = uno::Reference< frame::XStatusbarController >(
 399                                 static_cast< ::cppu::OWeakObject *>( pController ),
 400                                 uno::UNO_QUERY );
 401         }
 402
 403         m_aControllerMap[nId] = xController;
 404         if ( bInit )
 405         {
 406             xController->initialize( aArgs );
 407         }
 408     }
 409
 410     AddFrameActionListener();
 411 }
 412
 413 void StatusBarManager::AddFrameActionListener()
 414 {
 415     if ( !m_bFrameActionRegistered && m_xFrame.is() )
 416     {
 417         m_bFrameActionRegistered = true;
 418         m_xFrame->addFrameActionListener( uno::Reference< frame::XFrameActionListener >(
 419             static_cast< ::cppu::OWeakObject *>( this ), uno::UNO_QUERY ));
 420     }
 421 }
 422
 423 void StatusBarManager::FillStatusBar( const uno::Reference< container::XIndexAccess >& rItemContainer )
 424 {
 425     SolarMutexGuard g;
 426
 427     if ( m_bDisposed || !m_pStatusBar )
 428         return;
 429
 430     sal_uInt16         nId( 1 );
 431
 432     RemoveControllers();
 433
 434     // reset and fill command map
 435     m_pStatusBar->Clear();
 436     m_aControllerMap.clear();// TODO already done in RemoveControllers
 437
 438     for ( sal_Int32 n = 0; n < rItemContainer->getCount(); n++ )
 439     {
 440         uno::Sequence< beans::PropertyValue >   aProp;
 441         OUString                           aCommandURL;
 442         OUString                           aHelpURL;
 443         sal_Int16                               nOffset( 0 );
 444         sal_Int16                               nStyle( 0 );
 445         sal_Int16                               nWidth( 0 );
 446         sal_uInt16                              nType( ::com::sun::star::ui::ItemType::DEFAULT );
 447
 448         try
 449         {
 450             if ( rItemContainer->getByIndex( n ) >>= aProp )
 451             {
 452                 for ( int i = 0; i < aProp.getLength(); i++ )
 453                 {
 454                     if ( aProp[i].Name == ITEM_DESCRIPTOR_COMMANDURL )
 455                     {
 456                         aProp[i].Value >>= aCommandURL;
 457                     }
 458                     else if ( aProp[i].Name == ITEM_DESCRIPTOR_HELPURL )
 459                     {
 460                         aProp[i].Value >>= aHelpURL;
 461                     }
 462                     else if ( aProp[i].Name == ITEM_DESCRIPTOR_STYLE )
 463                     {
 464                         aProp[i].Value >>= nStyle;
 465                     }
 466                     else if ( aProp[i].Name == ITEM_DESCRIPTOR_TYPE )
 467                     {
 468                         aProp[i].Value >>= nType;
 469                     }
 470                     else if ( aProp[i].Name == ITEM_DESCRIPTOR_WIDTH )
 471                     {
 472                         aProp[i].Value >>= nWidth;
 473                     }
 474                     else if ( aProp[i].Name == ITEM_DESCRIPTOR_OFFSET )
 475                     {
 476                         aProp[i].Value >>= nOffset;
 477                     }
 478                 }
 479
 480                 if (( nType == ::com::sun::star::ui::ItemType::DEFAULT ) && !aCommandURL.isEmpty() )
 481                 {
 482                     OUString aString( RetrieveLabelFromCommand( aCommandURL ));
 483                     sal_uInt16        nItemBits( impl_convertItemStyleToItemBits( nStyle ));
 484
 485                     m_pStatusBar->InsertItem( nId, nWidth, nItemBits, nOffset );
 486                     m_pStatusBar->SetItemCommand( nId, aCommandURL );
 487                     m_pStatusBar->SetAccessibleName( nId, aString );
 488                     ++nId;
 489                 }
 490             }
 491         }
 492         catch ( const ::com::sun::star::lang::IndexOutOfBoundsException& )
 493         {
 494             break;
 495         }
 496     }
 497
 498     // Statusbar Merging
 499     const sal_uInt16 STATUSBAR_ITEM_STARTID = 1000;
 500     MergeStatusbarInstructionContainer aMergeInstructions = AddonsOptions().GetMergeStatusbarInstructions();
 501     if ( !aMergeInstructions.empty() )
 502     {
 503         const sal_uInt32 nCount = aMergeInstructions.size();
 504         sal_uInt16 nItemId( STATUSBAR_ITEM_STARTID );
 505
 506         for ( sal_uInt32 i = 0; i < nCount; i++ )
 507         {
 508             MergeStatusbarInstruction &rInstruction = aMergeInstructions[i];
 509             if ( !StatusbarMerger::IsCorrectContext( rInstruction.aMergeContext, m_aModuleIdentifier ) )
 510                 continue;
 511
 512             AddonStatusbarItemContainer aItems;
 513             StatusbarMerger::ConvertSeqSeqToVector( rInstruction.aMergeStatusbarItems, aItems );
 514
 515             sal_uInt16 nRefPos = StatusbarMerger::FindReferencePos( m_pStatusBar, rInstruction.aMergePoint );
 516             if ( nRefPos != STATUSBAR_ITEM_NOTFOUND )
 517             {
 518                 StatusbarMerger::ProcessMergeOperation( m_pStatusBar,
 519                                                         nRefPos,
 520                                                         nItemId,
 521                                                         m_aModuleIdentifier,
 522                                                         rInstruction.aMergeCommand,
 523                                                         rInstruction.aMergeCommandParameter,
 524                                                         aItems );
 525             }
 526             else
 527             {
 528                 StatusbarMerger::ProcessMergeFallback( m_pStatusBar,
 529                                                        nRefPos,
 530                                                        nItemId,
 531                                                        m_aModuleIdentifier,
 532                                                        rInstruction.aMergeCommand,
 533                                                        rInstruction.aMergeCommandParameter,
 534                                                        aItems );
 535             }
 536         }
 537     }
 538
 539     // Create controllers
 540     CreateControllers();
 541
 542     // Notify controllers that they are now correctly initialized and can start listening
 543     UpdateControllers();
 544 }
 545
 546 void StatusBarManager::DataChanged( const DataChangedEvent& rDCEvt )
 547 {
 548     SolarMutexClearableGuard aGuard;
 549
 550     if ((( rDCEvt.GetType() == DataChangedEventType::SETTINGS         ) ||
 551          ( rDCEvt.GetType() == DataChangedEventType::FONTS            ) ||
 552          ( rDCEvt.GetType() == DataChangedEventType::FONTSUBSTITUTION ) ||
 553          ( rDCEvt.GetType() == DataChangedEventType::DISPLAY          ))  &&
 554          ( rDCEvt.GetFlags() & AllSettingsFlags::STYLE               ))
 555     {
 556         css::uno::Reference< css::frame::XLayoutManager > xLayoutManager;
 557         css::uno::Reference< css::beans::XPropertySet > xPropSet( m_xFrame, css::uno::UNO_QUERY );
 558         if ( xPropSet.is() )
 559             xPropSet->getPropertyValue("LayoutManager") >>= xLayoutManager;
 560         if ( xLayoutManager.is() )
 561         {
 562             aGuard.clear();
 563             xLayoutManager->doLayout();
 564         }
 565     }
 566 }
 567
 568 void StatusBarManager::UserDraw( const UserDrawEvent& rUDEvt )
 569 {
 570     SolarMutexClearableGuard aGuard;
 571
 572     if ( m_bDisposed )
 573         return;
 574
 575     sal_uInt16 nId( rUDEvt.GetItemId() );
 576     StatusBarControllerMap::const_iterator it = m_aControllerMap.find( nId );
 577     if (( nId > 0 ) && ( it != m_aControllerMap.end() ))
 578     {
 579         uno::Reference< frame::XStatusbarController > xController( it->second );
 580         if (xController.is() && rUDEvt.GetRenderContext())
 581         {
 582             uno::Reference< awt::XGraphics > xGraphics = rUDEvt.GetRenderContext()->CreateUnoGraphics();
 583
 584             awt::Rectangle aRect( rUDEvt.GetRect().Left(),
 585                                   rUDEvt.GetRect().Top(),
 586                                   rUDEvt.GetRect().GetWidth(),
 587                                   rUDEvt.GetRect().GetHeight() );
 588             aGuard.clear();
 589             xController->paint( xGraphics, aRect, rUDEvt.GetStyle() );
 590         }
 591     }
 592 }
 593
 594 void StatusBarManager::Command( const CommandEvent& rEvt )
 595 {
 596     SolarMutexGuard g;
 597
 598     if ( m_bDisposed )
 599         return;
 600
 601     if ( rEvt.GetCommand() == CommandEventId::ContextMenu )
 602     {
 603         sal_uInt16 nId = m_pStatusBar->GetItemId( rEvt.GetMousePosPixel() );
 604         StatusBarControllerMap::const_iterator it = m_aControllerMap.find( nId );
 605         if (( nId > 0 ) && ( it != m_aControllerMap.end() ))
 606         {
 607             uno::Reference< frame::XStatusbarController > xController( it->second );
 608             if ( xController.is() )
 609             {
 610                 awt::Point aPos;
 611                 aPos.X = rEvt.GetMousePosPixel().X();
 612                 aPos.Y = rEvt.GetMousePosPixel().Y();
 613                 xController->command( aPos, awt::Command::CONTEXTMENU, sal_True, uno::Any() );
 614             }
 615         }
 616     }
 617 }
 618
 619 void StatusBarManager::MouseMove( const MouseEvent& rMEvt )
 620 {
 621     MouseButton(rMEvt,&frame::XStatusbarController::mouseMove);
 622 }
 623
 624 void StatusBarManager::MouseButton( const MouseEvent& rMEvt ,sal_Bool ( SAL_CALL frame::XStatusbarController::*_pMethod )(const ::com::sun::star::awt::MouseEvent&))
 625 {
 626     SolarMutexGuard g;
 627
 628     if ( !m_bDisposed )
 629     {
 630         sal_uInt16 nId = m_pStatusBar->GetItemId( rMEvt.GetPosPixel() );
 631         StatusBarControllerMap::const_iterator it = m_aControllerMap.find( nId );
 632         if (( nId > 0 ) && ( it != m_aControllerMap.end() ))
 633         {
 634             uno::Reference< frame::XStatusbarController > xController( it->second );
 635             if ( xController.is() )
 636             {
 637                 ::com::sun::star::awt::MouseEvent aMouseEvent;
 638                 aMouseEvent.Buttons = rMEvt.GetButtons();
 639                 aMouseEvent.X = rMEvt.GetPosPixel().X();
 640                 aMouseEvent.Y = rMEvt.GetPosPixel().Y();
 641                 aMouseEvent.ClickCount = rMEvt.GetClicks();
 642                 (xController.get()->*_pMethod)( aMouseEvent);
 643             }
 644         }
 645     }
 646 }
 647
 648 void StatusBarManager::MouseButtonDown( const MouseEvent& rMEvt )
 649 {
 650     MouseButton(rMEvt,&frame::XStatusbarController::mouseButtonDown);
 651 }
 652
 653 void StatusBarManager::MouseButtonUp( const MouseEvent& rMEvt )
 654 {
 655     MouseButton(rMEvt,&frame::XStatusbarController::mouseButtonUp);
 656 }
 657
 658 IMPL_LINK_NOARG(StatusBarManager, Click)
 659 {
 660     SolarMutexGuard g;
 661
 662     if ( m_bDisposed )
 663         return 1;
 664
 665     sal_uInt16 nId = m_pStatusBar->GetCurItemId();
 666     StatusBarControllerMap::const_iterator it = m_aControllerMap.find( nId );
 667     if (( nId > 0 ) && ( it != m_aControllerMap.end() ))
 668     {
 669         uno::Reference< frame::XStatusbarController > xController( it->second );
 670         if ( xController.is() )
 671         {
 672             const Point aVCLPos = m_pStatusBar->GetPointerPosPixel();
 673             const awt::Point aAWTPoint( aVCLPos.X(), aVCLPos.Y() );
 674             xController->click( aAWTPoint );
 675         }
 676     }
 677
 678     return 1;
 679 }
 680
 681 IMPL_LINK_NOARG(StatusBarManager, DoubleClick)
 682 {
 683     SolarMutexGuard g;
 684
 685     if ( m_bDisposed )
 686         return 1;
 687
 688     sal_uInt16 nId = m_pStatusBar->GetCurItemId();
 689     StatusBarControllerMap::const_iterator it = m_aControllerMap.find( nId );
 690     if (( nId > 0 ) && ( it != m_aControllerMap.end() ))
 691     {
 692         uno::Reference< frame::XStatusbarController > xController( it->second );
 693         if ( xController.is() )
 694         {
 695             const Point aVCLPos = m_pStatusBar->GetPointerPosPixel();
 696             const awt::Point aAWTPoint( aVCLPos.X(), aVCLPos.Y() );
 697             xController->doubleClick( aAWTPoint );
 698         }
 699     }
 700
 701     return 1;
 702 }
 703
 704 }
 705
 706 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */