sfx2/source/statbar/stbitem.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: stbitem.cxx,v $
  10  * $Revision: 1.16 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_sfx2.hxx"
  33 #include <svtools/stritem.hxx>
  34 #ifndef GCC
  35 #endif
  36 #include <com/sun/star/util/URL.hpp>
  37 #include <com/sun/star/util/XURLTransformer.hpp>
  38 #include <com/sun/star/frame/XController.hpp>
  39 #include <com/sun/star/lang/XUnoTunnel.hpp>
  40 #include <com/sun/star/frame/status/ItemStatus.hpp>
  41 #include <com/sun/star/frame/status/ItemState.hpp>
  42 #include <com/sun/star/awt/MouseButton.hpp>
  43
  44 #include <vcl/status.hxx>
  45
  46 #include <sfx2/app.hxx>
  47 #include "stbitem.hxx"
  48 #include "sfxtypes.hxx"
  49 #include <sfx2/msg.hxx>
  50 #include "arrdecl.hxx"
  51 #include <sfx2/bindings.hxx>
  52 #include <sfx2/msgpool.hxx>
  53 #include <sfx2/module.hxx>
  54 #include <sfx2/dispatch.hxx>
  55 #include <sfx2/unoctitm.hxx>
  56 #include <sfx2/objsh.hxx>
  57 #include <sfx2/sfx.hrc>
  58
  59 #include <comphelper/processfactory.hxx>
  60 #include <svtools/eitem.hxx>
  61 #include <svtools/stritem.hxx>
  62 #include <svtools/intitem.hxx>
  63 #ifndef _TOOLKIT_HELPER_VCLUNOHELPER_HXX_
  64 #include <toolkit/unohlp.hxx>
  65 #endif
  66 #include <toolkit/helper/convert.hxx>
  67
  68 using namespace ::com::sun::star;
  69
  70 //--------------------------------------------------------------------
  71
  72 USHORT SfxStatusBarControl::convertAwtToVCLMouseButtons( sal_Int16 nAwtMouseButtons )
  73 {
  74     USHORT nVCLMouseButtons( 0 );
  75
  76     if ( nAwtMouseButtons & awt::MouseButton::LEFT )
  77         nVCLMouseButtons |= MOUSE_LEFT;
  78     if ( nAwtMouseButtons & awt::MouseButton::RIGHT )
  79         nVCLMouseButtons |= MOUSE_RIGHT;
  80     if ( nAwtMouseButtons & awt::MouseButton::MIDDLE )
  81         nVCLMouseButtons |= MOUSE_MIDDLE;
  82
  83     return nVCLMouseButtons;
  84 }
  85
  86 //--------------------------------------------------------------------
  87
  88 svt::StatusbarController* SAL_CALL SfxStatusBarControllerFactory(
  89     const uno::Reference< frame::XFrame >& rFrame,
  90     StatusBar* pStatusBar,
  91     unsigned short nID,
  92     const ::rtl::OUString& aCommandURL )
  93 {
  94     ::vos::OGuard aGuard( Application::GetSolarMutex() );
  95
  96     util::URL aTargetURL;
  97     aTargetURL.Complete = aCommandURL;
  98     uno::Reference < util::XURLTransformer > xTrans( ::comphelper::getProcessServiceFactory()->createInstance(
  99         rtl::OUString::createFromAscii( "com.sun.star.util.URLTransformer" )), uno::UNO_QUERY );
 100     xTrans->parseStrict( aTargetURL );
 101
 102     SfxObjectShell* pObjShell = NULL;
 103     uno::Reference < frame::XController > xController;
 104     uno::Reference < frame::XModel > xModel;
 105     if ( rFrame.is() )
 106     {
 107         xController = rFrame->getController();
 108         if ( xController.is() )
 109             xModel = xController->getModel();
 110     }
 111
 112     if ( xModel.is() )
 113     {
 114         // Get tunnel from model to retrieve the SfxObjectShell pointer from it
 115         ::com::sun::star::uno::Reference < ::com::sun::star::lang::XUnoTunnel > xObj( xModel, uno::UNO_QUERY );
 116         ::com::sun::star::uno::Sequence < sal_Int8 > aSeq = SvGlobalName( SFX_GLOBAL_CLASSID ).GetByteSequence();
 117         if ( xObj.is() )
 118         {
 119             sal_Int64 nHandle = xObj->getSomething( aSeq );
 120             if ( nHandle )
 121                         pObjShell = reinterpret_cast< SfxObjectShell* >( sal::static_int_cast< sal_IntPtr >( nHandle ));
 122         }
 123     }
 124
 125     SfxModule*     pModule   = pObjShell ? pObjShell->GetModule() : NULL;
 126     SfxSlotPool*   pSlotPool = 0;
 127
 128     if ( pModule )
 129         pSlotPool = pModule->GetSlotPool();
 130     else
 131         pSlotPool = &(SfxSlotPool::GetSlotPool( NULL ));
 132
 133     const SfxSlot* pSlot = pSlotPool->GetUnoSlot( aTargetURL.Path );
 134     if ( pSlot )
 135     {
 136         USHORT nSlotId = pSlot->GetSlotId();
 137         if ( nSlotId > 0 )
 138             return SfxStatusBarControl::CreateControl( nSlotId, nID, pStatusBar, pModule );
 139     }
 140
 141     return NULL;
 142 }
 143
 144 //--------------------------------------------------------------------
 145
 146 SfxStatusBarControl::SfxStatusBarControl
 147 (
 148     USHORT              nSlotID,                        /* Slot-Id, mit der diese Instanz
 149                                        verbunden wird. Wurde bei der
 150                                        Registrierung eine Slot-Id != 0
 151                                        angegeben, ist dies immer die dort
 152                                        angegebene. */
 153     USHORT      nCtrlID,            /* ID of this controller in the status bar */
 154
 155     StatusBar&  rBar                            /* Referenz auf die StatusBar, f"ur die
 156                                        dieses Control erzeugt wurde. */
 157 )
 158
 159 /*      [Beschreibung]
 160
 161     Konstruktor der Klasse SfxStatusBarControl. Die Subclasses werden
 162     bei Bedarf per Factory vom SFx erzeugt.
 163
 164     Instanzen dieser Basisklasse werden f"ur alle StatusBar-Felder
 165     erzeugt, f"ur die keine speziellen registriert wurden.
 166 */
 167
 168 :   svt::StatusbarController(),
 169     nSlotId( nSlotID ),
 170     nId( nCtrlID ),
 171     pBar( &rBar )
 172 {
 173 }
 174
 175 //--------------------------------------------------------------------
 176
 177 SfxStatusBarControl::~SfxStatusBarControl()
 178
 179 /*      [Beschreibung]
 180
 181     Destruktor der Klasse SfxStatusBarControl. Die Instanzen dieser
 182     Klasse und deren Subklassen werden vom SFx zerst"ort.
 183 */
 184
 185 {}
 186
 187 //--------------------------------------------------------------------
 188 // XInterface
 189 uno::Any SAL_CALL SfxStatusBarControl::queryInterface( const uno::Type & rType )
 190 throw( uno::RuntimeException)
 191 {
 192     return svt::StatusbarController::queryInterface( rType );
 193 }
 194
 195 void SAL_CALL SfxStatusBarControl::acquire() throw()
 196 {
 197     OWeakObject::acquire();
 198 }
 199
 200 void SAL_CALL SfxStatusBarControl::release() throw()
 201 {
 202     OWeakObject::release();
 203 }
 204
 205 //--------------------------------------------------------------------
 206 // XEventListener
 207 void SAL_CALL SfxStatusBarControl::disposing( const lang::EventObject& aEvent )
 208 throw( uno::RuntimeException )
 209 {
 210     svt::StatusbarController::disposing( aEvent );
 211 }
 212
 213 //--------------------------------------------------------------------
 214 // XComponent
 215 void SAL_CALL SfxStatusBarControl::dispose()
 216 throw (uno::RuntimeException)
 217 {
 218     svt::StatusbarController::dispose();
 219 }
 220
 221 //--------------------------------------------------------------------
 222 // XStatusListener
 223 void SAL_CALL SfxStatusBarControl::statusChanged( const frame::FeatureStateEvent& rEvent )
 224 throw ( ::com::sun::star::uno::RuntimeException )
 225 {
 226     SfxViewFrame* pViewFrame = NULL;
 227     uno::Reference < frame::XController > xController;
 228
 229     ::vos::OGuard aGuard( Application::GetSolarMutex() );
 230     if ( m_xFrame.is() )
 231         xController = m_xFrame->getController();
 232
 233     uno::Reference < frame::XDispatchProvider > xProvider( xController, uno::UNO_QUERY );
 234     if ( xProvider.is() )
 235     {
 236         uno::Reference < frame::XDispatch > xDisp = xProvider->queryDispatch( rEvent.FeatureURL, ::rtl::OUString(), 0 );
 237         if ( xDisp.is() )
 238         {
 239             uno::Reference< lang::XUnoTunnel > xTunnel( xDisp, uno::UNO_QUERY );
 240             SfxOfficeDispatch* pDisp = NULL;
 241             if ( xTunnel.is() )
 242             {
 243                 sal_Int64 nImplementation = xTunnel->getSomething(SfxOfficeDispatch::impl_getStaticIdentifier());
 244                 pDisp = reinterpret_cast< SfxOfficeDispatch* >(sal::static_int_cast< sal_IntPtr >( nImplementation ));
 245             }
 246
 247             if ( pDisp )
 248                 pViewFrame = pDisp->GetDispatcher_Impl()->GetFrame();
 249         }
 250     }
 251
 252     USHORT nSlotID = 0;
 253     SfxSlotPool& rPool = SfxSlotPool::GetSlotPool( pViewFrame );
 254     const SfxSlot* pSlot = rPool.GetUnoSlot( rEvent.FeatureURL.Path );
 255     if ( pSlot )
 256         nSlotID = pSlot->GetSlotId();
 257
 258     if ( nSlotID > 0 )
 259     {
 260         if ( rEvent.Requery )
 261             svt::StatusbarController::statusChanged( rEvent );
 262         else
 263         {
 264             SfxItemState eState = SFX_ITEM_DISABLED;
 265             SfxPoolItem* pItem = NULL;
 266             if ( rEvent.IsEnabled )
 267             {
 268                 eState = SFX_ITEM_AVAILABLE;
 269                 uno::Type pType = rEvent.State.getValueType();
 270
 271                 if ( pType == ::getVoidCppuType() )
 272                 {
 273                     pItem = new SfxVoidItem( nSlotID );
 274                     eState = SFX_ITEM_UNKNOWN;
 275                 }
 276                 else if ( pType == ::getBooleanCppuType() )
 277                 {
 278                     sal_Bool bTemp = 0;
 279                     rEvent.State >>= bTemp ;
 280                     pItem = new SfxBoolItem( nSlotID, bTemp );
 281                 }
 282                 else if ( pType == ::getCppuType((const sal_uInt16*)0) )
 283                 {
 284                     sal_uInt16 nTemp = 0;
 285                     rEvent.State >>= nTemp ;
 286                     pItem = new SfxUInt16Item( nSlotID, nTemp );
 287                 }
 288                 else if ( pType == ::getCppuType((const sal_uInt32*)0) )
 289                 {
 290                     sal_uInt32 nTemp = 0;
 291                     rEvent.State >>= nTemp ;
 292                     pItem = new SfxUInt32Item( nSlotID, nTemp );
 293                 }
 294                 else if ( pType == ::getCppuType((const ::rtl::OUString*)0) )
 295                 {
 296                     ::rtl::OUString sTemp ;
 297                     rEvent.State >>= sTemp ;
 298                     pItem = new SfxStringItem( nSlotID, sTemp );
 299                 }
 300                 else if ( pType == ::getCppuType((const ::com::sun::star::frame::status::ItemStatus*)0) )
 301                 {
 302                     frame::status::ItemStatus aItemStatus;
 303                     rEvent.State >>= aItemStatus;
 304                     eState = aItemStatus.State;
 305                     pItem = new SfxVoidItem( nSlotID );
 306                 }
 307                 else
 308                 {
 309                     if ( pSlot )
 310                         pItem = pSlot->GetType()->CreateItem();
 311                     if ( pItem )
 312                     {
 313                         pItem->SetWhich( nSlotID );
 314                         pItem->PutValue( rEvent.State );
 315                     }
 316                     else
 317                         pItem = new SfxVoidItem( nSlotID );
 318                 }
 319             }
 320
 321             StateChanged( nSlotID, eState, pItem );
 322             delete pItem;
 323         }
 324     }
 325 }
 326
 327 //--------------------------------------------------------------------
 328 // XStatusbarController
 329
 330 ::sal_Bool SAL_CALL SfxStatusBarControl::mouseButtonDown(
 331     const awt::MouseEvent& rMouseEvent )
 332 throw ( uno::RuntimeException )
 333 {
 334     ::vos::OGuard aGuard( Application::GetSolarMutex() );
 335     ::Point aPos( rMouseEvent.X, rMouseEvent.Y );
 336
 337     ::MouseEvent aMouseEvent( aPos,
 338                               (USHORT)rMouseEvent.ClickCount,
 339                               0,
 340                               convertAwtToVCLMouseButtons( rMouseEvent.Buttons ),
 341                               0 );
 342
 343     return MouseButtonDown( aMouseEvent );
 344 }
 345
 346 //--------------------------------------------------------------------
 347
 348 ::sal_Bool SAL_CALL SfxStatusBarControl::mouseMove(
 349     const awt::MouseEvent& rMouseEvent )
 350 throw (uno::RuntimeException)
 351 {
 352     ::vos::OGuard aGuard( Application::GetSolarMutex() );
 353     ::Point aPos( rMouseEvent.X, rMouseEvent.Y );
 354
 355     ::MouseEvent aMouseEvent( aPos,
 356                               (USHORT)rMouseEvent.ClickCount,
 357                               0,
 358                               convertAwtToVCLMouseButtons( rMouseEvent.Buttons ),
 359                               0 );
 360     return MouseMove( aMouseEvent );
 361 }
 362
 363 //--------------------------------------------------------------------
 364
 365 ::sal_Bool SAL_CALL SfxStatusBarControl::mouseButtonUp(
 366     const ::awt::MouseEvent& rMouseEvent )
 367 throw ( uno::RuntimeException )
 368 {
 369     ::vos::OGuard aGuard( Application::GetSolarMutex() );
 370     ::Point aPos( rMouseEvent.X, rMouseEvent.Y );
 371
 372     ::MouseEvent aMouseEvent( aPos,
 373                               (USHORT)rMouseEvent.ClickCount,
 374                               0,
 375                               convertAwtToVCLMouseButtons( rMouseEvent.Buttons ),
 376                               0 );
 377     return MouseButtonUp( aMouseEvent );
 378 }
 379
 380 //--------------------------------------------------------------------
 381
 382 void SAL_CALL SfxStatusBarControl::command(
 383     const awt::Point& rPos,
 384     ::sal_Int32 nCommand,
 385     ::sal_Bool /*bMouseEvent*/,
 386     const ::com::sun::star::uno::Any& /*aData*/ )
 387 throw (::com::sun::star::uno::RuntimeException)
 388 {
 389     ::vos::OGuard aGuard( Application::GetSolarMutex() );
 390     ::Point aPos( rPos.X, rPos.Y );
 391     CommandEvent aCmdEvent( aPos, (USHORT)nCommand, TRUE, NULL );
 392
 393     Command( aCmdEvent );
 394 }
 395
 396 //--------------------------------------------------------------------
 397
 398 void SAL_CALL SfxStatusBarControl::paint(
 399     const uno::Reference< awt::XGraphics >& xGraphics,
 400     const awt::Rectangle& rOutputRectangle,
 401     ::sal_Int32 nItemId,
 402     ::sal_Int32 nStyle )
 403 throw ( ::uno::RuntimeException )
 404 {
 405     ::vos::OGuard aGuard( Application::GetSolarMutex() );
 406
 407     OutputDevice* pOutDev = VCLUnoHelper::GetOutputDevice( xGraphics );;
 408     if ( pOutDev )
 409     {
 410         ::Rectangle aRect = VCLRectangle( rOutputRectangle );
 411         UserDrawEvent aUserDrawEvent( pOutDev, aRect, (USHORT)nItemId, (USHORT)nStyle );
 412         Paint( aUserDrawEvent );
 413     }
 414 }
 415
 416 //--------------------------------------------------------------------
 417
 418 void SAL_CALL SfxStatusBarControl::click()
 419 throw ( uno::RuntimeException )
 420 {
 421     ::vos::OGuard aGuard( Application::GetSolarMutex() );
 422     Click();
 423 }
 424
 425 //--------------------------------------------------------------------
 426
 427 void SAL_CALL SfxStatusBarControl::doubleClick()
 428 throw ( uno::RuntimeException )
 429 {
 430     ::vos::OGuard aGuard( Application::GetSolarMutex() );
 431     DoubleClick();
 432 }
 433
 434 //--------------------------------------------------------------------
 435 // old sfx2 interface
 436 //--------------------------------------------------------------------
 437
 438 void SfxStatusBarControl::StateChanged
 439 (
 440     USHORT                              nSID,
 441     SfxItemState                eState,
 442     const SfxPoolItem*  pState  /* Zeiger auf ein SfxPoolItem, welches nur
 443                                    innerhalb dieses Methodenaufrufs g"ultig
 444                                    ist. Es kann ein 0-Pointer, ein Pointer
 445                                    auf ein SfxVoidItem oder auf den Typ, f"ur
 446                                    den die Subclass von SfxStatusBarControl
 447                                    registriert ist vorkommen. */
 448 )
 449
 450 /*      [Beschreibung]
 451
 452     Die Basisimplementation versteht Items vom Type SfxStringItem, bei
 453     denen der Text in das Status-Zeilen-Feld eingetragen wird und
 454     SfxVoidItem, bei denen das Feld geleert wird. Die Basisimplementierng
 455     sollte in "uberladenen Methoden nicht gerufen werden.
 456 */
 457
 458 {
 459     DBG_MEMTEST();
 460     DBG_ASSERT( pBar != 0, "setting state to dangling StatusBar" );
 461
 462     const SfxStringItem* pStr = PTR_CAST( SfxStringItem, pState );
 463     if ( eState == SFX_ITEM_AVAILABLE && pStr )
 464         pBar->SetItemText( nSID, pStr->GetValue() );
 465     else
 466     {
 467         DBG_ASSERT( eState != SFX_ITEM_AVAILABLE || pState->ISA(SfxVoidItem),
 468                     "wrong SfxPoolItem subclass in SfxStatusBarControl" );
 469         pBar->SetItemText( nSID, String() );
 470     }
 471 }
 472
 473 //--------------------------------------------------------------------
 474
 475 BOOL SfxStatusBarControl::MouseButtonDown( const MouseEvent & )
 476
 477 /*      [Beschreibung]
 478
 479     Diese virtuelle Methode ist eine Weiterleitung des Events
 480     MouseButtonDown() der StatusBar, falls die Maus-Position innerhalb
 481     des Bereichs des betreffenden Items ist, oder die Maus von diesem
 482     Control mit <SfxStatusBarControl::CaptureMouse()> gecaptured wurde.
 483
 484     Die Defaultimplementierung ist leer und gibt FALSE zur"uck.
 485
 486
 487     [Rueckgabewert]
 488
 489     BOOL                                TRUE
 490                         das Event wurde bearbeitet und soll nicht an
 491                         die StatusBar weitergeleitet werden
 492
 493                         FALSE
 494                         das Event wurde nicht bearbeitet und soll an
 495                         die StatusBar weitergeleitet werden
 496 */
 497
 498 {
 499     return FALSE;
 500 }
 501
 502 //--------------------------------------------------------------------
 503
 504 BOOL SfxStatusBarControl::MouseMove( const MouseEvent & )
 505
 506 /*      [Beschreibung]
 507
 508     Diese virtuelle Methode ist eine Weiterleitung des Events
 509     MouseMove() der StatusBar, falls die Maus-Position innerhalb
 510     des Bereichs des betreffenden Items ist, oder die Maus von diesem
 511     Control mit <SfxStatusBarControl::CaptureMouse()> gecaptured wurde.
 512
 513     Die Defaultimplementierung ist leer und gibt FALSE zur"uck.
 514
 515
 516     [Rueckgabewert]
 517
 518     BOOL                                TRUE
 519                         das Event wurde bearbeitet und soll nicht an
 520                         die StatusBar weitergeleitet werden
 521
 522                         FALSE
 523                         das Event wurde nicht bearbeitet und soll an
 524                         die StatusBar weitergeleitet werden
 525 */
 526
 527 {
 528     return FALSE;
 529 }
 530
 531 //--------------------------------------------------------------------
 532
 533 BOOL SfxStatusBarControl::MouseButtonUp( const MouseEvent & )
 534
 535 /*      [Beschreibung]
 536
 537     Diese virtuelle Methode ist eine Weiterleitung des Events
 538     MouseButtonUp() der StatusBar, falls die Maus-Position innerhalb
 539     des Bereichs des betreffenden Items ist, oder die Maus von diesem
 540     Control mit <SfxStatusBarControl::CaptureMouse()> gecaptured wurde.
 541
 542     Die Defaultimplementierung ist leer und gibt FALSE zur"uck.
 543
 544
 545     [Rueckgabewert]
 546
 547     BOOL                                TRUE
 548                         das Event wurde bearbeitet und soll nicht an
 549                         die StatusBar weitergeleitet werden
 550
 551                         FALSE
 552                         das Event wurde nicht bearbeitet und soll an
 553                         die StatusBar weitergeleitet werden
 554 */
 555
 556 {
 557     return FALSE;
 558 }
 559
 560 //--------------------------------------------------------------------
 561
 562 void SfxStatusBarControl::Command( const CommandEvent& )
 563
 564 /*      [Beschreibung]
 565
 566     Diese virtuelle Methode wird gerufen, wenn f"ur dieses SfxStatusBarControl
 567     ein CommandEvent f"ur erkannt wurde.
 568
 569     Die Defaultimplementierung ist leer.
 570 */
 571
 572 {
 573 }
 574
 575 //--------------------------------------------------------------------
 576
 577 void SfxStatusBarControl::Click()
 578
 579 /*      [Beschreibung]
 580
 581     Diese virtuelle Methode wird gerufen, wenn der Anwender mit der Maus
 582     in das zu diesem Control geh"orige Feld der Statuszeile klickt.
 583
 584     Die Defaultimplementierung ist leer.
 585 */
 586
 587 {
 588 }
 589
 590 //--------------------------------------------------------------------
 591
 592 void SfxStatusBarControl::DoubleClick()
 593
 594 /*  [Beschreibung]
 595
 596     Diese virtuelle Methode wird gerufen, wenn der Anwender mit der Maus
 597     in das zu diesem Control geh"orige Feld der Statuszeile doppel-klickt.
 598 */
 599
 600 {
 601     ::com::sun::star::uno::Sequence< ::com::sun::star::beans::PropertyValue > aArgs;
 602     execute( aArgs );
 603 }
 604
 605 //--------------------------------------------------------------------
 606
 607 void SfxStatusBarControl::Paint
 608 (
 609     const UserDrawEvent& /* Referenz auf einen UserDrawEvent */
 610 )
 611
 612 /*  [Beschreibung]
 613
 614     Diese virtuelle Methode wird gerufen, falls das betreffende Feld
 615     mit SIB_USERDRAW gekennzeichnet ist, um den Inhalt zu zeichnen.
 616     Die Ausgabe mu"s auf dem in durch rUDEvt.GetDevice() erh"altlichen
 617     OutputDevice innerhalb des durch rUDEvt.GetRect() angegebenenen
 618     Rechtecks erfolgen.
 619
 620     Die Defaultimplementierung ist leer.
 621 */
 622
 623 {
 624 }
 625
 626 //--------------------------------------------------------------------
 627
 628 void SfxStatusBarControl::CaptureMouse()
 629 {
 630 }
 631
 632 //--------------------------------------------------------------------
 633
 634 void SfxStatusBarControl::ReleaseMouse()
 635 {
 636 }
 637
 638 //--------------------------------------------------------------------
 639
 640 SfxStatusBarControl* SfxStatusBarControl::CreateControl
 641 (
 642     USHORT     nSlotID,
 643     USHORT     nStbId,
 644     StatusBar* pBar,
 645     SfxModule* pMod
 646 )
 647 {
 648     ::vos::OGuard aGuard( Application::GetSolarMutex() );
 649     SfxApplication *pApp = SFX_APP();
 650
 651     SfxSlotPool *pSlotPool;
 652     if ( pMod )
 653         pSlotPool = pMod->GetSlotPool();
 654     else
 655         pSlotPool = &SfxSlotPool::GetSlotPool();
 656
 657     TypeId aSlotType = pSlotPool->GetSlotType(nSlotID);
 658     if ( aSlotType )
 659     {
 660         if ( pMod )
 661         {
 662             SfxStbCtrlFactArr_Impl *pFactories = pMod->GetStbCtrlFactories_Impl();
 663             if ( pFactories )
 664             {
 665                 SfxStbCtrlFactArr_Impl &rFactories = *pFactories;
 666                 for ( USHORT nFactory = 0; nFactory < rFactories.Count(); ++nFactory )
 667                 if ( rFactories[nFactory]->nTypeId == aSlotType &&
 668                      ( ( rFactories[nFactory]->nSlotId == 0 ) ||
 669                      ( rFactories[nFactory]->nSlotId == nSlotID) ) )
 670                     return rFactories[nFactory]->pCtor( nSlotID, nStbId, *pBar );
 671             }
 672         }
 673
 674         SfxStbCtrlFactArr_Impl &rFactories = pApp->GetStbCtrlFactories_Impl();
 675         for ( USHORT nFactory = 0; nFactory < rFactories.Count(); ++nFactory )
 676         if ( rFactories[nFactory]->nTypeId == aSlotType &&
 677              ( ( rFactories[nFactory]->nSlotId == 0 ) ||
 678              ( rFactories[nFactory]->nSlotId == nSlotID) ) )
 679             return rFactories[nFactory]->pCtor( nSlotID, nStbId, *pBar );
 680     }
 681
 682     return NULL;
 683 }
 684
 685 //--------------------------------------------------------------------
 686 void SfxStatusBarControl::RegisterStatusBarControl(SfxModule* pMod, SfxStbCtrlFactory* pFact)
 687 {
 688     SFX_APP()->RegisterStatusBarControl_Impl( pMod, pFact );
 689 }
 690 //--------------------------------------------------------------------