sfx2/source/toolbox/tbxitem.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
  21 #ifdef SOLARIS
  22 #include <ctime>
  23 #endif
  24
  25 #include <string>
  26 #include <com/sun/star/uno/Reference.h>
  27 #include <com/sun/star/frame/XFrame.hpp>
  28 #include <com/sun/star/awt/XPopupMenu.hpp>
  29 #include <com/sun/star/awt/XWindow.hpp>
  30 #include <com/sun/star/awt/XWindowPeer.hpp>
  31 #include <com/sun/star/util/URL.hpp>
  32 #include <com/sun/star/util/URLTransformer.hpp>
  33 #include <com/sun/star/util/XURLTransformer.hpp>
  34 #include <com/sun/star/frame/XController.hpp>
  35 #include <com/sun/star/lang/XUnoTunnel.hpp>
  36 #include <com/sun/star/document/MacroExecMode.hpp>
  37 #include <com/sun/star/document/UpdateDocMode.hpp>
  38 #include <com/sun/star/frame/Desktop.hpp>
  39 #include <com/sun/star/frame/XComponentLoader.hpp>
  40 #include <com/sun/star/beans/PropertyValue.hpp>
  41 #include <com/sun/star/beans/XPropertySet.hpp>
  42 #include <com/sun/star/frame/XLayoutManager.hpp>
  43 #include <com/sun/star/frame/XPopupMenuController.hpp>
  44 #include <com/sun/star/frame/status/ItemStatus.hpp>
  45 #include <com/sun/star/frame/status/ItemState.hpp>
  46 #include <com/sun/star/ui/XUIElementFactory.hpp>
  47 #include <com/sun/star/frame/XModuleManager.hpp>
  48 #include <com/sun/star/container/XNameAccess.hpp>
  49 #include <com/sun/star/ui/XUIFunctionListener.hpp>
  50 #include <com/sun/star/ui/theUIElementFactoryManager.hpp>
  51 #include <com/sun/star/frame/status/Visibility.hpp>
  52 #include <svl/eitem.hxx>
  53 #include <svl/stritem.hxx>
  54 #include <svl/intitem.hxx>
  55 #include <svl/imageitm.hxx>
  56 #include <svl/visitem.hxx>
  57 #include <svl/urlbmk.hxx>
  58 #include <vcl/toolbox.hxx>
  59 #include <unotools/moduleoptions.hxx>
  60
  61 #include <svtools/imagemgr.hxx>
  62 #include <comphelper/processfactory.hxx>
  63 #include <framework/addonmenu.hxx>
  64 #include <framework/addonsoptions.hxx>
  65 #include <framework/menuconfiguration.hxx>
  66 #include <framework/sfxhelperfunctions.hxx>
  67 #include <vcl/taskpanelist.hxx>
  68 #include <toolkit/helper/vclunohelper.hxx>
  69 #include <svtools/menuoptions.hxx>
  70 #include <svtools/miscopt.hxx>
  71
  72 #include <sfx2/tbxctrl.hxx>
  73 #include <sfx2/mnumgr.hxx>
  74 #include <sfx2/dispatch.hxx>
  75 #include <sfx2/msg.hxx>
  76 #include <sfx2/msgpool.hxx>
  77 #include "statcach.hxx"
  78 #include <sfx2/viewfrm.hxx>
  79 #include "sfxtypes.hxx"
  80 #include <sfx2/genlink.hxx>
  81 #include <sfx2/sfxresid.hxx>
  82 #include <sfx2/sfx.hrc>
  83 #include <sfx2/module.hxx>
  84 #include <sfx2/docfile.hxx>
  85 #include <sfx2/docfac.hxx>
  86 #include <sfx2/frmhtmlw.hxx>
  87 #include <sfx2/app.hxx>
  88 #include <sfx2/unoctitm.hxx>
  89 #include "helpid.hrc"
  90 #include "workwin.hxx"
  91 #include <sfx2/imgmgr.hxx>
  92 #include "virtmenu.hxx"
  93 #include <sfx2/imagemgr.hxx>
  94 #include <ctrlfactoryimpl.hxx>
  95
  96 using namespace ::com::sun::star;
  97 using namespace ::com::sun::star::beans;
  98 using namespace ::com::sun::star::frame;
  99 using namespace ::com::sun::star::frame::status;
 100 using namespace ::com::sun::star::lang;
 101 using namespace ::com::sun::star::uno;
 102 using namespace ::com::sun::star::util;
 103 using namespace ::com::sun::star::container;
 104 using namespace ::com::sun::star::ui;
 105
 106
 107
 108 SFX_IMPL_TOOLBOX_CONTROL_ARG(SfxToolBoxControl, SfxStringItem, true);
 109 SFX_IMPL_TOOLBOX_CONTROL(SfxRecentFilesToolBoxControl, SfxStringItem);
 110
 111 static vcl::Window* GetTopMostParentSystemWindow( vcl::Window* pWindow )
 112 {
 113     OSL_ASSERT( pWindow );
 114     if ( pWindow )
 115     {
 116         // ->manually search topmost system window
 117         // required because their might be another system window between this and the top window
 118         pWindow = pWindow->GetParent();
 119         SystemWindow* pTopMostSysWin = NULL;
 120         while ( pWindow )
 121         {
 122             if ( pWindow->IsSystemWindow() )
 123                 pTopMostSysWin = static_cast<SystemWindow*>(pWindow);
 124             pWindow = pWindow->GetParent();
 125         }
 126         pWindow = pTopMostSysWin;
 127         OSL_ASSERT( pWindow );
 128         return pWindow;
 129     }
 130
 131     return NULL;
 132 }
 133
 134 svt::ToolboxController* SAL_CALL SfxToolBoxControllerFactory( const Reference< XFrame >& rFrame, ToolBox* pToolbox, unsigned short nID, const OUString& aCommandURL )
 135 {
 136     SolarMutexGuard aGuard;
 137
 138     URL aTargetURL;
 139     aTargetURL.Complete = aCommandURL;
 140     Reference < XURLTransformer > xTrans( URLTransformer::create( ::comphelper::getProcessComponentContext() ) );
 141     xTrans->parseStrict( aTargetURL );
 142     if ( !aTargetURL.Arguments.isEmpty() )
 143         return NULL;
 144
 145     SfxObjectShell* pObjShell = NULL;
 146     Reference < XController > xController;
 147     Reference < XModel > xModel;
 148     if ( rFrame.is() )
 149     {
 150         xController = rFrame->getController();
 151         if ( xController.is() )
 152             xModel = xController->getModel();
 153     }
 154
 155     if ( xModel.is() )
 156     {
 157         // Get tunnel from model to retrieve the SfxObjectShell pointer from it
 158         ::com::sun::star::uno::Reference < ::com::sun::star::lang::XUnoTunnel > xObj( xModel, UNO_QUERY );
 159         if ( xObj.is() )
 160         {
 161             ::com::sun::star::uno::Sequence < sal_Int8 > aSeq = SvGlobalName( SFX_GLOBAL_CLASSID ).GetByteSequence();
 162             sal_Int64 nHandle = xObj->getSomething( aSeq );
 163             if ( nHandle )
 164                 pObjShell = reinterpret_cast< SfxObjectShell* >( sal::static_int_cast< sal_IntPtr >( nHandle ));
 165         }
 166     }
 167
 168     SfxModule*     pModule   = pObjShell ? pObjShell->GetModule() : NULL;
 169     SfxSlotPool*   pSlotPool = 0;
 170
 171     if ( pModule )
 172         pSlotPool = pModule->GetSlotPool();
 173     else
 174         pSlotPool = &(SfxSlotPool::GetSlotPool( NULL ));
 175
 176     const SfxSlot* pSlot = pSlotPool->GetUnoSlot( aTargetURL.Path );
 177     if ( pSlot )
 178     {
 179         sal_uInt16 nSlotId = pSlot->GetSlotId();
 180         if ( nSlotId > 0 )
 181             return SfxToolBoxControl::CreateControl( nSlotId, nID, pToolbox, pModule );
 182     }
 183
 184     return NULL;
 185 }
 186
 187 struct SfxToolBoxControl_Impl
 188 {
 189     VclPtr<ToolBox>         pBox;
 190     bool                    bShowString;
 191     SfxTbxCtrlFactory*      pFact;
 192     sal_uInt16              nTbxId;
 193     sal_uInt16              nSlotId;
 194     VclPtr<SfxPopupWindow>  mpFloatingWindow;
 195     VclPtr<SfxPopupWindow>  mpPopupWindow;
 196     Reference< XUIElement > mxUIElement;
 197
 198     DECL_LINK( WindowEventListener, VclSimpleEvent* );
 199 };
 200
 201 IMPL_LINK( SfxToolBoxControl_Impl, WindowEventListener, VclSimpleEvent*, pEvent )
 202 {
 203     if ( pEvent &&
 204          pEvent->ISA( VclWindowEvent ) &&
 205          (( pEvent->GetId() == VCLEVENT_WINDOW_MOVE ) ||
 206           ( pEvent->GetId() == VCLEVENT_WINDOW_ACTIVATE )))
 207     {
 208         vcl::Window* pWindow( static_cast<VclWindowEvent*>(pEvent)->GetWindow() );
 209         if (( pWindow == mpFloatingWindow ) &&
 210             ( mpPopupWindow != nullptr ))
 211         {
 212             mpPopupWindow.disposeAndClear();
 213         }
 214     }
 215
 216     return 1;
 217 }
 218
 219
 220
 221 SfxToolBoxControl::SfxToolBoxControl(
 222     sal_uInt16      nSlotID,
 223     sal_uInt16      nID,
 224     ToolBox&        rBox,
 225     bool            bShowStringItems     )
 226 {
 227     pImpl = new SfxToolBoxControl_Impl;
 228
 229     pImpl->pBox = &rBox;
 230     pImpl->bShowString = bShowStringItems;
 231     pImpl->pFact = 0;
 232     pImpl->nTbxId = nID;
 233     pImpl->nSlotId = nSlotID;
 234     pImpl->mpFloatingWindow = 0;
 235     pImpl->mpPopupWindow = 0;
 236 }
 237
 238
 239
 240 SfxToolBoxControl::~SfxToolBoxControl()
 241 {
 242     if ( pImpl->mxUIElement.is() )
 243     {
 244         Reference< XComponent > xComponent( pImpl->mxUIElement, UNO_QUERY );
 245         xComponent->dispose();
 246     }
 247     pImpl->mxUIElement = 0;
 248     delete pImpl;
 249 }
 250
 251
 252
 253 ToolBox& SfxToolBoxControl::GetToolBox() const
 254 {
 255     return *pImpl->pBox;
 256 }
 257 unsigned short SfxToolBoxControl::GetId() const
 258 {
 259     return pImpl->nTbxId;
 260 }
 261 unsigned short SfxToolBoxControl::GetSlotId() const
 262 {
 263     return pImpl->nSlotId;
 264 }
 265
 266
 267
 268 void SAL_CALL SfxToolBoxControl::dispose() throw (::com::sun::star::uno::RuntimeException, std::exception)
 269 {
 270     if ( m_bDisposed )
 271         return;
 272
 273     svt::ToolboxController::dispose();
 274
 275     // Remove and destroy our item window at our toolbox
 276     SolarMutexGuard aGuard;
 277     VclPtr< vcl::Window > pWindow = pImpl->pBox->GetItemWindow( pImpl->nTbxId );
 278     pImpl->pBox->SetItemWindow( pImpl->nTbxId, 0 );
 279     pWindow.disposeAndClear();
 280
 281     // Dispose an open sub toolbar. It's possible that we have an open
 282     // sub toolbar while we get disposed. Therefore we have to dispose
 283     // it now! Not doing so would result in a crash. The sub toolbar
 284     // gets destroyed asynchronously and would access a non-existing
 285     // parent toolbar!
 286     if ( pImpl->mxUIElement.is() )
 287     {
 288         Reference< XComponent > xComponent( pImpl->mxUIElement, UNO_QUERY );
 289         xComponent->dispose();
 290     }
 291     pImpl->mxUIElement = 0;
 292
 293     // Delete my popup windows
 294     pImpl->mpFloatingWindow.disposeAndClear();
 295     pImpl->mpPopupWindow.disposeAndClear();
 296 }
 297
 298
 299 void SfxToolBoxControl::RegisterToolBoxControl( SfxModule* pMod, SfxTbxCtrlFactory* pFact)
 300 {
 301     SfxGetpApp()->RegisterToolBoxControl_Impl( pMod, pFact );
 302 }
 303
 304 SfxToolBoxControl* SfxToolBoxControl::CreateControl( sal_uInt16 nSlotId, sal_uInt16 nTbxId, ToolBox *pBox, SfxModule* pMod  )
 305 {
 306     SolarMutexGuard aGuard;
 307
 308     SfxApplication *pApp = SfxGetpApp();
 309
 310     SfxSlotPool *pSlotPool;
 311     if ( pMod )
 312         pSlotPool = pMod->GetSlotPool();
 313     else
 314         pSlotPool = &SfxSlotPool::GetSlotPool();
 315     TypeId aSlotType = pSlotPool->GetSlotType( nSlotId );
 316     if ( aSlotType )
 317     {
 318         SfxToolBoxControl *pCtrl;
 319         if ( pMod )
 320         {
 321             SfxTbxCtrlFactArr_Impl *pFactories = pMod->GetTbxCtrlFactories_Impl();
 322             if ( pFactories )
 323             {
 324                 SfxTbxCtrlFactArr_Impl &rFactories = *pFactories;
 325                 sal_uInt16 nFactory;
 326                 const sal_uInt16 nCount = rFactories.size();
 327
 328                 // search for a factory with the given slot id
 329                 for( nFactory = 0; nFactory < nCount; ++nFactory )
 330                     if( (rFactories[nFactory].nTypeId == aSlotType) && (rFactories[nFactory].nSlotId == nSlotId) )
 331                         break;
 332
 333                 if( nFactory == nCount )
 334                 {
 335                     // if no factory exists for the given slot id, see if we
 336                     // have a generic factory with the correct slot type and slot id == 0
 337                     for ( nFactory = 0; nFactory < nCount; ++nFactory )
 338                         if( (rFactories[nFactory].nTypeId == aSlotType) && (rFactories[nFactory].nSlotId == 0) )
 339                             break;
 340                 }
 341
 342                 if( nFactory < nCount )
 343                 {
 344                     pCtrl = rFactories[nFactory].pCtor( nSlotId, nTbxId, *pBox );
 345                     pCtrl->pImpl->pFact = &rFactories[nFactory];
 346                     return pCtrl;
 347                 }
 348             }
 349         }
 350
 351         SfxTbxCtrlFactArr_Impl &rFactories = pApp->GetTbxCtrlFactories_Impl();
 352         sal_uInt16 nFactory;
 353         const sal_uInt16 nCount = rFactories.size();
 354
 355         for( nFactory = 0; nFactory < nCount; ++nFactory )
 356             if( (rFactories[nFactory].nTypeId == aSlotType) && (rFactories[nFactory].nSlotId == nSlotId) )
 357                 break;
 358
 359         if( nFactory == nCount )
 360         {
 361             // if no factory exists for the given slot id, see if we
 362             // have a generic factory with the correct slot type and slot id == 0
 363             for( nFactory = 0; nFactory < nCount; ++nFactory )
 364                 if( (rFactories[nFactory].nTypeId == aSlotType) && (rFactories[nFactory].nSlotId == 0) )
 365                     break;
 366         }
 367
 368         if( nFactory < nCount )
 369         {
 370             pCtrl = rFactories[nFactory].pCtor( nSlotId, nTbxId, *pBox );
 371             pCtrl->pImpl->pFact = &rFactories[nFactory];
 372             return pCtrl;
 373         }
 374     }
 375
 376     return NULL;
 377 }
 378
 379 SfxItemState SfxToolBoxControl::GetItemState(
 380     const SfxPoolItem* pState )
 381 /*  [Description]
 382
 383     Static method for determining the status of the SfxPoolItem-pointer,
 384     used in the method <SfxControllerItem::StateChanged(const SfxPoolItem*)>.
 385
 386     [Return value]
 387
 388     SfxItemState        SfxItemState::UNKNOWN
 389                         Enabled, however no further status information is available.
 390                         Typical for <Slot>s, which are temporarily disabled a
 391                         anyway but other than that do not change their appearance.
 392
 393                         SfxItemState::DISABLED
 394                         Disabled, no further status information is available.
 395                         All other displayed values should be reset to the default
 396                         if possible.
 397
 398                         SfxItemState::DONTCARE
 399                         Enabled but there were only ambiguous values available
 400                         (i.e. none that could be queried).
 401
 402                         SfxItemState::DEFAULT
 403                         Enabled and with available values which can be queried
 404                         through'pState'. The type is thus by the Slot clearly
 405                         defined in the entire Program.
 406 */
 407
 408 {
 409     return !pState
 410                 ? SfxItemState::DISABLED
 411                 : IsInvalidItem(pState)
 412                     ? SfxItemState::DONTCARE
 413                     : pState->ISA(SfxVoidItem) && !pState->Which()
 414                         ? SfxItemState::UNKNOWN
 415                         : SfxItemState::DEFAULT;
 416 }
 417
 418 void SfxToolBoxControl::Dispatch(
 419     const Reference< XDispatchProvider >& rProvider,
 420     const OUString& rCommand,
 421     Sequence< ::PropertyValue >& aArgs )
 422 {
 423     if ( rProvider.is() )
 424     {
 425         ::com::sun::star::util::URL aTargetURL;
 426         aTargetURL.Complete = rCommand;
 427         Reference < XURLTransformer > xTrans( URLTransformer::create( ::comphelper::getProcessComponentContext() ) );
 428         xTrans->parseStrict( aTargetURL );
 429
 430         Reference < XDispatch > xDispatch = rProvider->queryDispatch( aTargetURL, OUString(), 0 );
 431         if ( xDispatch.is() )
 432             xDispatch->dispatch( aTargetURL, aArgs );
 433     }
 434 }
 435
 436 void SfxToolBoxControl::Dispatch( const OUString& aCommand, ::com::sun::star::uno::Sequence< ::com::sun::star::beans::PropertyValue >& aArgs )
 437 {
 438     Reference < XController > xController;
 439
 440     SolarMutexGuard aGuard;
 441     if ( getFrameInterface().is() )
 442         xController = getFrameInterface()->getController();
 443
 444     Reference < XDispatchProvider > xProvider( xController, UNO_QUERY );
 445     if ( xProvider.is() )
 446     {
 447         ::com::sun::star::util::URL aTargetURL;
 448         aTargetURL.Complete = aCommand;
 449         getURLTransformer()->parseStrict( aTargetURL );
 450
 451         Reference < XDispatch > xDispatch = xProvider->queryDispatch( aTargetURL, OUString(), 0 );
 452         if ( xDispatch.is() )
 453             xDispatch->dispatch( aTargetURL, aArgs );
 454     }
 455 }
 456
 457 void SAL_CALL SfxToolBoxControl::disposing( const ::com::sun::star::lang::EventObject& aEvent )
 458 throw( ::com::sun::star::uno::RuntimeException, std::exception )
 459 {
 460     svt::ToolboxController::disposing( aEvent );
 461 }
 462
 463 // XStatusListener
 464 void SAL_CALL SfxToolBoxControl::statusChanged( const FeatureStateEvent& rEvent )
 465 throw ( ::com::sun::star::uno::RuntimeException, std::exception )
 466 {
 467     SfxViewFrame* pViewFrame = NULL;
 468     Reference < XController > xController;
 469
 470     SolarMutexGuard aGuard;
 471     if ( getFrameInterface().is() )
 472         xController = getFrameInterface()->getController();
 473
 474     Reference < XDispatchProvider > xProvider( xController, UNO_QUERY );
 475     if ( xProvider.is() )
 476     {
 477         Reference < XDispatch > xDisp = xProvider->queryDispatch( rEvent.FeatureURL, OUString(), 0 );
 478         if ( xDisp.is() )
 479         {
 480             Reference< XUnoTunnel > xTunnel( xDisp, UNO_QUERY );
 481             SfxOfficeDispatch* pDisp = NULL;
 482             if ( xTunnel.is() )
 483             {
 484                 sal_Int64 nImplementation = xTunnel->getSomething(SfxOfficeDispatch::impl_getStaticIdentifier());
 485                 pDisp = reinterpret_cast< SfxOfficeDispatch* >( sal::static_int_cast< sal_IntPtr >( nImplementation ));
 486             }
 487
 488             if ( pDisp )
 489                 pViewFrame = pDisp->GetDispatcher_Impl()->GetFrame();
 490         }
 491     }
 492
 493     sal_uInt16 nSlotId = 0;
 494     SfxSlotPool& rPool = SfxSlotPool::GetSlotPool( pViewFrame );
 495     const SfxSlot* pSlot = rPool.GetUnoSlot( rEvent.FeatureURL.Path );
 496     if ( pSlot )
 497         nSlotId = pSlot->GetSlotId();
 498     else if ( m_aCommandURL == rEvent.FeatureURL.Path )
 499         nSlotId = GetSlotId();
 500
 501     if ( nSlotId > 0 )
 502     {
 503         if ( rEvent.Requery )
 504             svt::ToolboxController::statusChanged( rEvent );
 505         else
 506         {
 507             SfxItemState eState = SfxItemState::DISABLED;
 508             SfxPoolItem* pItem = NULL;
 509             if ( rEvent.IsEnabled )
 510             {
 511                 eState = SfxItemState::DEFAULT;
 512                 ::com::sun::star::uno::Type pType = rEvent.State.getValueType();
 513
 514                 if ( pType == cppu::UnoType<void>::get() )
 515                 {
 516                     pItem = new SfxVoidItem( nSlotId );
 517                     eState = SfxItemState::UNKNOWN;
 518                 }
 519                 else if ( pType == cppu::UnoType<bool>::get() )
 520                 {
 521                     bool bTemp = false;
 522                     rEvent.State >>= bTemp ;
 523                     pItem = new SfxBoolItem( nSlotId, bTemp );
 524                 }
 525                 else if ( pType == ::cppu::UnoType< ::cppu::UnoUnsignedShortType >::get())
 526                 {
 527                     sal_uInt16 nTemp = 0;
 528                     rEvent.State >>= nTemp ;
 529                     pItem = new SfxUInt16Item( nSlotId, nTemp );
 530                 }
 531                 else if ( pType == cppu::UnoType<sal_uInt32>::get() )
 532                 {
 533                     sal_uInt32 nTemp = 0;
 534                     rEvent.State >>= nTemp ;
 535                     pItem = new SfxUInt32Item( nSlotId, nTemp );
 536                 }
 537                 else if ( pType == cppu::UnoType<OUString>::get() )
 538                 {
 539                     OUString sTemp ;
 540                     rEvent.State >>= sTemp ;
 541                     pItem = new SfxStringItem( nSlotId, sTemp );
 542                 }
 543                 else if ( pType == cppu::UnoType< ::com::sun::star::frame::status::ItemStatus>::get() )
 544                 {
 545                     ItemStatus aItemStatus;
 546                     rEvent.State >>= aItemStatus;
 547                     SfxItemState tmpState = (SfxItemState) aItemStatus.State;
 548                     // make sure no-one tries to send us a combination of states
 549                     if (tmpState != SfxItemState::UNKNOWN && tmpState != SfxItemState::DISABLED &&
 550                         tmpState != SfxItemState::READONLY && tmpState != SfxItemState::DONTCARE &&
 551                         tmpState != SfxItemState::DEFAULT && tmpState != SfxItemState::SET)
 552                         throw ::com::sun::star::uno::RuntimeException("unknown status");
 553                     eState = tmpState;
 554                     pItem = new SfxVoidItem( nSlotId );
 555                 }
 556                 else if ( pType == cppu::UnoType< ::com::sun::star::frame::status::Visibility>::get() )
 557                 {
 558                     Visibility aVisibilityStatus;
 559                     rEvent.State >>= aVisibilityStatus;
 560                     pItem = new SfxVisibilityItem( nSlotId, aVisibilityStatus.bVisible );
 561                 }
 562                 else
 563                 {
 564                     if ( pSlot )
 565                         pItem = pSlot->GetType()->CreateItem();
 566                     if ( pItem )
 567                     {
 568                         pItem->SetWhich( nSlotId );
 569                         pItem->PutValue( rEvent.State );
 570                     }
 571                     else
 572                         pItem = new SfxVoidItem( nSlotId );
 573                 }
 574             }
 575
 576             StateChanged( nSlotId, eState, pItem );
 577             delete pItem;
 578         }
 579     }
 580 }
 581
 582 // XSubToolbarController
 583 sal_Bool SAL_CALL SfxToolBoxControl::opensSubToolbar() throw (::com::sun::star::uno::RuntimeException, std::exception)
 584 {
 585     return sal_False;
 586 }
 587
 588 OUString SAL_CALL SfxToolBoxControl::getSubToolbarName() throw (::com::sun::star::uno::RuntimeException, std::exception)
 589 {
 590     return OUString();
 591 }
 592
 593 void SAL_CALL SfxToolBoxControl::functionSelected( const OUString& /*aCommand*/ ) throw (::com::sun::star::uno::RuntimeException, std::exception)
 594 {
 595     // must be implemented by sub-class
 596 }
 597
 598 void SAL_CALL SfxToolBoxControl::updateImage() throw (::com::sun::star::uno::RuntimeException, std::exception)
 599 {
 600     // must be implemented by sub-class
 601 }
 602
 603 // XToolbarController
 604 void SAL_CALL SfxToolBoxControl::execute( sal_Int16 KeyModifier ) throw (::com::sun::star::uno::RuntimeException, std::exception)
 605 {
 606     SolarMutexGuard aGuard;
 607     Select( (sal_uInt16)KeyModifier );
 608 }
 609
 610 void SAL_CALL SfxToolBoxControl::click() throw (::com::sun::star::uno::RuntimeException, std::exception)
 611 {
 612     SolarMutexGuard aGuard;
 613     Click();
 614 }
 615
 616 void SAL_CALL SfxToolBoxControl::doubleClick() throw (::com::sun::star::uno::RuntimeException, std::exception)
 617 {
 618     SolarMutexGuard aGuard;
 619     DoubleClick();
 620 }
 621
 622 Reference< ::com::sun::star::awt::XWindow > SAL_CALL SfxToolBoxControl::createPopupWindow() throw (::com::sun::star::uno::RuntimeException, std::exception)
 623 {
 624     SolarMutexGuard aGuard;
 625     VclPtr<vcl::Window> pWindow = CreatePopupWindow();
 626     if ( pWindow )
 627         return VCLUnoHelper::GetInterface( pWindow );
 628     else
 629         return Reference< ::com::sun::star::awt::XWindow >();
 630 }
 631
 632 Reference< ::com::sun::star::awt::XWindow > SAL_CALL SfxToolBoxControl::createItemWindow( const Reference< ::com::sun::star::awt::XWindow >& rParent ) throw (::com::sun::star::uno::RuntimeException, std::exception)
 633 {
 634     SolarMutexGuard aGuard;
 635     return VCLUnoHelper::GetInterface( CreateItemWindow( VCLUnoHelper::GetWindow( rParent )));
 636 }
 637
 638 // XDockableWindowListener
 639 void SAL_CALL SfxToolBoxControl::startDocking( const ::com::sun::star::awt::DockingEvent& )
 640 throw (::com::sun::star::uno::RuntimeException, std::exception)
 641 {
 642 }
 643 ::com::sun::star::awt::DockingData SAL_CALL SfxToolBoxControl::docking( const ::com::sun::star::awt::DockingEvent& )
 644 throw (::com::sun::star::uno::RuntimeException, std::exception)
 645 {
 646     return ::com::sun::star::awt::DockingData();
 647 }
 648
 649 void SAL_CALL SfxToolBoxControl::endDocking( const ::com::sun::star::awt::EndDockingEvent& )
 650 throw (::com::sun::star::uno::RuntimeException, std::exception)
 651 {
 652 }
 653
 654 sal_Bool SAL_CALL SfxToolBoxControl::prepareToggleFloatingMode( const ::com::sun::star::lang::EventObject& )
 655 throw (::com::sun::star::uno::RuntimeException, std::exception)
 656 {
 657     return sal_False;
 658 }
 659
 660 void SAL_CALL SfxToolBoxControl::toggleFloatingMode( const ::com::sun::star::lang::EventObject& )
 661 throw (::com::sun::star::uno::RuntimeException, std::exception)
 662 {
 663 }
 664
 665 void SAL_CALL SfxToolBoxControl::closed( const ::com::sun::star::lang::EventObject& )
 666 throw (::com::sun::star::uno::RuntimeException, std::exception)
 667 {
 668 }
 669
 670 void SAL_CALL SfxToolBoxControl::endPopupMode( const ::com::sun::star::awt::EndPopupModeEvent& aEvent )
 671 throw (::com::sun::star::uno::RuntimeException, std::exception)
 672 {
 673     SolarMutexGuard aGuard;
 674
 675     OUString aSubToolBarResName;
 676     if ( pImpl->mxUIElement.is() )
 677     {
 678         Reference< XPropertySet > xPropSet( pImpl->mxUIElement, UNO_QUERY );
 679         if ( xPropSet.is() )
 680         {
 681             try
 682             {
 683                 xPropSet->getPropertyValue("ResourceURL") >>= aSubToolBarResName;
 684             }
 685             catch ( com::sun::star::beans::UnknownPropertyException& )
 686             {
 687             }
 688             catch ( com::sun::star::lang::WrappedTargetException& )
 689             {
 690             }
 691         }
 692
 693         Reference< XComponent > xComponent( pImpl->mxUIElement, UNO_QUERY );
 694         xComponent->dispose();
 695     }
 696     pImpl->mxUIElement = 0;
 697
 698     // if the toolbar was teared-off recreate it and place it at the given position
 699     if( aEvent.bTearoff )
 700     {
 701         Reference< XUIElement >     xUIElement;
 702         Reference< XLayoutManager > xLayoutManager = getLayoutManager();
 703
 704         if ( !xLayoutManager.is() )
 705             return;
 706
 707         xLayoutManager->createElement( aSubToolBarResName );
 708         xUIElement = xLayoutManager->getElement( aSubToolBarResName );
 709         if ( xUIElement.is() )
 710         {
 711             Reference< ::com::sun::star::awt::XWindow > xParent = getFrameInterface()->getContainerWindow();
 712
 713             Reference< ::com::sun::star::awt::XWindow > xSubToolBar( xUIElement->getRealInterface(), UNO_QUERY );
 714             Reference< ::com::sun::star::beans::XPropertySet > xProp( xUIElement, UNO_QUERY );
 715             if ( xSubToolBar.is() && xProp.is() )
 716             {
 717                 OUString aPersistentString( "Persistent" );
 718                 try
 719                 {
 720                     vcl::Window*  pTbxWindow = VCLUnoHelper::GetWindow( xSubToolBar );
 721                     if ( pTbxWindow && pTbxWindow->GetType() == WINDOW_TOOLBOX )
 722                     {
 723                         Any a;
 724                         a = xProp->getPropertyValue( aPersistentString );
 725                         xProp->setPropertyValue( aPersistentString, makeAny( sal_False ));
 726
 727                         xLayoutManager->hideElement( aSubToolBarResName );
 728                         xLayoutManager->floatWindow( aSubToolBarResName );
 729
 730                         xLayoutManager->setElementPos( aSubToolBarResName, aEvent.FloatingPosition );
 731                         xLayoutManager->showElement( aSubToolBarResName );
 732
 733                         xProp->setPropertyValue("Persistent", a );
 734                     }
 735                 }
 736                 catch ( ::com::sun::star::uno::RuntimeException& )
 737                 {
 738                     throw;
 739                 }
 740                 catch ( ::com::sun::star::uno::Exception& )
 741                 {
 742                 }
 743             }
 744         }
 745     }
 746 }
 747
 748 ::Size  SfxToolBoxControl::getPersistentFloatingSize( const Reference< XFrame >& /*xFrame*/, const OUString& /*rSubToolBarResName*/ )
 749 {
 750     ::Size  aToolboxSize;
 751     return aToolboxSize;
 752 }
 753
 754 bool SfxToolBoxControl::hasBigImages() const
 755 {
 756     return (GetToolBox().GetToolboxButtonSize() == TOOLBOX_BUTTONSIZE_LARGE);
 757 }
 758
 759 void SfxToolBoxControl::createAndPositionSubToolBar( const OUString& rSubToolBarResName )
 760 {
 761     SolarMutexGuard aGuard;
 762
 763     if ( pImpl->pBox )
 764     {
 765         static WeakReference< XUIElementFactoryManager > xWeakUIElementFactory;
 766
 767         sal_uInt16 nItemId = pImpl->pBox->GetDownItemId();
 768
 769         if ( !nItemId )
 770             return;
 771
 772         // create element with factory
 773         Reference< XFrame >                 xFrame          = getFrameInterface();
 774         Reference< XUIElement >             xUIElement;
 775         Reference< XUIElementFactoryManager >  xUIElementFactory;
 776
 777         xUIElementFactory = xWeakUIElementFactory;
 778         if ( !xUIElementFactory.is() )
 779         {
 780             xUIElementFactory = theUIElementFactoryManager::get( m_xContext );
 781             xWeakUIElementFactory = xUIElementFactory;
 782         }
 783
 784         Sequence< PropertyValue > aPropSeq( 3 );
 785         aPropSeq[0].Name = "Frame";
 786         aPropSeq[0].Value <<= xFrame;
 787         aPropSeq[1].Name = "Persistent";
 788         aPropSeq[1].Value <<= sal_False;
 789         aPropSeq[2].Name = "PopupMode";
 790         aPropSeq[2].Value <<= sal_True;
 791
 792         try
 793         {
 794             xUIElement = xUIElementFactory->createUIElement( rSubToolBarResName, aPropSeq );
 795         }
 796         catch ( ::com::sun::star::container::NoSuchElementException& )
 797         {
 798         }
 799         catch ( IllegalArgumentException& )
 800         {
 801         }
 802
 803         if ( xUIElement.is() )
 804         {
 805             Reference< ::com::sun::star::awt::XWindow > xParent = getFrameInterface()->getContainerWindow();
 806
 807             Reference< ::com::sun::star::awt::XWindow > xSubToolBar( xUIElement->getRealInterface(), UNO_QUERY );
 808             if ( xSubToolBar.is() )
 809             {
 810                 Reference< ::com::sun::star::awt::XDockableWindow > xDockWindow( xSubToolBar, UNO_QUERY );
 811                 xDockWindow->addDockableWindowListener( Reference< ::com::sun::star::awt::XDockableWindowListener >(
 812                     static_cast< OWeakObject * >( this ), UNO_QUERY ));
 813                 xDockWindow->enableDocking( sal_True );
 814
 815                 // keep refererence to UIElement to avoid its destruction
 816                 if ( pImpl->mxUIElement.is() )
 817                 {
 818                     Reference< XComponent > xComponent( pImpl->mxUIElement, UNO_QUERY );
 819                     xComponent->dispose();
 820                 }
 821                 pImpl->mxUIElement = xUIElement;
 822
 823                 vcl::Window*  pTbxWindow = VCLUnoHelper::GetWindow( xSubToolBar );
 824                 ToolBox* pToolBar( 0 );
 825                 if ( pTbxWindow && pTbxWindow->GetType() == WINDOW_TOOLBOX )
 826                     pToolBar = static_cast<ToolBox *>(pTbxWindow);
 827
 828                 if ( pToolBar )
 829                 {
 830                     vcl::Window*  pParentTbxWindow( pImpl->pBox );
 831                     pToolBar->SetParent( pParentTbxWindow );
 832                     ::Size aSize = getPersistentFloatingSize( xFrame, rSubToolBarResName );
 833                     if ( aSize.Width() == 0 || aSize.Height() == 0 )
 834                     {
 835                         // calc and set size for popup mode
 836                         aSize = pToolBar->CalcPopupWindowSizePixel();
 837                     }
 838                     pToolBar->SetSizePixel( aSize );
 839
 840                     // open subtoolbox in popup mode
 841                     vcl::Window::GetDockingManager()->StartPopupMode( pImpl->pBox, pToolBar );
 842                 }
 843             }
 844         }
 845     }
 846 }
 847
 848
 849
 850 void SfxToolBoxControl::SetPopupWindow( SfxPopupWindow* pWindow )
 851 {
 852     pImpl->mpPopupWindow = pWindow;
 853     pImpl->mpPopupWindow->SetPopupModeEndHdl( LINK( this, SfxToolBoxControl, PopupModeEndHdl ));
 854     pImpl->mpPopupWindow->SetDeleteLink_Impl( LINK( this, SfxToolBoxControl, ClosePopupWindow ));
 855 }
 856
 857
 858
 859 IMPL_LINK_NOARG(SfxToolBoxControl, PopupModeEndHdl)
 860 {
 861     if ( pImpl->mpPopupWindow->IsVisible() )
 862     {
 863         // Replace floating window with popup window and destroy
 864         // floating window instance.
 865         pImpl->mpFloatingWindow.disposeAndClear();
 866         pImpl->mpFloatingWindow = pImpl->mpPopupWindow;
 867         pImpl->mpPopupWindow.clear();
 868         // We also need to know when the user tries to use the
 869         // floating window.
 870         pImpl->mpFloatingWindow->AddEventListener( LINK( pImpl, SfxToolBoxControl_Impl, WindowEventListener ));
 871     }
 872     else
 873     {
 874         // Popup window has been closed by the user. No replacement, instance
 875         // will destroy itself.
 876         pImpl->mpPopupWindow.clear();
 877     }
 878
 879     return 1;
 880 }
 881
 882
 883 IMPL_LINK( SfxToolBoxControl, ClosePopupWindow, SfxPopupWindow *, pWindow )
 884 {
 885     if ( pWindow == pImpl->mpFloatingWindow )
 886         pImpl->mpFloatingWindow = 0;
 887     else
 888         pImpl->mpPopupWindow = 0;
 889
 890     return 1;
 891 }
 892
 893
 894
 895 void SfxToolBoxControl::StateChanged
 896 (
 897     sal_uInt16              nId,
 898     SfxItemState        eState,
 899     const SfxPoolItem*  pState
 900 )
 901 {
 902     DBG_ASSERT( pImpl->pBox != nullptr, "setting state to dangling ToolBox" );
 903
 904     if ( GetId() >= SID_OBJECTMENU0 && GetId() <= SID_OBJECTMENU_LAST )
 905         return;
 906
 907     // enabled/disabled-Flag correcting the lump sum
 908     pImpl->pBox->EnableItem( GetId(), eState != SfxItemState::DISABLED );
 909
 910     ToolBoxItemBits nItemBits = pImpl->pBox->GetItemBits( GetId() );
 911     nItemBits &= ~ToolBoxItemBits::CHECKABLE;
 912     ::TriState eTri = TRISTATE_FALSE;
 913     switch ( eState )
 914     {
 915         case SfxItemState::DEFAULT:
 916         if ( pState )
 917         {
 918             if ( pState->ISA(SfxBoolItem) )
 919             {
 920                 // BoolItem for checking
 921                 if ( static_cast<const SfxBoolItem*>(pState)->GetValue() )
 922                     eTri = TRISTATE_TRUE;
 923                 nItemBits |= ToolBoxItemBits::CHECKABLE;
 924             }
 925             else if ( pState->ISA(SfxEnumItemInterface) &&
 926                 static_cast<const SfxEnumItemInterface *>(pState)->HasBoolValue())
 927             {
 928                 // EnumItem is handled as Bool
 929                 if ( static_cast<const SfxEnumItemInterface *>(pState)->GetBoolValue() )
 930                     eTri = TRISTATE_TRUE;
 931                 nItemBits |= ToolBoxItemBits::CHECKABLE;
 932             }
 933             else if ( pImpl->bShowString && pState->ISA(SfxStringItem) )
 934                 pImpl->pBox->SetItemText(nId, static_cast<const SfxStringItem*>(pState)->GetValue() );
 935         }
 936         break;
 937
 938         case SfxItemState::DONTCARE:
 939         {
 940             eTri = TRISTATE_INDET;
 941             nItemBits |= ToolBoxItemBits::CHECKABLE;
 942         }
 943         break;
 944
 945         default: break; // do nothing
 946     }
 947
 948     pImpl->pBox->SetItemState( GetId(), eTri );
 949     pImpl->pBox->SetItemBits( GetId(), nItemBits );
 950 }
 951
 952
 953
 954 void SfxToolBoxControl::Select( sal_uInt16 nSelectModifier )
 955 {
 956     svt::ToolboxController::execute( nSelectModifier );
 957 }
 958
 959
 960
 961 void SfxToolBoxControl::DoubleClick()
 962 {
 963 }
 964
 965
 966
 967 void SfxToolBoxControl::Click()
 968 {
 969 }
 970
 971
 972
 973 SfxPopupWindowType SfxToolBoxControl::GetPopupWindowType() const
 974 {
 975     return SfxPopupWindowType::NONE;
 976 }
 977
 978
 979
 980 VclPtr<SfxPopupWindow> SfxToolBoxControl::CreatePopupWindow()
 981 {
 982     return 0;
 983 }
 984
 985 VclPtr<vcl::Window> SfxToolBoxControl::CreateItemWindow( vcl::Window * )
 986 {
 987     return VclPtr<vcl::Window>();
 988 }
 989
 990 SfxFrameStatusListener::SfxFrameStatusListener(
 991     const Reference< XComponentContext >& rxContext,
 992     const Reference< XFrame >& xFrame,
 993     SfxStatusListenerInterface* pCallee ) :
 994     svt::FrameStatusListener( rxContext, xFrame ),
 995     m_pCallee( pCallee )
 996 {
 997 }
 998
 999
1000
1001 SfxFrameStatusListener::~SfxFrameStatusListener()
1002 {
1003 }
1004
1005
1006
1007 // XStatusListener
1008 void SAL_CALL SfxFrameStatusListener::statusChanged( const ::com::sun::star::frame::FeatureStateEvent& rEvent )
1009 throw ( ::com::sun::star::uno::RuntimeException, std::exception )
1010 {
1011     SfxViewFrame* pViewFrame = NULL;
1012     Reference < XController > xController;
1013
1014     SolarMutexGuard aGuard;
1015     if ( m_xFrame.is() )
1016         xController = m_xFrame->getController();
1017
1018     Reference < XDispatchProvider > xProvider( xController, UNO_QUERY );
1019     if ( xProvider.is() )
1020     {
1021         Reference < XDispatch > xDisp = xProvider->queryDispatch( rEvent.FeatureURL, OUString(), 0 );
1022         if ( xDisp.is() )
1023         {
1024             Reference< XUnoTunnel > xTunnel( xDisp, UNO_QUERY );
1025             SfxOfficeDispatch* pDisp = NULL;
1026             if ( xTunnel.is() )
1027             {
1028                 sal_Int64 nImplementation = xTunnel->getSomething(SfxOfficeDispatch::impl_getStaticIdentifier());
1029                 pDisp = reinterpret_cast< SfxOfficeDispatch* >( sal::static_int_cast< sal_IntPtr >( nImplementation ));
1030             }
1031
1032             if ( pDisp )
1033                 pViewFrame = pDisp->GetDispatcher_Impl()->GetFrame();
1034         }
1035     }
1036
1037     sal_uInt16 nSlotId = 0;
1038     SfxSlotPool& rPool = SfxSlotPool::GetSlotPool( pViewFrame );
1039     const SfxSlot* pSlot = rPool.GetUnoSlot( rEvent.FeatureURL.Path );
1040     if ( pSlot )
1041         nSlotId = pSlot->GetSlotId();
1042
1043     if ( nSlotId > 0 )
1044     {
1045         if ( rEvent.Requery )
1046         {
1047             // requery for the notified state
1048             addStatusListener( rEvent.FeatureURL.Complete );
1049         }
1050         else
1051         {
1052             SfxItemState eState = SfxItemState::DISABLED;
1053             SfxPoolItem* pItem = NULL;
1054             if ( rEvent.IsEnabled )
1055             {
1056                 eState = SfxItemState::DEFAULT;
1057                 ::com::sun::star::uno::Type pType = rEvent.State.getValueType();
1058
1059                 if ( pType == cppu::UnoType<void>::get() )
1060                 {
1061                     pItem = new SfxVoidItem( nSlotId );
1062                     eState = SfxItemState::UNKNOWN;
1063                 }
1064                 else if ( pType == cppu::UnoType<bool>::get() )
1065                 {
1066                     bool bTemp = false;
1067                     rEvent.State >>= bTemp ;
1068                     pItem = new SfxBoolItem( nSlotId, bTemp );
1069                 }
1070                 else if ( pType == ::cppu::UnoType< ::cppu::UnoUnsignedShortType >::get())
1071                 {
1072                     sal_uInt16 nTemp = 0;
1073                     rEvent.State >>= nTemp ;
1074                     pItem = new SfxUInt16Item( nSlotId, nTemp );
1075                 }
1076                 else if ( pType == cppu::UnoType<sal_uInt32>::get() )
1077                 {
1078                     sal_uInt32 nTemp = 0;
1079                     rEvent.State >>= nTemp ;
1080                     pItem = new SfxUInt32Item( nSlotId, nTemp );
1081                 }
1082                 else if ( pType == cppu::UnoType<OUString>::get() )
1083                 {
1084                     OUString sTemp ;
1085                     rEvent.State >>= sTemp ;
1086                     pItem = new SfxStringItem( nSlotId, sTemp );
1087                 }
1088                 else if ( pType == cppu::UnoType< ::com::sun::star::frame::status::ItemStatus>::get() )
1089                 {
1090                     ItemStatus aItemStatus;
1091                     rEvent.State >>= aItemStatus;
1092                     SfxItemState tmpState = (SfxItemState) aItemStatus.State;
1093                     // make sure no-one tries to send us a combination of states
1094                     if (tmpState != SfxItemState::UNKNOWN && tmpState != SfxItemState::DISABLED &&
1095                         tmpState != SfxItemState::READONLY && tmpState != SfxItemState::DONTCARE &&
1096                         tmpState != SfxItemState::DEFAULT && tmpState != SfxItemState::SET)
1097                         throw ::com::sun::star::uno::RuntimeException("unknown status");
1098                     eState = tmpState;
1099                     pItem = new SfxVoidItem( nSlotId );
1100                 }
1101                 else if ( pType == cppu::UnoType< ::com::sun::star::frame::status::Visibility>::get() )
1102                 {
1103                     Visibility aVisibilityStatus;
1104                     rEvent.State >>= aVisibilityStatus;
1105                     pItem = new SfxVisibilityItem( nSlotId, aVisibilityStatus.bVisible );
1106                 }
1107                 else
1108                 {
1109                     if ( pSlot )
1110                         pItem = pSlot->GetType()->CreateItem();
1111                     if ( pItem )
1112                     {
1113                         pItem->SetWhich( nSlotId );
1114                         pItem->PutValue( rEvent.State );
1115                     }
1116                     else
1117                         pItem = new SfxVoidItem( nSlotId );
1118                 }
1119             }
1120
1121             if ( m_pCallee )
1122                 m_pCallee->StateChanged( nSlotId, eState, pItem );
1123             delete pItem;
1124         }
1125     }
1126 }
1127
1128 SfxPopupWindow::SfxPopupWindow(
1129     sal_uInt16 nId,
1130     const Reference< XFrame >& rFrame,
1131     WinBits nBits ) :
1132     FloatingWindow( SfxGetpApp()->GetTopWindow(), nBits )
1133     , m_bFloating( false )
1134     , m_bCascading( false )
1135     , m_nId( nId )
1136     , m_xFrame( rFrame )
1137     , m_pStatusListener( 0 )
1138 {
1139     vcl::Window* pWindow = GetTopMostParentSystemWindow( this );
1140     if ( pWindow )
1141         static_cast<SystemWindow *>(pWindow)->GetTaskPaneList()->AddWindow( this );
1142 }
1143
1144 SfxPopupWindow::SfxPopupWindow(sal_uInt16 nId, const OString& rID, const OUString& rUIXMLDescription,
1145                                const css::uno::Reference<css::frame::XFrame> &rFrame)
1146     : FloatingWindow(SfxGetpApp()->GetTopWindow(), rID, rUIXMLDescription, rFrame)
1147     , m_bFloating( false )
1148     , m_bCascading( false )
1149     , m_nId( nId )
1150     , m_xFrame( rFrame )
1151     , m_pStatusListener( 0 )
1152 {
1153     vcl::Window* pWindow = GetTopMostParentSystemWindow( this );
1154     if ( pWindow )
1155         static_cast<SystemWindow *>(pWindow)->GetTaskPaneList()->AddWindow( this );
1156 }
1157
1158 SfxPopupWindow::SfxPopupWindow(
1159     sal_uInt16 nId,
1160     const Reference< XFrame >& rFrame,
1161     vcl::Window* pParentWindow,
1162     WinBits nBits ) :
1163     FloatingWindow( pParentWindow, nBits )
1164     , m_bFloating( false )
1165     , m_bCascading( false )
1166     , m_nId( nId )
1167     , m_xFrame( rFrame )
1168     , m_pStatusListener( 0 )
1169 {
1170     vcl::Window* pWindow = GetTopMostParentSystemWindow( this );
1171     if ( pWindow )
1172         static_cast<SystemWindow *>(pWindow)->GetTaskPaneList()->AddWindow( this );
1173 }
1174
1175 SfxPopupWindow::SfxPopupWindow(
1176     sal_uInt16 nId,
1177     vcl::Window* pParentWindow,
1178     const OString& rID, const OUString& rUIXMLDescription,
1179     const Reference< XFrame >& rFrame ) :
1180     FloatingWindow( pParentWindow, rID, rUIXMLDescription, rFrame)
1181     , m_bFloating( false )
1182     , m_bCascading( false )
1183     , m_nId( nId )
1184     , m_xFrame( rFrame )
1185     , m_pStatusListener( 0 )
1186 {
1187     vcl::Window* pWindow = GetTopMostParentSystemWindow( this );
1188     if ( pWindow )
1189         static_cast<SystemWindow *>(pWindow)->GetTaskPaneList()->AddWindow( this );
1190 }
1191
1192 SfxPopupWindow::~SfxPopupWindow()
1193 {
1194     disposeOnce();
1195 }
1196
1197 void SfxPopupWindow::dispose()
1198 {
1199     if ( m_xStatusListener.is() )
1200     {
1201         m_xStatusListener->dispose();
1202         m_xStatusListener.clear();
1203     }
1204
1205     vcl::Window* pWindow = GetTopMostParentSystemWindow( this );
1206     if ( pWindow )
1207         static_cast<SystemWindow *>(pWindow)->GetTaskPaneList()->RemoveWindow( this );
1208     FloatingWindow::dispose();
1209 }
1210
1211
1212
1213 SfxFrameStatusListener* SfxPopupWindow::GetOrCreateStatusListener()
1214 {
1215     if ( !m_xStatusListener.is() )
1216     {
1217         m_pStatusListener = new SfxFrameStatusListener(
1218                                     ::comphelper::getProcessComponentContext(),
1219                                     m_xFrame,
1220                                     this );
1221         m_xStatusListener = Reference< XComponent >( static_cast< cppu::OWeakObject* >(
1222                                                         m_pStatusListener ), UNO_QUERY );
1223     }
1224
1225     return m_pStatusListener;
1226 }
1227
1228
1229
1230 void SfxPopupWindow::BindListener()
1231 {
1232     GetOrCreateStatusListener();
1233     if ( m_xStatusListener.is() )
1234         m_pStatusListener->bindListener();
1235 }
1236
1237
1238
1239 void SfxPopupWindow::UnbindListener()
1240 {
1241     GetOrCreateStatusListener();
1242     if ( m_xStatusListener.is() )
1243         m_pStatusListener->unbindListener();
1244 }
1245
1246
1247
1248 void SfxPopupWindow::AddStatusListener( const OUString& rCommandURL )
1249 {
1250     GetOrCreateStatusListener();
1251     if ( m_xStatusListener.is() )
1252         m_pStatusListener->addStatusListener( rCommandURL );
1253 }
1254
1255
1256
1257 bool SfxPopupWindow::Close()
1258 {
1259     m_bFloating = false;
1260     FloatingWindow::Close();
1261
1262     Delete();
1263     return true;
1264 }
1265
1266
1267
1268 void SfxPopupWindow::PopupModeEnd()
1269 {
1270     //! to allow PopupModeEndHdl to be called
1271     FloatingWindow::PopupModeEnd();
1272
1273     if ( IsVisible() )
1274     {
1275         // was teared-off
1276         DeleteFloatingWindow();
1277         m_bFloating = true;
1278     }
1279     else
1280         Close();
1281 }
1282
1283
1284
1285 void SfxPopupWindow::DeleteFloatingWindow()
1286 {
1287     if ( m_bFloating )
1288     {
1289         Hide();
1290         Delete();
1291     }
1292 }
1293
1294
1295
1296 void SfxPopupWindow::MouseMove( const ::MouseEvent& rMEvt )
1297 {
1298     if ( !m_bCascading )
1299         FloatingWindow::MouseMove( rMEvt );
1300     else
1301     {
1302         // Forward MouseMove-Event to Children
1303         ::Point       aPos = rMEvt.GetPosPixel();
1304         ::Point       aScrPos = OutputToScreenPixel( aPos );
1305         sal_uInt16 i = 0;
1306         vcl::Window* pWindow = GetChild( i );
1307         while ( pWindow )
1308         {
1309             ::MouseEvent aMEvt( pWindow->ScreenToOutputPixel( aScrPos ),
1310                               rMEvt.GetClicks(), rMEvt.GetMode(),
1311                               rMEvt.GetButtons(), rMEvt.GetModifier() );
1312             pWindow->MouseMove( rMEvt );
1313             pWindow->Update();
1314             i++;
1315             pWindow = GetChild( i );
1316         }
1317     }
1318 }
1319
1320
1321
1322 void SfxPopupWindow::StartCascading()
1323 {
1324     m_bCascading = true;
1325 }
1326
1327
1328
1329 VclPtr<SfxPopupWindow> SfxPopupWindow::Clone() const
1330
1331 /*  [Description]
1332
1333     This method must be overridden to show this Popup also in the
1334     Presentation-mode. It is called when a Show() would be meaningless
1335     since the parent is no presentation window.
1336     When create a new window the bew Top-Window will be used automatically,
1337     so that the Parent becomes the presentation window and that the new
1338     Popup therefore becomes visible.
1339 */
1340
1341 {
1342     return 0;
1343 }
1344
1345
1346
1347 void SfxPopupWindow::StateChanged(
1348     sal_uInt16 /*nSID*/,
1349     SfxItemState eState,
1350     const SfxPoolItem* /*pState*/ )
1351 /*  [Description]
1352
1353     See also <SfxControllerItem::StateChanged()>. In addition the Popup
1354     will become hidden when eState==SfxItemState::DISABLED and in all other
1355     cases it will be shown again if it is floating. In general this requires
1356     to call the Base class.
1357
1358     Due to the parent the presentation mode is handled in a special way.
1359 */
1360
1361 {
1362     if ( SfxItemState::DISABLED == eState )
1363     {
1364         Hide();
1365     }
1366     else if ( m_bFloating )
1367     {
1368         Show( true, SHOW_NOFOCUSCHANGE | SHOW_NOACTIVATE );
1369     }
1370 }
1371
1372
1373
1374 void SfxPopupWindow::Delete()
1375 {
1376     if ( m_aDeleteLink.IsSet() )
1377         m_aDeleteLink.Call( this );
1378     disposeOnce();
1379 }
1380
1381
1382
1383 SfxRecentFilesToolBoxControl::SfxRecentFilesToolBoxControl( sal_uInt16 nSlotId, sal_uInt16 nId, ToolBox& rBox )
1384     : SfxToolBoxControl( nSlotId, nId, rBox )
1385 {
1386     rBox.SetItemBits( nId, rBox.GetItemBits( nId ) | ToolBoxItemBits::DROPDOWN);
1387 }
1388
1389 SfxRecentFilesToolBoxControl::~SfxRecentFilesToolBoxControl()
1390 {
1391 }
1392
1393 VclPtr<SfxPopupWindow> SfxRecentFilesToolBoxControl::CreatePopupWindow()
1394 {
1395     ToolBox& rBox = GetToolBox();
1396     sal_uInt16 nItemId = GetId();
1397     ::Rectangle aRect( rBox.GetItemRect( nItemId ) );
1398
1399     Sequence< Any > aArgs( 2 );
1400     PropertyValue aPropValue;
1401
1402     aPropValue.Name = "CommandURL";
1403     aPropValue.Value <<= OUString( ".uno:RecentFileList" );
1404     aArgs[0] <<= aPropValue;
1405
1406     aPropValue.Name = "Frame";
1407     aPropValue.Value <<= m_xFrame;
1408     aArgs[1] <<= aPropValue;
1409
1410     uno::Reference< frame::XPopupMenuController > xPopupController( m_xContext->getServiceManager()->createInstanceWithArgumentsAndContext(
1411                 "com.sun.star.comp.framework.RecentFilesMenuController", aArgs, m_xContext ), UNO_QUERY );
1412
1413     uno::Reference< awt::XPopupMenu > xPopupMenu( m_xContext->getServiceManager()->createInstanceWithContext(
1414                 "com.sun.star.awt.PopupMenu", m_xContext ), uno::UNO_QUERY );
1415
1416     if ( xPopupController.is() && xPopupMenu.is() )
1417     {
1418         xPopupController->setPopupMenu( xPopupMenu );
1419
1420         rBox.SetItemDown( nItemId, true );
1421         Reference< awt::XWindowPeer > xPeer( getParent(), uno::UNO_QUERY );
1422
1423         if ( xPeer.is() )
1424             xPopupMenu->execute( xPeer, VCLUnoHelper::ConvertToAWTRect( aRect ), 0 );
1425
1426         rBox.SetItemDown( nItemId, false );
1427     }
1428
1429     return 0;
1430 }
1431
1432 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */