sfx2/source/statbar/stbitem.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 <svl/stritem.hxx>
  21 #include <com/sun/star/util/URL.hpp>
  22 #include <com/sun/star/util/URLTransformer.hpp>
  23 #include <com/sun/star/util/XURLTransformer.hpp>
  24 #include <com/sun/star/frame/XController.hpp>
  25 #include <com/sun/star/lang/XUnoTunnel.hpp>
  26 #include <com/sun/star/frame/status/ItemStatus.hpp>
  27 #include <com/sun/star/frame/status/ItemState.hpp>
  28 #include <com/sun/star/awt/MouseButton.hpp>
  29
  30 #include <vcl/status.hxx>
  31
  32 #include <sfx2/app.hxx>
  33 #include "sfx2/stbitem.hxx"
  34 #include "sfxtypes.hxx"
  35 #include <sfx2/msg.hxx>
  36 #include "arrdecl.hxx"
  37 #include <sfx2/bindings.hxx>
  38 #include <sfx2/msgpool.hxx>
  39 #include <sfx2/module.hxx>
  40 #include <sfx2/dispatch.hxx>
  41 #include <sfx2/unoctitm.hxx>
  42 #include <sfx2/objsh.hxx>
  43 #include <sfx2/sfx.hrc>
  44
  45 #include <comphelper/processfactory.hxx>
  46 #include <svl/eitem.hxx>
  47 #include <svl/intitem.hxx>
  48 #include <toolkit/unohlp.hxx>
  49 #include <toolkit/helper/convert.hxx>
  50
  51 using namespace ::com::sun::star;
  52
  53 //--------------------------------------------------------------------
  54
  55 sal_uInt16 SfxStatusBarControl::convertAwtToVCLMouseButtons( sal_Int16 nAwtMouseButtons )
  56 {
  57     sal_uInt16 nVCLMouseButtons( 0 );
  58
  59     if ( nAwtMouseButtons & awt::MouseButton::LEFT )
  60         nVCLMouseButtons |= MOUSE_LEFT;
  61     if ( nAwtMouseButtons & awt::MouseButton::RIGHT )
  62         nVCLMouseButtons |= MOUSE_RIGHT;
  63     if ( nAwtMouseButtons & awt::MouseButton::MIDDLE )
  64         nVCLMouseButtons |= MOUSE_MIDDLE;
  65
  66     return nVCLMouseButtons;
  67 }
  68
  69 //--------------------------------------------------------------------
  70
  71 svt::StatusbarController* SAL_CALL SfxStatusBarControllerFactory(
  72     const uno::Reference< frame::XFrame >& rFrame,
  73     StatusBar* pStatusBar,
  74     unsigned short nID,
  75     const OUString& aCommandURL )
  76 {
  77     SolarMutexGuard aGuard;
  78
  79     util::URL aTargetURL;
  80     aTargetURL.Complete = aCommandURL;
  81     uno::Reference < util::XURLTransformer > xTrans( util::URLTransformer::create( ::comphelper::getProcessComponentContext() ) );
  82     xTrans->parseStrict( aTargetURL );
  83
  84     SfxObjectShell* pObjShell = NULL;
  85     uno::Reference < frame::XController > xController;
  86     uno::Reference < frame::XModel > xModel;
  87     if ( rFrame.is() )
  88     {
  89         xController = rFrame->getController();
  90         if ( xController.is() )
  91             xModel = xController->getModel();
  92     }
  93
  94     if ( xModel.is() )
  95     {
  96         // Get tunnel from model to retrieve the SfxObjectShell pointer from it
  97         ::com::sun::star::uno::Reference < ::com::sun::star::lang::XUnoTunnel > xObj( xModel, uno::UNO_QUERY );
  98         ::com::sun::star::uno::Sequence < sal_Int8 > aSeq = SvGlobalName( SFX_GLOBAL_CLASSID ).GetByteSequence();
  99         if ( xObj.is() )
 100         {
 101             sal_Int64 nHandle = xObj->getSomething( aSeq );
 102             if ( nHandle )
 103                         pObjShell = reinterpret_cast< SfxObjectShell* >( sal::static_int_cast< sal_IntPtr >( nHandle ));
 104         }
 105     }
 106
 107     SfxModule*     pModule   = pObjShell ? pObjShell->GetModule() : NULL;
 108     SfxSlotPool*   pSlotPool = 0;
 109
 110     if ( pModule )
 111         pSlotPool = pModule->GetSlotPool();
 112     else
 113         pSlotPool = &(SfxSlotPool::GetSlotPool( NULL ));
 114
 115     const SfxSlot* pSlot = pSlotPool->GetUnoSlot( aTargetURL.Path );
 116     if ( pSlot )
 117     {
 118         sal_uInt16 nSlotId = pSlot->GetSlotId();
 119         if ( nSlotId > 0 )
 120         {
 121             OString aCmd(".uno:");
 122             aCmd += pSlot->GetUnoName();
 123             pStatusBar->SetHelpId( nSlotId, aCmd );
 124             return SfxStatusBarControl::CreateControl( nSlotId, nID, pStatusBar, pModule );
 125         }
 126     }
 127
 128     return NULL;
 129 }
 130
 131 //--------------------------------------------------------------------
 132
 133 SfxStatusBarControl::SfxStatusBarControl
 134 (
 135     sal_uInt16      nSlotID,            /* Slot-Id which is connected to this
 136                                        instance. If a Slot-Id is set to != 0 at
 137                                        registration it will always be set there.
 138                                     */
 139
 140
 141     sal_uInt16      nCtrlID,            /* ID of this controller in the status bar */
 142
 143     StatusBar&  rBar                /* Reference to the StatusBar,for which
 144                                        this Control was created. */
 145 )
 146
 147
 148 /*  [Description]
 149
 150     Constructor of the SfxStatusBarControl Class. The Subclasses are
 151     created at the Factory if necessary.
 152
 153     Instances of this base class are created for all StatusBar-fields
 154     for which no specific ones have been registered.
 155 */
 156
 157 :   svt::StatusbarController(),
 158     nSlotId( nSlotID ),
 159     nId( nCtrlID ),
 160     pBar( &rBar )
 161 {
 162 }
 163
 164 //--------------------------------------------------------------------
 165
 166 SfxStatusBarControl::~SfxStatusBarControl()
 167
 168 /*  [Description]
 169
 170     Destructor of the SfxStatusBarControl Class. The Class and its Subclasses
 171     are destroyed by SFx.
 172 */
 173
 174 {}
 175
 176 //--------------------------------------------------------------------
 177 // XInterface
 178 uno::Any SAL_CALL SfxStatusBarControl::queryInterface( const uno::Type & rType )
 179 throw( uno::RuntimeException)
 180 {
 181     return svt::StatusbarController::queryInterface( rType );
 182 }
 183
 184 void SAL_CALL SfxStatusBarControl::acquire() throw()
 185 {
 186     OWeakObject::acquire();
 187 }
 188
 189 void SAL_CALL SfxStatusBarControl::release() throw()
 190 {
 191     OWeakObject::release();
 192 }
 193
 194 //--------------------------------------------------------------------
 195 // XEventListener
 196 void SAL_CALL SfxStatusBarControl::disposing( const lang::EventObject& aEvent )
 197 throw( uno::RuntimeException )
 198 {
 199     svt::StatusbarController::disposing( aEvent );
 200 }
 201
 202 //--------------------------------------------------------------------
 203 // XComponent
 204 void SAL_CALL SfxStatusBarControl::dispose()
 205 throw (uno::RuntimeException)
 206 {
 207     svt::StatusbarController::dispose();
 208 }
 209
 210 //--------------------------------------------------------------------
 211 // XStatusListener
 212 void SAL_CALL SfxStatusBarControl::statusChanged( const frame::FeatureStateEvent& rEvent )
 213 throw ( ::com::sun::star::uno::RuntimeException )
 214 {
 215     SfxViewFrame* pViewFrame = NULL;
 216     uno::Reference < frame::XController > xController;
 217
 218     SolarMutexGuard aGuard;
 219     if ( m_xFrame.is() )
 220         xController = m_xFrame->getController();
 221
 222     uno::Reference < frame::XDispatchProvider > xProvider( xController, uno::UNO_QUERY );
 223     if ( xProvider.is() )
 224     {
 225         uno::Reference < frame::XDispatch > xDisp = xProvider->queryDispatch( rEvent.FeatureURL, OUString(), 0 );
 226         if ( xDisp.is() )
 227         {
 228             uno::Reference< lang::XUnoTunnel > xTunnel( xDisp, uno::UNO_QUERY );
 229             SfxOfficeDispatch* pDisp = NULL;
 230             if ( xTunnel.is() )
 231             {
 232                 sal_Int64 nImplementation = xTunnel->getSomething(SfxOfficeDispatch::impl_getStaticIdentifier());
 233                 pDisp = reinterpret_cast< SfxOfficeDispatch* >(sal::static_int_cast< sal_IntPtr >( nImplementation ));
 234             }
 235
 236             if ( pDisp )
 237                 pViewFrame = pDisp->GetDispatcher_Impl()->GetFrame();
 238         }
 239     }
 240
 241     sal_uInt16 nSlotID = 0;
 242     SfxSlotPool& rPool = SfxSlotPool::GetSlotPool( pViewFrame );
 243     const SfxSlot* pSlot = rPool.GetUnoSlot( rEvent.FeatureURL.Path );
 244     if ( pSlot )
 245         nSlotID = pSlot->GetSlotId();
 246
 247     if ( nSlotID > 0 )
 248     {
 249         if ( rEvent.Requery )
 250             svt::StatusbarController::statusChanged( rEvent );
 251         else
 252         {
 253             SfxItemState eState = SFX_ITEM_DISABLED;
 254             SfxPoolItem* pItem = NULL;
 255             if ( rEvent.IsEnabled )
 256             {
 257                 eState = SFX_ITEM_AVAILABLE;
 258                 uno::Type pType = rEvent.State.getValueType();
 259
 260                 if ( pType == ::getVoidCppuType() )
 261                 {
 262                     pItem = new SfxVoidItem( nSlotID );
 263                     eState = SFX_ITEM_UNKNOWN;
 264                 }
 265                 else if ( pType == ::getBooleanCppuType() )
 266                 {
 267                     sal_Bool bTemp = 0;
 268                     rEvent.State >>= bTemp ;
 269                     pItem = new SfxBoolItem( nSlotID, bTemp );
 270                 }
 271                 else if ( pType == ::getCppuType((const sal_uInt16*)0) )
 272                 {
 273                     sal_uInt16 nTemp = 0;
 274                     rEvent.State >>= nTemp ;
 275                     pItem = new SfxUInt16Item( nSlotID, nTemp );
 276                 }
 277                 else if ( pType == ::getCppuType((const sal_uInt32*)0) )
 278                 {
 279                     sal_uInt32 nTemp = 0;
 280                     rEvent.State >>= nTemp ;
 281                     pItem = new SfxUInt32Item( nSlotID, nTemp );
 282                 }
 283                 else if ( pType == ::getCppuType((const OUString*)0) )
 284                 {
 285                     OUString sTemp ;
 286                     rEvent.State >>= sTemp ;
 287                     pItem = new SfxStringItem( nSlotID, sTemp );
 288                 }
 289                 else if ( pType == ::getCppuType((const ::com::sun::star::frame::status::ItemStatus*)0) )
 290                 {
 291                     frame::status::ItemStatus aItemStatus;
 292                     rEvent.State >>= aItemStatus;
 293                     eState = aItemStatus.State;
 294                     pItem = new SfxVoidItem( nSlotID );
 295                 }
 296                 else
 297                 {
 298                     if ( pSlot )
 299                         pItem = pSlot->GetType()->CreateItem();
 300                     if ( pItem )
 301                     {
 302                         pItem->SetWhich( nSlotID );
 303                         pItem->PutValue( rEvent.State );
 304                     }
 305                     else
 306                         pItem = new SfxVoidItem( nSlotID );
 307                 }
 308             }
 309
 310             StateChanged( nSlotID, eState, pItem );
 311             delete pItem;
 312         }
 313     }
 314 }
 315
 316 //--------------------------------------------------------------------
 317 // XStatusbarController
 318
 319 ::sal_Bool SAL_CALL SfxStatusBarControl::mouseButtonDown(
 320     const awt::MouseEvent& rMouseEvent )
 321 throw ( uno::RuntimeException )
 322 {
 323     SolarMutexGuard aGuard;
 324     ::Point aPos( rMouseEvent.X, rMouseEvent.Y );
 325
 326     ::MouseEvent aMouseEvent( aPos,
 327                               (sal_uInt16)rMouseEvent.ClickCount,
 328                               0,
 329                               convertAwtToVCLMouseButtons( rMouseEvent.Buttons ),
 330                               0 );
 331
 332     return MouseButtonDown( aMouseEvent );
 333 }
 334
 335 //--------------------------------------------------------------------
 336
 337 ::sal_Bool SAL_CALL SfxStatusBarControl::mouseMove(
 338     const awt::MouseEvent& rMouseEvent )
 339 throw (uno::RuntimeException)
 340 {
 341     SolarMutexGuard aGuard;
 342     ::Point aPos( rMouseEvent.X, rMouseEvent.Y );
 343
 344     ::MouseEvent aMouseEvent( aPos,
 345                               (sal_uInt16)rMouseEvent.ClickCount,
 346                               0,
 347                               convertAwtToVCLMouseButtons( rMouseEvent.Buttons ),
 348                               0 );
 349     return MouseMove( aMouseEvent );
 350 }
 351
 352 //--------------------------------------------------------------------
 353
 354 ::sal_Bool SAL_CALL SfxStatusBarControl::mouseButtonUp(
 355     const ::awt::MouseEvent& rMouseEvent )
 356 throw ( uno::RuntimeException )
 357 {
 358     SolarMutexGuard aGuard;
 359     ::Point aPos( rMouseEvent.X, rMouseEvent.Y );
 360
 361     ::MouseEvent aMouseEvent( aPos,
 362                               (sal_uInt16)rMouseEvent.ClickCount,
 363                               0,
 364                               convertAwtToVCLMouseButtons( rMouseEvent.Buttons ),
 365                               0 );
 366     return MouseButtonUp( aMouseEvent );
 367 }
 368
 369 //--------------------------------------------------------------------
 370
 371 void SAL_CALL SfxStatusBarControl::command(
 372     const awt::Point& rPos,
 373     ::sal_Int32 nCommand,
 374     ::sal_Bool /*bMouseEvent*/,
 375     const ::com::sun::star::uno::Any& /*aData*/ )
 376 throw (::com::sun::star::uno::RuntimeException)
 377 {
 378     SolarMutexGuard aGuard;
 379     ::Point aPos( rPos.X, rPos.Y );
 380     CommandEvent aCmdEvent( aPos, (sal_uInt16)nCommand, sal_True, NULL );
 381
 382     Command( aCmdEvent );
 383 }
 384
 385 //--------------------------------------------------------------------
 386
 387 void SAL_CALL SfxStatusBarControl::paint(
 388     const uno::Reference< awt::XGraphics >& xGraphics,
 389     const awt::Rectangle& rOutputRectangle,
 390     ::sal_Int32 nStyle )
 391 throw ( ::uno::RuntimeException )
 392 {
 393     SolarMutexGuard aGuard;
 394
 395     OutputDevice* pOutDev = VCLUnoHelper::GetOutputDevice( xGraphics );
 396     if ( pOutDev )
 397     {
 398         ::Rectangle aRect = VCLRectangle( rOutputRectangle );
 399         UserDrawEvent aUserDrawEvent( pOutDev, aRect, pBar->GetCurItemId(), (sal_uInt16)nStyle );
 400         Paint( aUserDrawEvent );
 401     }
 402 }
 403
 404 //--------------------------------------------------------------------
 405
 406 void SAL_CALL SfxStatusBarControl::click( const awt::Point& )
 407 throw ( uno::RuntimeException )
 408 {
 409     SolarMutexGuard aGuard;
 410     Click();
 411 }
 412
 413 //--------------------------------------------------------------------
 414
 415 void SAL_CALL SfxStatusBarControl::doubleClick( const awt::Point& )
 416 throw ( uno::RuntimeException )
 417 {
 418     SolarMutexGuard aGuard;
 419     DoubleClick();
 420 }
 421
 422 //--------------------------------------------------------------------
 423 // old sfx2 interface
 424 //--------------------------------------------------------------------
 425
 426 void SfxStatusBarControl::StateChanged
 427 (
 428     sal_uInt16              nSID,
 429     SfxItemState        eState,
 430     const SfxPoolItem*  pState  /* Pointer to SfxPoolItem, is only valid
 431                                    withih this Method call. This can be a
 432                                    Null-Pointer, a Pointer to SfxVoidItem
 433                                    or of this Type found registered by the
 434                                    Subclass of SfxStatusBarControl.
 435                                 */
 436 )
 437
 438 /*  [Description]
 439
 440     The base implementation includes items of type SfxStringItem
 441     where the text is entered in the status row field and
 442     SfxVoidItem, where the field is emptied. The base implementation
 443     should not be called in overloaded methods.
 444 */
 445
 446 {
 447     DBG_ASSERT( pBar != 0, "setting state to dangling StatusBar" );
 448
 449     const SfxStringItem* pStr = PTR_CAST( SfxStringItem, pState );
 450     if ( eState == SFX_ITEM_AVAILABLE && pStr )
 451         pBar->SetItemText( nSID, pStr->GetValue() );
 452     else
 453     {
 454         DBG_ASSERT( eState != SFX_ITEM_AVAILABLE || pState->ISA(SfxVoidItem),
 455                     "wrong SfxPoolItem subclass in SfxStatusBarControl" );
 456         pBar->SetItemText( nSID, String() );
 457     }
 458 }
 459
 460 //--------------------------------------------------------------------
 461
 462 sal_Bool SfxStatusBarControl::MouseButtonDown( const MouseEvent & )
 463
 464 /*  [Description]
 465
 466     This virtual method forwards the Event MouseButtonDown() of the
 467     StatusBar if the mouse position is within the range of the items,
 468     or if the mouse was captured by <SfxStatusBarControl::CaptureMouse()>
 469
 470     The default implementation is empty and returns FALSE.
 471
 472     [Return value]
 473
 474     sal_Bool                TRUE
 475            The event has been processed and is not intended to
 476            be forwarded to StatusBar
 477
 478                         FALSE
 479            The event was not processed and is to be
 480            be forwarded to StatusBar
 481 */
 482
 483 {
 484     return sal_False;
 485 }
 486
 487 //--------------------------------------------------------------------
 488
 489 sal_Bool SfxStatusBarControl::MouseMove( const MouseEvent & )
 490
 491 /*  [Description]
 492
 493     This virtual method forwards the Event MouseMove() of the
 494     StatusBar if the mouse position is within the range of the items,
 495     or if the mouse was captured by <SfxStatusBarControl::CaptureMouse()>
 496
 497     The default implementation is empty and returns FALSE.
 498
 499     [Return value]
 500
 501     sal_Bool                TRUE
 502            The event has been processed and is not intended to
 503            be forwarded to StatusBar
 504
 505                         FALSE
 506            The event was not processed and is to be
 507            be forwarded to StatusBar
 508 */
 509
 510 {
 511     return sal_False;
 512 }
 513
 514 //--------------------------------------------------------------------
 515
 516 sal_Bool SfxStatusBarControl::MouseButtonUp( const MouseEvent & )
 517
 518 /*  [Description]
 519
 520     This virtual method forwards the Event MouseButtonUp() of the
 521     StatusBar if the mouse position is within the range of the items,
 522     or if the mouse was captured by <SfxStatusBarControl::CaptureMouse()>
 523
 524     The default implementation is empty and returns FALSE.
 525
 526     [Return value]
 527
 528     sal_Bool                TRUE
 529            The event has been processed and is not intended to
 530            be forwarded to StatusBar
 531
 532                         FALSE
 533            The event was not processed and is to be
 534            be forwarded to StatusBar
 535 */
 536
 537 {
 538     return sal_False;
 539 }
 540
 541 //--------------------------------------------------------------------
 542
 543 void SfxStatusBarControl::Command( const CommandEvent& )
 544
 545 /*  [Description]
 546
 547     This virtual method is called when a CommandEvent is recived by
 548     SfxStatusBarControl.
 549
 550     The default implementation is empty.
 551 */
 552
 553 {
 554 }
 555
 556 //--------------------------------------------------------------------
 557
 558 void SfxStatusBarControl::Click()
 559
 560 /*  [Description]
 561
 562     This virtual method is called when the user clicks on the
 563     field in the status row that belongs to this control.
 564
 565     The default implementation is empty.
 566 */
 567
 568 {
 569 }
 570
 571 //--------------------------------------------------------------------
 572
 573 void SfxStatusBarControl::DoubleClick()
 574
 575 /*  [Description]
 576
 577     This virtual method is called when the user double-clicks on the
 578     field in the status row that belongs to this control.
 579 */
 580
 581 {
 582     ::com::sun::star::uno::Sequence< ::com::sun::star::beans::PropertyValue > aArgs;
 583     execute( aArgs );
 584 }
 585
 586 //--------------------------------------------------------------------
 587
 588 void SfxStatusBarControl::Paint
 589 (
 590     const UserDrawEvent& /* Reference to an UserDrawEvent */
 591 )
 592
 593 /*  [Description]
 594
 595     This virtual method is called to paint the contents if the field
 596     at hand is marked with SIB_USERDRAW. The output must be obtained
 597     within the Rectangle of rUDEvt.GetRect() by the OutputDevice
 598     given by rUDEvt.GetDevice().
 599
 600     The default implementation is empty.
 601 */
 602
 603 {
 604 }
 605
 606 //--------------------------------------------------------------------
 607
 608 void SfxStatusBarControl::CaptureMouse()
 609 {
 610 }
 611
 612 //--------------------------------------------------------------------
 613
 614 void SfxStatusBarControl::ReleaseMouse()
 615 {
 616 }
 617
 618 //--------------------------------------------------------------------
 619
 620 SfxStatusBarControl* SfxStatusBarControl::CreateControl
 621 (
 622     sal_uInt16     nSlotID,
 623     sal_uInt16     nStbId,
 624     StatusBar* pBar,
 625     SfxModule* pMod
 626 )
 627 {
 628     SolarMutexGuard aGuard;
 629     SfxApplication *pApp = SFX_APP();
 630
 631     SfxSlotPool *pSlotPool;
 632     if ( pMod )
 633         pSlotPool = pMod->GetSlotPool();
 634     else
 635         pSlotPool = &SfxSlotPool::GetSlotPool();
 636
 637     TypeId aSlotType = pSlotPool->GetSlotType(nSlotID);
 638     if ( aSlotType )
 639     {
 640         if ( pMod )
 641         {
 642             SfxStbCtrlFactArr_Impl *pFactories = pMod->GetStbCtrlFactories_Impl();
 643             if ( pFactories )
 644             {
 645                 SfxStbCtrlFactArr_Impl &rFactories = *pFactories;
 646                 for ( sal_uInt16 nFactory = 0; nFactory < rFactories.size(); ++nFactory )
 647                 if ( rFactories[nFactory]->nTypeId == aSlotType &&
 648                      ( ( rFactories[nFactory]->nSlotId == 0 ) ||
 649                      ( rFactories[nFactory]->nSlotId == nSlotID) ) )
 650                     return rFactories[nFactory]->pCtor( nSlotID, nStbId, *pBar );
 651             }
 652         }
 653
 654         SfxStbCtrlFactArr_Impl &rFactories = pApp->GetStbCtrlFactories_Impl();
 655         for ( sal_uInt16 nFactory = 0; nFactory < rFactories.size(); ++nFactory )
 656         if ( rFactories[nFactory]->nTypeId == aSlotType &&
 657              ( ( rFactories[nFactory]->nSlotId == 0 ) ||
 658              ( rFactories[nFactory]->nSlotId == nSlotID) ) )
 659             return rFactories[nFactory]->pCtor( nSlotID, nStbId, *pBar );
 660     }
 661
 662     return NULL;
 663 }
 664
 665 //--------------------------------------------------------------------
 666 void SfxStatusBarControl::RegisterStatusBarControl(SfxModule* pMod, SfxStbCtrlFactory* pFact)
 667 {
 668     SFX_APP()->RegisterStatusBarControl_Impl( pMod, pFact );
 669 }
 670 //--------------------------------------------------------------------
 671
 672 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */