1 /**************************************************************
2 *
3 * Licensed to the Apache Software Foundation (ASF) under one
4 * or more contributor license agreements. See the NOTICE file
5 * distributed with this work for additional information
6 * regarding copyright ownership. The ASF licenses this file
7 * to you under the Apache License, Version 2.0 (the
8 * "License"); you may not use this file except in compliance
9 * with the License. You may obtain a copy of the License at
10 *
11 * http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing,
14 * software distributed under the License is distributed on an
15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16 * KIND, either express or implied. See the License for the
17 * specific language governing permissions and limitations
18 * under the License.
19 *
20 *************************************************************/
21
22
23
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_sfx2.hxx"
26
27 #ifdef SOLARIS
28 // HACK: prevent conflict between STLPORT and Workshop headers on Solaris 8
29 #include <ctime>
30 #endif
31
32 #include <string> // prevent conflict with STL includes
33 #include <com/sun/star/uno/Reference.h>
34 #include <com/sun/star/frame/XFrame.hpp>
35 #include <com/sun/star/awt/XWindow.hpp>
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/document/MacroExecMode.hpp>
41 #include <com/sun/star/document/UpdateDocMode.hpp>
42 #include <com/sun/star/frame/XComponentLoader.hpp>
43 #include <com/sun/star/beans/PropertyValue.hpp>
44 #include <com/sun/star/beans/XPropertySet.hpp>
45 #include <com/sun/star/frame/XLayoutManager.hpp>
46 #include <com/sun/star/frame/status/ItemStatus.hpp>
47 #include <com/sun/star/frame/status/ItemState.hpp>
48 #include <com/sun/star/ui/XUIElementFactory.hpp>
49 #include <com/sun/star/frame/XModuleManager.hpp>
50 #include <com/sun/star/container/XNameAccess.hpp>
51 #include <com/sun/star/ui/XUIFunctionListener.hpp>
52 #include <com/sun/star/frame/status/Visibility.hpp>
53 #include <com/sun/star/document/CorruptedFilterConfigurationException.hpp>
54 #include <svl/eitem.hxx>
55 #include <svl/stritem.hxx>
56 #include <svl/intitem.hxx>
57 #include <svl/imageitm.hxx>
58 #include <svl/visitem.hxx>
59 #include <svl/urlbmk.hxx>
60 #include <vcl/toolbox.hxx>
61 #include <unotools/moduleoptions.hxx>
62
63 #include <svtools/imagemgr.hxx>
64 #include <comphelper/processfactory.hxx>
65 #include <framework/addonmenu.hxx>
66 #include <framework/addonsoptions.hxx>
67 #include <framework/menuconfiguration.hxx>
68 #include <framework/sfxhelperfunctions.hxx>
69 #include <vcl/taskpanelist.hxx>
70 #ifndef _TOOLKIT_UNOHLP_HXX
71 #include <toolkit/helper/vclunohelper.hxx>
72 #endif
73 #include <svtools/menuoptions.hxx>
74 #include <svtools/miscopt.hxx>
75
76 #ifndef GCC
77 #endif
78
79 #include <sfx2/tbxctrl.hxx>
80 #include <sfx2/mnumgr.hxx>
81 #include <sfx2/dispatch.hxx>
82 #include "fltfnc.hxx"
83 #include <sfx2/msg.hxx>
84 #include <sfx2/msgpool.hxx>
85 #include "statcach.hxx"
86 #include <sfx2/viewfrm.hxx>
87 #include "arrdecl.hxx"
88 #include "sfxtypes.hxx"
89 #include <sfx2/genlink.hxx>
90 #include "sfx2/sfxresid.hxx"
91 #include <sfx2/sfx.hrc>
92 #include <sfx2/module.hxx>
93 #include <sfx2/docfile.hxx>
94 #include <sfx2/docfac.hxx>
95 #include "referers.hxx"
96 #include <sfx2/frmhtmlw.hxx>
97 #include <sfx2/app.hxx>
98 #include <sfx2/unoctitm.hxx>
99 #include "helpid.hrc"
100 #include "workwin.hxx"
101 #include "sfx2/imgmgr.hxx"
102 #include "virtmenu.hxx"
103 #include <sfx2/viewfrm.hxx>
104 #include <sfx2/module.hxx>
105 #include "sfx2/imagemgr.hxx"
106
107 #include <comphelper/uieventslogger.hxx>
108 #include <com/sun/star/frame/XModuleManager.hpp>
109
110 //using namespace ::com::sun::star::awt;
111 using namespace ::com::sun::star::beans;
112 using namespace ::com::sun::star::frame;
113 using namespace ::com::sun::star::frame::status;
114 using namespace ::com::sun::star::lang;
115 using namespace ::com::sun::star::uno;
116 using namespace ::com::sun::star::util;
117 using namespace ::com::sun::star::container;
118 using namespace ::com::sun::star::frame;
119 using namespace ::com::sun::star::ui;
120
121 //====================================================================
122
123 SFX_IMPL_TOOLBOX_CONTROL_ARG(SfxToolBoxControl, SfxStringItem, sal_True);
124
GetTopMostParentSystemWindow(Window * pWindow)125 static Window* GetTopMostParentSystemWindow( Window* pWindow )
126 {
127 OSL_ASSERT( pWindow );
128 if ( pWindow )
129 {
130 // ->manually search topmost system window
131 // required because their might be another system window between this and the top window
132 pWindow = pWindow->GetParent();
133 SystemWindow* pTopMostSysWin = NULL;
134 while ( pWindow )
135 {
136 if ( pWindow->IsSystemWindow() )
137 pTopMostSysWin = (SystemWindow*)pWindow;
138 pWindow = pWindow->GetParent();
139 }
140 pWindow = pTopMostSysWin;
141 OSL_ASSERT( pWindow );
142 return pWindow;
143 }
144
145 return NULL;
146 }
147
SfxToolBoxControllerFactory(const Reference<XFrame> & rFrame,ToolBox * pToolbox,unsigned short nID,const::rtl::OUString & aCommandURL)148 svt::ToolboxController* SAL_CALL SfxToolBoxControllerFactory( const Reference< XFrame >& rFrame, ToolBox* pToolbox, unsigned short nID, const ::rtl::OUString& aCommandURL )
149 {
150 ::vos::OGuard aGuard( Application::GetSolarMutex() );
151
152 URL aTargetURL;
153 aTargetURL.Complete = aCommandURL;
154 Reference < XURLTransformer > xTrans( ::comphelper::getProcessServiceFactory()->createInstance( rtl::OUString::createFromAscii("com.sun.star.util.URLTransformer" )), UNO_QUERY );
155 xTrans->parseStrict( aTargetURL );
156 if ( aTargetURL.Arguments.getLength() )
157 return NULL;
158
159 SfxObjectShell* pObjShell = NULL;
160 Reference < XController > xController;
161 Reference < XModel > xModel;
162 if ( rFrame.is() )
163 {
164 xController = rFrame->getController();
165 if ( xController.is() )
166 xModel = xController->getModel();
167 }
168
169 if ( xModel.is() )
170 {
171 // Get tunnel from model to retrieve the SfxObjectShell pointer from it
172 ::com::sun::star::uno::Reference < ::com::sun::star::lang::XUnoTunnel > xObj( xModel, UNO_QUERY );
173 if ( xObj.is() )
174 {
175 ::com::sun::star::uno::Sequence < sal_Int8 > aSeq = SvGlobalName( SFX_GLOBAL_CLASSID ).GetByteSequence();
176 sal_Int64 nHandle = xObj->getSomething( aSeq );
177 if ( nHandle )
178 pObjShell = reinterpret_cast< SfxObjectShell* >( sal::static_int_cast< sal_IntPtr >( nHandle ));
179 }
180 }
181
182 SfxModule* pModule = pObjShell ? pObjShell->GetModule() : NULL;
183 SfxSlotPool* pSlotPool = 0;
184
185 if ( pModule )
186 pSlotPool = pModule->GetSlotPool();
187 else
188 pSlotPool = &(SfxSlotPool::GetSlotPool( NULL ));
189
190 const SfxSlot* pSlot = pSlotPool->GetUnoSlot( aTargetURL.Path );
191 if ( pSlot )
192 {
193 sal_uInt16 nSlotId = pSlot->GetSlotId();
194 if ( nSlotId > 0 )
195 return SfxToolBoxControl::CreateControl( nSlotId, nID, pToolbox, pModule );
196 }
197
198 return NULL;
199 }
200
201 struct SfxToolBoxControl_Impl
202 {
203 ToolBox* pBox;
204 sal_Bool bShowString;
205 sal_uInt16 nSelectModifier;
206 SfxTbxCtrlFactory* pFact;
207 sal_uInt16 nTbxId;
208 sal_uInt16 nSlotId;
209 SfxPopupWindow* mpFloatingWindow;
210 SfxPopupWindow* mpPopupWindow;
211 Reference< XUIElement > mxUIElement;
212
213 DECL_LINK( WindowEventListener, VclSimpleEvent* );
214 };
215
IMPL_LINK(SfxToolBoxControl_Impl,WindowEventListener,VclSimpleEvent *,pEvent)216 IMPL_LINK( SfxToolBoxControl_Impl, WindowEventListener, VclSimpleEvent*, pEvent )
217 {
218 if ( pEvent &&
219 pEvent->ISA( VclWindowEvent ) &&
220 (( pEvent->GetId() == VCLEVENT_WINDOW_MOVE ) ||
221 ( pEvent->GetId() == VCLEVENT_WINDOW_ACTIVATE )))
222 {
223 Window* pWindow( ((VclWindowEvent*)pEvent)->GetWindow() );
224 if (( pWindow == mpFloatingWindow ) &&
225 ( mpPopupWindow != 0 ))
226 {
227 delete mpPopupWindow;
228 mpPopupWindow = 0;
229 }
230 }
231
232 return 1;
233 }
234
235 //--------------------------------------------------------------------
236
SfxToolBoxControl(sal_uInt16 nSlotID,sal_uInt16 nID,ToolBox & rBox,sal_Bool bShowStringItems)237 SfxToolBoxControl::SfxToolBoxControl(
238 sal_uInt16 nSlotID,
239 sal_uInt16 nID,
240 ToolBox& rBox,
241 sal_Bool bShowStringItems )
242 : svt::ToolboxController()
243 {
244 pImpl = new SfxToolBoxControl_Impl;
245
246 pImpl->pBox = &rBox;
247 pImpl->bShowString = bShowStringItems;
248 pImpl->nSelectModifier = 0;
249 pImpl->pFact = 0;
250 pImpl->nTbxId = nID;
251 pImpl->nSlotId = nSlotID;
252 pImpl->mpFloatingWindow = 0;
253 pImpl->mpPopupWindow = 0;
254 }
255
256 //--------------------------------------------------------------------
257
~SfxToolBoxControl()258 SfxToolBoxControl::~SfxToolBoxControl()
259 {
260 if ( pImpl->mxUIElement.is() )
261 {
262 Reference< XComponent > xComponent( pImpl->mxUIElement, UNO_QUERY );
263 xComponent->dispose();
264 }
265 pImpl->mxUIElement = 0;
266 delete pImpl;
267 }
268
269 //--------------------------------------------------------------------
270
GetToolBox() const271 ToolBox& SfxToolBoxControl::GetToolBox() const
272 {
273 return *pImpl->pBox;
274 }
GetId() const275 unsigned short SfxToolBoxControl::GetId() const
276 {
277 return pImpl->nTbxId;
278 }
GetSlotId() const279 unsigned short SfxToolBoxControl::GetSlotId() const
280 {
281 return pImpl->nSlotId;
282 }
283
284 //--------------------------------------------------------------------
285
dispose()286 void SAL_CALL SfxToolBoxControl::dispose() throw (::com::sun::star::uno::RuntimeException)
287 {
288 if ( m_bDisposed )
289 return;
290
291 svt::ToolboxController::dispose();
292
293 // Remove and destroy our item window at our toolbox
294 ::vos::OGuard aGuard( Application::GetSolarMutex() );
295 Window* pWindow = pImpl->pBox->GetItemWindow( pImpl->nTbxId );
296 pImpl->pBox->SetItemWindow( pImpl->nTbxId, 0 );
297 delete pWindow;
298
299 // Dispose an open sub toolbar. It's possible that we have an open
300 // sub toolbar while we get disposed. Therefore we have to dispose
301 // it now! Not doing so would result in a crash. The sub toolbar
302 // gets destroyed asynchronously and would access a non-existing
303 // parent toolbar! See #126569#
304 if ( pImpl->mxUIElement.is() )
305 {
306 Reference< XComponent > xComponent( pImpl->mxUIElement, UNO_QUERY );
307 xComponent->dispose();
308 }
309 pImpl->mxUIElement = 0;
310
311 // Delete my popup windows
312 delete pImpl->mpFloatingWindow;
313 delete pImpl->mpPopupWindow;
314
315 pImpl->mpFloatingWindow = 0;
316 pImpl->mpPopupWindow = 0;
317 }
318
319 //--------------------------------------------------------------------
RegisterToolBoxControl(SfxModule * pMod,SfxTbxCtrlFactory * pFact)320 void SfxToolBoxControl::RegisterToolBoxControl( SfxModule* pMod, SfxTbxCtrlFactory* pFact)
321 {
322 SFX_APP()->RegisterToolBoxControl_Impl( pMod, pFact );
323 }
324
CreateControl(sal_uInt16 nSlotId,sal_uInt16 nTbxId,ToolBox * pBox,SfxModule * pMod)325 SfxToolBoxControl* SfxToolBoxControl::CreateControl( sal_uInt16 nSlotId, sal_uInt16 nTbxId, ToolBox *pBox, SfxModule* pMod )
326 {
327 ::vos::OGuard aGuard( Application::GetSolarMutex() );
328
329 SfxToolBoxControl *pCtrl;
330 SfxApplication *pApp = SFX_APP();
331
332 SfxSlotPool *pSlotPool;
333 if ( pMod )
334 pSlotPool = pMod->GetSlotPool();
335 else
336 pSlotPool = &SfxSlotPool::GetSlotPool();
337 TypeId aSlotType = pSlotPool->GetSlotType( nSlotId );
338 if ( aSlotType )
339 {
340 if ( pMod )
341 {
342 SfxTbxCtrlFactArr_Impl *pFactories = pMod->GetTbxCtrlFactories_Impl();
343 if ( pFactories )
344 {
345 SfxTbxCtrlFactArr_Impl &rFactories = *pFactories;
346 sal_uInt16 nFactory;
347 const sal_uInt16 nCount = rFactories.Count();
348
349 // search for a factory with the given slot id
350 for( nFactory = 0; nFactory < nCount; ++nFactory )
351 if( (rFactories[nFactory]->nTypeId == aSlotType) && (rFactories[nFactory]->nSlotId == nSlotId) )
352 break;
353
354 if( nFactory == nCount )
355 {
356 // if no factory exists for the given slot id, see if we
357 // have a generic factory with the correct slot type and slot id == 0
358 for ( nFactory = 0; nFactory < nCount; ++nFactory )
359 if( (rFactories[nFactory]->nTypeId == aSlotType) && (rFactories[nFactory]->nSlotId == 0) )
360 break;
361 }
362
363 if( nFactory < nCount )
364 {
365 pCtrl = rFactories[nFactory]->pCtor( nSlotId, nTbxId, *pBox );
366 pCtrl->pImpl->pFact = rFactories[nFactory];
367 return pCtrl;
368 }
369 }
370 }
371
372 SfxTbxCtrlFactArr_Impl &rFactories = pApp->GetTbxCtrlFactories_Impl();
373 sal_uInt16 nFactory;
374 const sal_uInt16 nCount = rFactories.Count();
375
376 for( nFactory = 0; nFactory < nCount; ++nFactory )
377 if( (rFactories[nFactory]->nTypeId == aSlotType) && (rFactories[nFactory]->nSlotId == nSlotId) )
378 break;
379
380 if( nFactory == nCount )
381 {
382 // if no factory exists for the given slot id, see if we
383 // have a generic factory with the correct slot type and slot id == 0
384 for( nFactory = 0; nFactory < nCount; ++nFactory )
385 if( (rFactories[nFactory]->nTypeId == aSlotType) && (rFactories[nFactory]->nSlotId == 0) )
386 break;
387 }
388
389 if( nFactory < nCount )
390 {
391 pCtrl = rFactories[nFactory]->pCtor( nSlotId, nTbxId, *pBox );
392 pCtrl->pImpl->pFact = rFactories[nFactory];
393 return pCtrl;
394 }
395 }
396
397 return NULL;
398 }
399
GetItemState(const SfxPoolItem * pState)400 SfxItemState SfxToolBoxControl::GetItemState(
401 const SfxPoolItem* pState )
402 /* [Beschreibung]
403
404 Statische Methode zum Ermitteln des Status des SfxPoolItem-Pointers,
405 in der Methode <SfxControllerItem::StateChanged(const SfxPoolItem*)>
406 zu verwenden.
407
408 [R"uckgabewert]
409
410 SfxItemState SFX_ITEM_UNKNOWN
411 Enabled, aber keine weitere Statusinformation
412 verf"ugbar. Typisch f"ur <Slot>s, die allenfalls
413 zeitweise disabled sind, aber ihre Darstellung sonst
414 nicht "andern.
415
416 SFX_ITEM_DISABLED
417 Disabled und keine weiter Statusinformation
418 verf"ugbar. Alle anderen ggf. angezeigten Werte sollten
419 auf den Default zur"uckgesetzt werden.
420
421 SFX_ITEM_DONTCARE
422 Enabled aber es waren nur uneindeutige Werte
423 verf"ugbar (also keine, die abgefragt werden k"onnen).
424
425 SFX_ITEM_AVAILABLE
426 Enabled und mit verf"ugbarem Wert, der von 'pState'
427 erfragbar ist. Der Typ ist dabei im gesamten
428 Programm eindeutig und durch den Slot festgelegt.
429 */
430
431 {
432 return !pState
433 ? SFX_ITEM_DISABLED
434 : IsInvalidItem(pState)
435 ? SFX_ITEM_DONTCARE
436 : pState->ISA(SfxVoidItem) && !pState->Which()
437 ? SFX_ITEM_UNKNOWN
438 : SFX_ITEM_AVAILABLE;
439 }
440
Dispatch(const Reference<XDispatchProvider> & rProvider,const rtl::OUString & rCommand,Sequence<::PropertyValue> & aArgs)441 void SfxToolBoxControl::Dispatch(
442 const Reference< XDispatchProvider >& rProvider,
443 const rtl::OUString& rCommand,
444 Sequence< ::PropertyValue >& aArgs )
445 {
446 if ( rProvider.is() )
447 {
448 ::com::sun::star::util::URL aTargetURL;
449 aTargetURL.Complete = rCommand;
450 Reference < XURLTransformer > xTrans( ::comphelper::getProcessServiceFactory()->createInstance(
451 rtl::OUString::createFromAscii("com.sun.star.util.URLTransformer" )),
452 UNO_QUERY );
453 xTrans->parseStrict( aTargetURL );
454
455 Reference < XDispatch > xDispatch = rProvider->queryDispatch( aTargetURL, ::rtl::OUString(), 0 );
456 if ( xDispatch.is() )
457 xDispatch->dispatch( aTargetURL, aArgs );
458 }
459 }
460
Dispatch(const::rtl::OUString & aCommand,::com::sun::star::uno::Sequence<::com::sun::star::beans::PropertyValue> & aArgs)461 void SfxToolBoxControl::Dispatch( const ::rtl::OUString& aCommand, ::com::sun::star::uno::Sequence< ::com::sun::star::beans::PropertyValue >& aArgs )
462 {
463 Reference < XController > xController;
464
465 ::vos::OGuard aGuard( Application::GetSolarMutex() );
466 if ( getFrameInterface().is() )
467 xController = getFrameInterface()->getController();
468
469 Reference < XDispatchProvider > xProvider( xController, UNO_QUERY );
470 if ( xProvider.is() )
471 {
472 ::com::sun::star::util::URL aTargetURL;
473 aTargetURL.Complete = aCommand;
474 getURLTransformer()->parseStrict( aTargetURL );
475
476 Reference < XDispatch > xDispatch = xProvider->queryDispatch( aTargetURL, ::rtl::OUString(), 0 );
477 if ( xDispatch.is() )
478 {
479 if(::comphelper::UiEventsLogger::isEnabled()) //#i88653#
480 {
481 ::rtl::OUString sAppName;
482 try
483 {
484 static ::rtl::OUString our_aModuleManagerName = ::rtl::OUString::createFromAscii("com.sun.star.frame.ModuleManager");
485 ::com::sun::star::uno::Reference< ::com::sun::star::lang::XMultiServiceFactory > xServiceManager =
486 ::comphelper::getProcessServiceFactory();
487 ::com::sun::star::uno::Reference< ::com::sun::star::frame::XModuleManager > xModuleManager(
488 xServiceManager->createInstance(our_aModuleManagerName)
489 , ::com::sun::star::uno::UNO_QUERY_THROW);
490 ::com::sun::star::uno::Reference < ::com::sun::star::frame::XFrame > xFrame(
491 getFrameInterface(), UNO_QUERY_THROW);
492 sAppName = xModuleManager->identify(xFrame);
493 } catch(::com::sun::star::uno::Exception&) {}
494 Sequence<PropertyValue> source;
495 ::comphelper::UiEventsLogger::appendDispatchOrigin(source, sAppName, ::rtl::OUString::createFromAscii("SfxToolBoxControl"));
496 ::comphelper::UiEventsLogger::logDispatch(aTargetURL, source);
497 }
498 xDispatch->dispatch( aTargetURL, aArgs );
499 }
500 }
501 }
502
503 // XInterface
queryInterface(const Type & rType)504 Any SAL_CALL SfxToolBoxControl::queryInterface( const Type & rType )
505 throw(::com::sun::star::uno::RuntimeException)
506 {
507 ::com::sun::star::uno::Any aRet = ::cppu::queryInterface( rType,
508 SAL_STATIC_CAST( ::com::sun::star::awt::XDockableWindowListener*, this ),
509 SAL_STATIC_CAST( ::com::sun::star::frame::XSubToolbarController*, this ));
510 return (aRet.hasValue() ? aRet : svt::ToolboxController::queryInterface( rType ));
511 }
512
acquire()513 void SAL_CALL SfxToolBoxControl::acquire() throw()
514 {
515 OWeakObject::acquire();
516 }
517
release()518 void SAL_CALL SfxToolBoxControl::release() throw()
519 {
520 OWeakObject::release();
521 }
522
disposing(const::com::sun::star::lang::EventObject & aEvent)523 void SAL_CALL SfxToolBoxControl::disposing( const ::com::sun::star::lang::EventObject& aEvent )
524 throw( ::com::sun::star::uno::RuntimeException )
525 {
526 svt::ToolboxController::disposing( aEvent );
527 }
528
529 // XStatusListener
statusChanged(const FeatureStateEvent & rEvent)530 void SAL_CALL SfxToolBoxControl::statusChanged( const FeatureStateEvent& rEvent )
531 throw ( ::com::sun::star::uno::RuntimeException )
532 {
533 SfxViewFrame* pViewFrame = NULL;
534 Reference < XController > xController;
535
536 ::vos::OGuard aGuard( Application::GetSolarMutex() );
537 if ( getFrameInterface().is() )
538 xController = getFrameInterface()->getController();
539
540 Reference < XDispatchProvider > xProvider( xController, UNO_QUERY );
541 if ( xProvider.is() )
542 {
543 Reference < XDispatch > xDisp = xProvider->queryDispatch( rEvent.FeatureURL, ::rtl::OUString(), 0 );
544 if ( xDisp.is() )
545 {
546 Reference< XUnoTunnel > xTunnel( xDisp, UNO_QUERY );
547 SfxOfficeDispatch* pDisp = NULL;
548 if ( xTunnel.is() )
549 {
550 sal_Int64 nImplementation = xTunnel->getSomething(SfxOfficeDispatch::impl_getStaticIdentifier());
551 pDisp = reinterpret_cast< SfxOfficeDispatch* >( sal::static_int_cast< sal_IntPtr >( nImplementation ));
552 }
553
554 if ( pDisp )
555 pViewFrame = pDisp->GetDispatcher_Impl()->GetFrame();
556 }
557 }
558
559 sal_uInt16 nSlotId = 0;
560 SfxSlotPool& rPool = SfxSlotPool::GetSlotPool( pViewFrame );
561 const SfxSlot* pSlot = rPool.GetUnoSlot( rEvent.FeatureURL.Path );
562 if ( pSlot )
563 nSlotId = pSlot->GetSlotId();
564 else if ( m_aCommandURL == rEvent.FeatureURL.Path )
565 nSlotId = GetSlotId();
566
567 if ( nSlotId > 0 )
568 {
569 if ( rEvent.Requery )
570 svt::ToolboxController::statusChanged( rEvent );
571 else
572 {
573 SfxItemState eState = SFX_ITEM_DISABLED;
574 SfxPoolItem* pItem = NULL;
575 if ( rEvent.IsEnabled )
576 {
577 eState = SFX_ITEM_AVAILABLE;
578 ::com::sun::star::uno::Type pType = rEvent.State.getValueType();
579
580 if ( pType == ::getVoidCppuType() )
581 {
582 pItem = new SfxVoidItem( nSlotId );
583 eState = SFX_ITEM_UNKNOWN;
584 }
585 else if ( pType == ::getBooleanCppuType() )
586 {
587 sal_Bool bTemp = false;
588 rEvent.State >>= bTemp ;
589 pItem = new SfxBoolItem( nSlotId, bTemp );
590 }
591 else if ( pType == ::getCppuType((const sal_uInt16*)0) )
592 {
593 sal_uInt16 nTemp = 0;
594 rEvent.State >>= nTemp ;
595 pItem = new SfxUInt16Item( nSlotId, nTemp );
596 }
597 else if ( pType == ::getCppuType((const sal_uInt32*)0) )
598 {
599 sal_uInt32 nTemp = 0;
600 rEvent.State >>= nTemp ;
601 pItem = new SfxUInt32Item( nSlotId, nTemp );
602 }
603 else if ( pType == ::getCppuType((const ::rtl::OUString*)0) )
604 {
605 ::rtl::OUString sTemp ;
606 rEvent.State >>= sTemp ;
607 pItem = new SfxStringItem( nSlotId, sTemp );
608 }
609 else if ( pType == ::getCppuType((const ::com::sun::star::frame::status::ItemStatus*)0) )
610 {
611 ItemStatus aItemStatus;
612 rEvent.State >>= aItemStatus;
613 eState = aItemStatus.State;
614 pItem = new SfxVoidItem( nSlotId );
615 }
616 else if ( pType == ::getCppuType((const ::com::sun::star::frame::status::Visibility*)0) )
617 {
618 Visibility aVisibilityStatus;
619 rEvent.State >>= aVisibilityStatus;
620 pItem = new SfxVisibilityItem( nSlotId, aVisibilityStatus.bVisible );
621 }
622 else
623 {
624 if ( pSlot )
625 pItem = pSlot->GetType()->CreateItem();
626 if ( pItem )
627 {
628 pItem->SetWhich( nSlotId );
629 pItem->PutValue( rEvent.State );
630 }
631 else
632 pItem = new SfxVoidItem( nSlotId );
633 }
634 }
635
636 StateChanged( nSlotId, eState, pItem );
637 delete pItem;
638 }
639 }
640 }
641
642 // XSubToolbarController
opensSubToolbar()643 ::sal_Bool SAL_CALL SfxToolBoxControl::opensSubToolbar() throw (::com::sun::star::uno::RuntimeException)
644 {
645 return sal_False;
646 }
647
getSubToolbarName()648 ::rtl::OUString SAL_CALL SfxToolBoxControl::getSubToolbarName() throw (::com::sun::star::uno::RuntimeException)
649 {
650 return rtl::OUString();
651 }
652
functionSelected(const::rtl::OUString &)653 void SAL_CALL SfxToolBoxControl::functionSelected( const ::rtl::OUString& /*aCommand*/ ) throw (::com::sun::star::uno::RuntimeException)
654 {
655 // must be implemented by sub-class
656 }
657
updateImage()658 void SAL_CALL SfxToolBoxControl::updateImage() throw (::com::sun::star::uno::RuntimeException)
659 {
660 // must be implemented by sub-class
661 }
662
663 // XToolbarController
execute(sal_Int16 KeyModifier)664 void SAL_CALL SfxToolBoxControl::execute( sal_Int16 KeyModifier ) throw (::com::sun::star::uno::RuntimeException)
665 {
666 ::vos::OGuard aGuard( Application::GetSolarMutex() );
667 Select( (sal_uInt16)KeyModifier );
668 }
click()669 void SAL_CALL SfxToolBoxControl::click() throw (::com::sun::star::uno::RuntimeException)
670 {
671 ::vos::OGuard aGuard( Application::GetSolarMutex() );
672 Click();
673 }
674
doubleClick()675 void SAL_CALL SfxToolBoxControl::doubleClick() throw (::com::sun::star::uno::RuntimeException)
676 {
677 ::vos::OGuard aGuard( Application::GetSolarMutex() );
678 DoubleClick();
679 }
680
createPopupWindow()681 Reference< ::com::sun::star::awt::XWindow > SAL_CALL SfxToolBoxControl::createPopupWindow() throw (::com::sun::star::uno::RuntimeException)
682 {
683 ::vos::OGuard aGuard( Application::GetSolarMutex() );
684 Window* pWindow = CreatePopupWindow();
685 if ( pWindow )
686 return VCLUnoHelper::GetInterface( pWindow );
687 else
688 return Reference< ::com::sun::star::awt::XWindow >();
689 }
690
createItemWindow(const Reference<::com::sun::star::awt::XWindow> & rParent)691 Reference< ::com::sun::star::awt::XWindow > SAL_CALL SfxToolBoxControl::createItemWindow( const Reference< ::com::sun::star::awt::XWindow >& rParent ) throw (::com::sun::star::uno::RuntimeException)
692 {
693 ::vos::OGuard aGuard( Application::GetSolarMutex() );
694 return VCLUnoHelper::GetInterface( CreateItemWindow( VCLUnoHelper::GetWindow( rParent )));
695 }
696
697 // XDockableWindowListener
startDocking(const::com::sun::star::awt::DockingEvent &)698 void SAL_CALL SfxToolBoxControl::startDocking( const ::com::sun::star::awt::DockingEvent& )
699 throw (::com::sun::star::uno::RuntimeException)
700 {
701 }
docking(const::com::sun::star::awt::DockingEvent &)702 ::com::sun::star::awt::DockingData SAL_CALL SfxToolBoxControl::docking( const ::com::sun::star::awt::DockingEvent& )
703 throw (::com::sun::star::uno::RuntimeException)
704 {
705 return ::com::sun::star::awt::DockingData();
706 }
707
endDocking(const::com::sun::star::awt::EndDockingEvent &)708 void SAL_CALL SfxToolBoxControl::endDocking( const ::com::sun::star::awt::EndDockingEvent& )
709 throw (::com::sun::star::uno::RuntimeException)
710 {
711 }
712
prepareToggleFloatingMode(const::com::sun::star::lang::EventObject &)713 sal_Bool SAL_CALL SfxToolBoxControl::prepareToggleFloatingMode( const ::com::sun::star::lang::EventObject& )
714 throw (::com::sun::star::uno::RuntimeException)
715 {
716 return sal_False;
717 }
718
toggleFloatingMode(const::com::sun::star::lang::EventObject &)719 void SAL_CALL SfxToolBoxControl::toggleFloatingMode( const ::com::sun::star::lang::EventObject& )
720 throw (::com::sun::star::uno::RuntimeException)
721 {
722 }
723
closed(const::com::sun::star::lang::EventObject &)724 void SAL_CALL SfxToolBoxControl::closed( const ::com::sun::star::lang::EventObject& )
725 throw (::com::sun::star::uno::RuntimeException)
726 {
727 }
728
endPopupMode(const::com::sun::star::awt::EndPopupModeEvent & aEvent)729 void SAL_CALL SfxToolBoxControl::endPopupMode( const ::com::sun::star::awt::EndPopupModeEvent& aEvent )
730 throw (::com::sun::star::uno::RuntimeException)
731 {
732 ::vos::OGuard aGuard( Application::GetSolarMutex() );
733
734 ::rtl::OUString aSubToolBarResName;
735 if ( pImpl->mxUIElement.is() )
736 {
737 Reference< XPropertySet > xPropSet( pImpl->mxUIElement, UNO_QUERY );
738 if ( xPropSet.is() )
739 {
740 try
741 {
742 xPropSet->getPropertyValue( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "ResourceURL" ))) >>= aSubToolBarResName;
743 }
744 catch ( com::sun::star::beans::UnknownPropertyException& )
745 {
746 }
747 catch ( com::sun::star::lang::WrappedTargetException& )
748 {
749 }
750 }
751
752 Reference< XComponent > xComponent( pImpl->mxUIElement, UNO_QUERY );
753 xComponent->dispose();
754 }
755 pImpl->mxUIElement = 0;
756
757 // if the toolbar was teared-off recreate it and place it at the given position
758 if( aEvent.bTearoff )
759 {
760 Reference< XUIElement > xUIElement;
761 Reference< XLayoutManager > xLayoutManager = getLayoutManager();
762
763 if ( !xLayoutManager.is() )
764 return;
765
766 xLayoutManager->createElement( aSubToolBarResName );
767 xUIElement = xLayoutManager->getElement( aSubToolBarResName );
768 if ( xUIElement.is() )
769 {
770 Reference< ::com::sun::star::awt::XWindow > xParent = getFrameInterface()->getContainerWindow();
771
772 Reference< ::com::sun::star::awt::XWindow > xSubToolBar( xUIElement->getRealInterface(), UNO_QUERY );
773 Reference< ::com::sun::star::beans::XPropertySet > xProp( xUIElement, UNO_QUERY );
774 if ( xSubToolBar.is() && xProp.is() )
775 {
776 rtl::OUString aPersistentString( RTL_CONSTASCII_USTRINGPARAM( "Persistent" ));
777 try
778 {
779 Window* pTbxWindow = VCLUnoHelper::GetWindow( xSubToolBar );
780 ToolBox* pToolBar( 0 );
781 if ( pTbxWindow && pTbxWindow->GetType() == WINDOW_TOOLBOX )
782 {
783 pToolBar = (ToolBox *)pTbxWindow;
784
785 Any a;
786 a = xProp->getPropertyValue( aPersistentString );
787 xProp->setPropertyValue( aPersistentString, makeAny( sal_False ));
788
789 xLayoutManager->hideElement( aSubToolBarResName );
790 xLayoutManager->floatWindow( aSubToolBarResName );
791
792 xLayoutManager->setElementPos( aSubToolBarResName, aEvent.FloatingPosition );
793 xLayoutManager->showElement( aSubToolBarResName );
794
795 xProp->setPropertyValue( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Persistent" )), a );
796 }
797 }
798 catch ( ::com::sun::star::uno::RuntimeException& )
799 {
800 throw;
801 }
802 catch ( ::com::sun::star::uno::Exception& )
803 {
804 }
805 }
806 }
807 }
808 }
809
getPersistentFloatingSize(const Reference<XFrame> &,const::rtl::OUString &)810 ::Size SfxToolBoxControl::getPersistentFloatingSize( const Reference< XFrame >& /*xFrame*/, const ::rtl::OUString& /*rSubToolBarResName*/ )
811 {
812 ::Size aToolboxSize;
813 return aToolboxSize;
814 }
815
createAndPositionSubToolBar(const::rtl::OUString & rSubToolBarResName)816 void SfxToolBoxControl::createAndPositionSubToolBar( const ::rtl::OUString& rSubToolBarResName )
817 {
818 ::vos::OGuard aGuard( Application::GetSolarMutex() );
819
820 if ( pImpl->pBox )
821 {
822 static WeakReference< XUIElementFactory > xWeakUIElementFactory;
823
824 sal_uInt16 nItemId = pImpl->pBox->GetDownItemId();
825
826 if ( !nItemId )
827 return;
828
829 // create element with factory
830 Reference< XMultiServiceFactory > xServiceManager = getServiceManager();
831 Reference< XFrame > xFrame = getFrameInterface();
832 Reference< XUIElement > xUIElement;
833 Reference< XUIElementFactory > xUIEementFactory;
834
835 xUIEementFactory = xWeakUIElementFactory;
836 if ( !xUIEementFactory.is() )
837 {
838 xUIEementFactory = Reference< XUIElementFactory >(
839 xServiceManager->createInstance(
840 rtl::OUString( RTL_CONSTASCII_USTRINGPARAM(
841 "com.sun.star.ui.UIElementFactoryManager" ))),
842 UNO_QUERY );
843 xWeakUIElementFactory = xUIEementFactory;
844 }
845
846 Sequence< PropertyValue > aPropSeq( 3 );
847 aPropSeq[0].Name = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Frame" ));
848 aPropSeq[0].Value <<= xFrame;
849 aPropSeq[1].Name = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Persistent" ));
850 aPropSeq[1].Value <<= sal_False;
851 aPropSeq[2].Name = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "PopupMode" ));
852 aPropSeq[2].Value <<= sal_True;
853
854 try
855 {
856 xUIElement = xUIEementFactory->createUIElement( rSubToolBarResName, aPropSeq );
857 }
858 catch ( ::com::sun::star::container::NoSuchElementException& )
859 {
860 }
861 catch ( IllegalArgumentException& )
862 {
863 }
864
865 if ( xUIElement.is() )
866 {
867 Reference< ::com::sun::star::awt::XWindow > xParent = getFrameInterface()->getContainerWindow();
868
869 Reference< ::com::sun::star::awt::XWindow > xSubToolBar( xUIElement->getRealInterface(), UNO_QUERY );
870 if ( xSubToolBar.is() )
871 {
872 Reference< ::com::sun::star::awt::XDockableWindow > xDockWindow( xSubToolBar, UNO_QUERY );
873 xDockWindow->addDockableWindowListener( Reference< ::com::sun::star::awt::XDockableWindowListener >(
874 static_cast< OWeakObject * >( this ), UNO_QUERY ));
875 xDockWindow->enableDocking( sal_True );
876
877 // keep refererence to UIElement to avoid its destruction
878 if ( pImpl->mxUIElement.is() )
879 {
880 Reference< XComponent > xComponent( pImpl->mxUIElement, UNO_QUERY );
881 xComponent->dispose();
882 }
883 pImpl->mxUIElement = xUIElement;
884
885 Window* pParentTbxWindow( pImpl->pBox );
886 Window* pTbxWindow = VCLUnoHelper::GetWindow( xSubToolBar );
887 ToolBox* pToolBar( 0 );
888 if ( pTbxWindow && pTbxWindow->GetType() == WINDOW_TOOLBOX )
889 pToolBar = (ToolBox *)pTbxWindow;
890
891 if ( pToolBar )
892 {
893 pToolBar->SetParent( pParentTbxWindow );
894 ::Size aSize = getPersistentFloatingSize( xFrame, rSubToolBarResName );
895 if ( aSize.Width() == 0 || aSize.Height() == 0 )
896 {
897 // calc and set size for popup mode
898 aSize = pToolBar->CalcPopupWindowSizePixel();
899 }
900 pToolBar->SetSizePixel( aSize );
901
902 // open subtoolbox in popup mode
903 Window::GetDockingManager()->StartPopupMode( pImpl->pBox, pToolBar );
904 }
905 }
906 }
907 }
908 }
909
910 //--------------------------------------------------------------------
911
SetPopupWindow(SfxPopupWindow * pWindow)912 void SfxToolBoxControl::SetPopupWindow( SfxPopupWindow* pWindow )
913 {
914 pImpl->mpPopupWindow = pWindow;
915 pImpl->mpPopupWindow->SetPopupModeEndHdl( LINK( this, SfxToolBoxControl, PopupModeEndHdl ));
916 pImpl->mpPopupWindow->SetDeleteLink_Impl( LINK( this, SfxToolBoxControl, ClosePopupWindow ));
917 }
918
919 //--------------------------------------------------------------------
920
IMPL_LINK(SfxToolBoxControl,PopupModeEndHdl,void *,EMPTYARG)921 IMPL_LINK( SfxToolBoxControl, PopupModeEndHdl, void *, EMPTYARG )
922 {
923 if ( pImpl->mpPopupWindow->IsVisible() )
924 {
925 // Replace floating window with popup window and destroy
926 // floating window instance.
927 delete pImpl->mpFloatingWindow;
928 pImpl->mpFloatingWindow = pImpl->mpPopupWindow;
929 pImpl->mpPopupWindow = 0;
930 // We also need to know when the user tries to use the
931 // floating window.
932 pImpl->mpFloatingWindow->AddEventListener( LINK( pImpl, SfxToolBoxControl_Impl, WindowEventListener ));
933 }
934 else
935 {
936 // Popup window has been closed by the user. No replacement, instance
937 // will destroy itself.
938 pImpl->mpPopupWindow = 0;
939 }
940
941 return 1;
942 }
943
944 //--------------------------------------------------------------------
IMPL_LINK(SfxToolBoxControl,ClosePopupWindow,SfxPopupWindow *,pWindow)945 IMPL_LINK( SfxToolBoxControl, ClosePopupWindow, SfxPopupWindow *, pWindow )
946 {
947 if ( pWindow == pImpl->mpFloatingWindow )
948 pImpl->mpFloatingWindow = 0;
949 else
950 pImpl->mpPopupWindow = 0;
951
952 return 1;
953 }
954
955 //--------------------------------------------------------------------
956
StateChanged(sal_uInt16 nId,SfxItemState eState,const SfxPoolItem * pState)957 void SfxToolBoxControl::StateChanged
958 (
959 sal_uInt16 nId,
960 SfxItemState eState,
961 const SfxPoolItem* pState
962 )
963 {
964 DBG_MEMTEST();
965 DBG_ASSERT( pImpl->pBox != 0, "setting state to dangling ToolBox" );
966
967 if ( GetId() >= SID_OBJECTMENU0 && GetId() <= SID_OBJECTMENU_LAST )
968 return;
969
970 // enabled/disabled-Flag pauschal korrigieren
971 pImpl->pBox->EnableItem( GetId(), eState != SFX_ITEM_DISABLED );
972
973 sal_uInt16 nItemBits = pImpl->pBox->GetItemBits( GetId() );
974 nItemBits &= ~TIB_CHECKABLE;
975 TriState eTri = STATE_NOCHECK;
976 switch ( eState )
977 {
978 case SFX_ITEM_AVAILABLE:
979 {
980 if ( pState->ISA(SfxBoolItem) )
981 {
982 // BoolItem fuer checken
983 if ( ((const SfxBoolItem*)pState)->GetValue() )
984 eTri = STATE_CHECK;
985 nItemBits |= TIB_CHECKABLE;
986 }
987 else if ( pState->ISA(SfxEnumItemInterface) &&
988 ((SfxEnumItemInterface *)pState)->HasBoolValue())
989 {
990 // EnumItem wie Bool behandeln
991 if ( ((const SfxEnumItemInterface *)pState)->GetBoolValue() )
992 eTri = STATE_CHECK;
993 nItemBits |= TIB_CHECKABLE;
994 }
995 else if ( pImpl->bShowString && pState->ISA(SfxStringItem) )
996 pImpl->pBox->SetItemText(nId, ((const SfxStringItem*)pState)->GetValue() );
997 break;
998 }
999
1000 case SFX_ITEM_DONTCARE:
1001 {
1002 eTri = STATE_DONTKNOW;
1003 nItemBits |= TIB_CHECKABLE;
1004 }
1005 }
1006
1007 pImpl->pBox->SetItemState( GetId(), eTri );
1008 pImpl->pBox->SetItemBits( GetId(), nItemBits );
1009 }
1010
1011 //--------------------------------------------------------------------
1012
Select(sal_uInt16 nModifier)1013 void SfxToolBoxControl::Select( sal_uInt16 nModifier )
1014 {
1015 pImpl->nSelectModifier = nModifier;
1016 Select( sal_Bool((nModifier & KEY_MOD1)!=0) );
1017 }
1018
1019 //--------------------------------------------------------------------
1020
Select(sal_Bool)1021 void SfxToolBoxControl::Select( sal_Bool /*bMod1*/ )
1022 {
1023 if(::comphelper::UiEventsLogger::isEnabled()) //#i88653# #i102805#
1024 {
1025 ::rtl::OUString sAppName;
1026 try
1027 {
1028 static ::rtl::OUString our_aModuleManagerName = ::rtl::OUString::createFromAscii("com.sun.star.frame.ModuleManager");
1029 ::com::sun::star::uno::Reference< ::com::sun::star::lang::XMultiServiceFactory > xServiceManager =
1030 ::comphelper::getProcessServiceFactory();
1031 ::com::sun::star::uno::Reference< ::com::sun::star::frame::XModuleManager > xModuleManager(
1032 xServiceManager->createInstance(our_aModuleManagerName)
1033 , ::com::sun::star::uno::UNO_QUERY_THROW);
1034 sAppName = xModuleManager->identify(m_xFrame);
1035 } catch(::com::sun::star::uno::Exception&) {}
1036 Sequence<PropertyValue> vSource;
1037 ::comphelper::UiEventsLogger::appendDispatchOrigin(vSource, sAppName, ::rtl::OUString::createFromAscii("SfxToolBoxControl"));
1038 URL aURL;
1039 aURL.Complete = m_aCommandURL;
1040 ::comphelper::UiEventsLogger::logDispatch(aURL, vSource);
1041 }
1042 svt::ToolboxController::execute( pImpl->nSelectModifier );
1043 }
1044
1045 //--------------------------------------------------------------------
1046
DoubleClick()1047 void SfxToolBoxControl::DoubleClick()
1048 {
1049 }
1050
1051 //--------------------------------------------------------------------
1052
Click()1053 void SfxToolBoxControl::Click()
1054 {
1055 }
1056
1057 //--------------------------------------------------------------------
1058
GetPopupWindowType() const1059 SfxPopupWindowType SfxToolBoxControl::GetPopupWindowType() const
1060 {
1061 return SFX_POPUPWINDOW_NONE;
1062 }
1063
1064 //--------------------------------------------------------------------
1065
CreatePopupWindow()1066 SfxPopupWindow* SfxToolBoxControl::CreatePopupWindow()
1067 {
1068 return 0;
1069 }
1070
CreatePopupWindowCascading()1071 SfxPopupWindow* SfxToolBoxControl::CreatePopupWindowCascading()
1072 {
1073 return 0;
1074 }
1075
1076 //--------------------------------------------------------------------
1077
CreateItemWindow(Window *)1078 Window* SfxToolBoxControl::CreateItemWindow( Window * )
1079 {
1080 return 0;
1081 }
1082
1083 //--------------------------------------------------------------------
1084
SfxFrameStatusListener(const Reference<XMultiServiceFactory> & rServiceManager,const Reference<XFrame> & xFrame,SfxStatusListenerInterface * pCallee)1085 SfxFrameStatusListener::SfxFrameStatusListener(
1086 const Reference< XMultiServiceFactory >& rServiceManager,
1087 const Reference< XFrame >& xFrame,
1088 SfxStatusListenerInterface* pCallee ) :
1089 svt::FrameStatusListener( rServiceManager, xFrame ),
1090 m_pCallee( pCallee )
1091 {
1092 }
1093
1094 //--------------------------------------------------------------------
1095
~SfxFrameStatusListener()1096 SfxFrameStatusListener::~SfxFrameStatusListener()
1097 {
1098 }
1099
1100 //--------------------------------------------------------------------
1101
1102 // XStatusListener
statusChanged(const::com::sun::star::frame::FeatureStateEvent & rEvent)1103 void SAL_CALL SfxFrameStatusListener::statusChanged( const ::com::sun::star::frame::FeatureStateEvent& rEvent )
1104 throw ( ::com::sun::star::uno::RuntimeException )
1105 {
1106 SfxViewFrame* pViewFrame = NULL;
1107 Reference < XController > xController;
1108
1109 ::vos::OGuard aGuard( Application::GetSolarMutex() );
1110 if ( m_xFrame.is() )
1111 xController = m_xFrame->getController();
1112
1113 Reference < XDispatchProvider > xProvider( xController, UNO_QUERY );
1114 if ( xProvider.is() )
1115 {
1116 Reference < XDispatch > xDisp = xProvider->queryDispatch( rEvent.FeatureURL, ::rtl::OUString(), 0 );
1117 if ( xDisp.is() )
1118 {
1119 Reference< XUnoTunnel > xTunnel( xDisp, UNO_QUERY );
1120 SfxOfficeDispatch* pDisp = NULL;
1121 if ( xTunnel.is() )
1122 {
1123 sal_Int64 nImplementation = xTunnel->getSomething(SfxOfficeDispatch::impl_getStaticIdentifier());
1124 pDisp = reinterpret_cast< SfxOfficeDispatch* >( sal::static_int_cast< sal_IntPtr >( nImplementation ));
1125 }
1126
1127 if ( pDisp )
1128 pViewFrame = pDisp->GetDispatcher_Impl()->GetFrame();
1129 }
1130 }
1131
1132 sal_uInt16 nSlotId = 0;
1133 SfxSlotPool& rPool = SfxSlotPool::GetSlotPool( pViewFrame );
1134 const SfxSlot* pSlot = rPool.GetUnoSlot( rEvent.FeatureURL.Path );
1135 if ( pSlot )
1136 nSlotId = pSlot->GetSlotId();
1137
1138 if ( nSlotId > 0 )
1139 {
1140 if ( rEvent.Requery )
1141 {
1142 // requery for the notified state
1143 addStatusListener( rEvent.FeatureURL.Complete );
1144 }
1145 else
1146 {
1147 SfxItemState eState = SFX_ITEM_DISABLED;
1148 SfxPoolItem* pItem = NULL;
1149 if ( rEvent.IsEnabled )
1150 {
1151 eState = SFX_ITEM_AVAILABLE;
1152 ::com::sun::star::uno::Type pType = rEvent.State.getValueType();
1153
1154 if ( pType == ::getVoidCppuType() )
1155 {
1156 pItem = new SfxVoidItem( nSlotId );
1157 eState = SFX_ITEM_UNKNOWN;
1158 }
1159 else if ( pType == ::getBooleanCppuType() )
1160 {
1161 sal_Bool bTemp = false;
1162 rEvent.State >>= bTemp ;
1163 pItem = new SfxBoolItem( nSlotId, bTemp );
1164 }
1165 else if ( pType == ::getCppuType((const sal_uInt16*)0) )
1166 {
1167 sal_uInt16 nTemp = 0;
1168 rEvent.State >>= nTemp ;
1169 pItem = new SfxUInt16Item( nSlotId, nTemp );
1170 }
1171 else if ( pType == ::getCppuType((const sal_uInt32*)0) )
1172 {
1173 sal_uInt32 nTemp = 0;
1174 rEvent.State >>= nTemp ;
1175 pItem = new SfxUInt32Item( nSlotId, nTemp );
1176 }
1177 else if ( pType == ::getCppuType((const ::rtl::OUString*)0) )
1178 {
1179 ::rtl::OUString sTemp ;
1180 rEvent.State >>= sTemp ;
1181 pItem = new SfxStringItem( nSlotId, sTemp );
1182 }
1183 else if ( pType == ::getCppuType((const ::com::sun::star::frame::status::ItemStatus*)0) )
1184 {
1185 ItemStatus aItemStatus;
1186 rEvent.State >>= aItemStatus;
1187 eState = aItemStatus.State;
1188 pItem = new SfxVoidItem( nSlotId );
1189 }
1190 else if ( pType == ::getCppuType((const ::com::sun::star::frame::status::Visibility*)0) )
1191 {
1192 Visibility aVisibilityStatus;
1193 rEvent.State >>= aVisibilityStatus;
1194 pItem = new SfxVisibilityItem( nSlotId, aVisibilityStatus.bVisible );
1195 }
1196 else
1197 {
1198 if ( pSlot )
1199 pItem = pSlot->GetType()->CreateItem();
1200 if ( pItem )
1201 {
1202 pItem->SetWhich( nSlotId );
1203 pItem->PutValue( rEvent.State );
1204 }
1205 else
1206 pItem = new SfxVoidItem( nSlotId );
1207 }
1208 }
1209
1210 if ( m_pCallee )
1211 m_pCallee->StateChanged( nSlotId, eState, pItem );
1212 delete pItem;
1213 }
1214 }
1215 }
1216
1217 //--------------------------------------------------------------------
1218
SfxPopupWindow(sal_uInt16 nId,const Reference<XFrame> & rFrame,WinBits nBits)1219 SfxPopupWindow::SfxPopupWindow(
1220 sal_uInt16 nId,
1221 const Reference< XFrame >& rFrame,
1222 WinBits nBits ) :
1223 FloatingWindow( SFX_APP()->GetTopWindow(), nBits )
1224 , m_bFloating(sal_False)
1225 , m_bCascading( sal_False )
1226 , m_nId( nId )
1227 , m_xFrame( rFrame )
1228 , m_pStatusListener( 0 )
1229 {
1230 m_xServiceManager = ::comphelper::getProcessServiceFactory();
1231
1232 Window* pWindow = GetTopMostParentSystemWindow( this );
1233 if ( pWindow )
1234 ((SystemWindow *)pWindow)->GetTaskPaneList()->AddWindow( this );
1235 }
1236
1237 //--------------------------------------------------------------------
1238
SfxPopupWindow(sal_uInt16 nId,const Reference<XFrame> & rFrame,const ResId & rId)1239 SfxPopupWindow::SfxPopupWindow(
1240 sal_uInt16 nId,
1241 const Reference< XFrame >& rFrame,
1242 const ResId &rId ) :
1243 FloatingWindow( SFX_APP()->GetTopWindow(), rId )
1244 , m_bFloating(sal_False)
1245 , m_bCascading( sal_False )
1246 , m_nId( nId )
1247 , m_xFrame( rFrame )
1248 , m_pStatusListener( 0 )
1249 {
1250 m_xServiceManager = ::comphelper::getProcessServiceFactory();
1251
1252 Window* pWindow = GetTopMostParentSystemWindow( this );
1253 if ( pWindow )
1254 ((SystemWindow *)pWindow)->GetTaskPaneList()->AddWindow( this );
1255 }
1256
1257 //--------------------------------------------------------------------
1258
SfxPopupWindow(sal_uInt16 nId,const Reference<XFrame> & rFrame,Window * pParentWindow,WinBits nBits)1259 SfxPopupWindow::SfxPopupWindow(
1260 sal_uInt16 nId,
1261 const Reference< XFrame >& rFrame,
1262 Window* pParentWindow,
1263 WinBits nBits ) :
1264 FloatingWindow( pParentWindow, nBits )
1265 , m_bFloating(sal_False)
1266 , m_bCascading( sal_False )
1267 , m_nId( nId )
1268 , m_xFrame( rFrame )
1269 , m_pStatusListener( 0 )
1270 {
1271 m_xServiceManager = ::comphelper::getProcessServiceFactory();
1272
1273 Window* pWindow = GetTopMostParentSystemWindow( this );
1274 if ( pWindow )
1275 ((SystemWindow *)pWindow)->GetTaskPaneList()->AddWindow( this );
1276 }
1277
1278 //--------------------------------------------------------------------
1279
SfxPopupWindow(sal_uInt16 nId,const::com::sun::star::uno::Reference<::com::sun::star::frame::XFrame> & rFrame,Window * pParentWindow,const ResId & rId)1280 SfxPopupWindow::SfxPopupWindow(
1281 sal_uInt16 nId,
1282 const ::com::sun::star::uno::Reference< ::com::sun::star::frame::XFrame >& rFrame,
1283 Window* pParentWindow,
1284 const ResId &rId ) :
1285 FloatingWindow( pParentWindow, rId )
1286 , m_bFloating(sal_False)
1287 , m_bCascading( sal_False )
1288 , m_nId( nId )
1289 , m_xFrame( rFrame )
1290 , m_pStatusListener( 0 )
1291 {
1292 m_xServiceManager = ::comphelper::getProcessServiceFactory();
1293
1294 Window* pWindow = GetTopMostParentSystemWindow( this );
1295 if ( pWindow )
1296 ((SystemWindow *)pWindow)->GetTaskPaneList()->AddWindow( this );
1297 }
1298
1299 //--------------------------------------------------------------------
1300
~SfxPopupWindow()1301 SfxPopupWindow::~SfxPopupWindow()
1302 {
1303 if ( m_xStatusListener.is() )
1304 {
1305 m_xStatusListener->dispose();
1306 m_xStatusListener.clear();
1307 }
1308
1309 Window* pWindow = GetTopMostParentSystemWindow( this );
1310 if ( pWindow )
1311 ((SystemWindow *)pWindow)->GetTaskPaneList()->RemoveWindow( this );
1312 }
1313
1314 //--------------------------------------------------------------------
1315
GetOrCreateStatusListener()1316 SfxFrameStatusListener* SfxPopupWindow::GetOrCreateStatusListener()
1317 {
1318 if ( !m_xStatusListener.is() )
1319 {
1320 m_pStatusListener = new SfxFrameStatusListener(
1321 m_xServiceManager,
1322 m_xFrame,
1323 this );
1324 m_xStatusListener = Reference< XComponent >( static_cast< cppu::OWeakObject* >(
1325 m_pStatusListener ), UNO_QUERY );
1326 }
1327
1328 return m_pStatusListener;
1329 }
1330
1331 //--------------------------------------------------------------------
1332
BindListener()1333 void SfxPopupWindow::BindListener()
1334 {
1335 GetOrCreateStatusListener();
1336 if ( m_xStatusListener.is() )
1337 m_pStatusListener->bindListener();
1338 }
1339
1340 //--------------------------------------------------------------------
1341
UnbindListener()1342 void SfxPopupWindow::UnbindListener()
1343 {
1344 GetOrCreateStatusListener();
1345 if ( m_xStatusListener.is() )
1346 m_pStatusListener->unbindListener();
1347 }
1348
1349 //--------------------------------------------------------------------
1350
AddStatusListener(const rtl::OUString & rCommandURL)1351 void SfxPopupWindow::AddStatusListener( const rtl::OUString& rCommandURL )
1352 {
1353 GetOrCreateStatusListener();
1354 if ( m_xStatusListener.is() )
1355 m_pStatusListener->addStatusListener( rCommandURL );
1356 }
1357
1358 //--------------------------------------------------------------------
1359
RemoveStatusListener(const rtl::OUString & rCommandURL)1360 void SfxPopupWindow::RemoveStatusListener( const rtl::OUString& rCommandURL )
1361 {
1362 GetOrCreateStatusListener();
1363 if ( m_xStatusListener.is() )
1364 m_pStatusListener->removeStatusListener( rCommandURL );
1365 }
1366
1367 //--------------------------------------------------------------------
1368
UpdateStatus(const rtl::OUString & rCommandURL)1369 void SfxPopupWindow::UpdateStatus( const rtl::OUString& rCommandURL )
1370 {
1371 GetOrCreateStatusListener();
1372 if ( m_xStatusListener.is() )
1373 m_pStatusListener->updateStatus( rCommandURL );
1374 }
1375
1376 //--------------------------------------------------------------------
1377
Close()1378 sal_Bool SfxPopupWindow::Close()
1379 {
1380 m_bFloating = sal_False;
1381 FloatingWindow::Close();
1382
1383 Delete(0);
1384 return sal_True;
1385 }
1386
1387 //--------------------------------------------------------------------
1388
PopupModeEnd()1389 void SfxPopupWindow::PopupModeEnd()
1390 {
1391 //! to allow PopupModeEndHdl to be called
1392 FloatingWindow::PopupModeEnd();
1393
1394 if ( IsVisible() )
1395 {
1396 // wurde abgerissen
1397 DeleteFloatingWindow();
1398 m_bFloating = sal_True;
1399 }
1400 else
1401 Close();
1402 }
1403
1404 //--------------------------------------------------------------------
1405
DeleteFloatingWindow()1406 void SfxPopupWindow::DeleteFloatingWindow()
1407 {
1408 if ( m_bFloating )
1409 {
1410 Hide();
1411 Delete(0);
1412 }
1413 }
1414
1415 //--------------------------------------------------------------------
1416
MouseMove(const::MouseEvent & rMEvt)1417 void SfxPopupWindow::MouseMove( const ::MouseEvent& rMEvt )
1418 {
1419 if ( m_bCascading == sal_False )
1420 FloatingWindow::MouseMove( rMEvt );
1421 else
1422 {
1423 // MouseMove-Event an die Children forwarden
1424 ::Point aPos = rMEvt.GetPosPixel();
1425 ::Point aScrPos = OutputToScreenPixel( aPos );
1426 sal_uInt16 i = 0;
1427 Window* pWindow = GetChild( i );
1428 while ( pWindow )
1429 {
1430 ::MouseEvent aMEvt( pWindow->ScreenToOutputPixel( aScrPos ),
1431 rMEvt.GetClicks(), rMEvt.GetMode(),
1432 rMEvt.GetButtons(), rMEvt.GetModifier() );
1433 pWindow->MouseMove( rMEvt );
1434 pWindow->Update();
1435 i++;
1436 pWindow = GetChild( i );
1437 }
1438 }
1439 }
1440
1441 //--------------------------------------------------------------------
1442
StartCascading()1443 void SfxPopupWindow::StartCascading()
1444 {
1445 m_bCascading= sal_True;
1446 }
1447
EndCascading()1448 void SfxPopupWindow::EndCascading()
1449 {
1450 m_bCascading = sal_False;
1451 }
1452
1453 //--------------------------------------------------------------------
1454
Clone() const1455 SfxPopupWindow* SfxPopupWindow::Clone() const
1456
1457 /* [Beschreibung]
1458
1459 Diese Methode mu\s "uberladen werden, um dieses Popup auch im
1460 Presentations-Modus anzuzeigen. Sie wird gerufen, wenn ein Show()
1461 sinnlos w"are, da der Parent nicht das Presentations-Window ist.
1462 Beim neu erzeugen wird automatisch das neue Top-Window verwendet, so
1463 da\s der Parent das Presentations-Window ist und das neue Popup somit
1464 sichtbar ist.
1465 */
1466
1467 {
1468 return 0;
1469 }
1470
1471 //--------------------------------------------------------------------
1472
StateChanged(sal_uInt16,SfxItemState eState,const SfxPoolItem *)1473 void SfxPopupWindow::StateChanged(
1474 sal_uInt16 /*nSID*/,
1475 SfxItemState eState,
1476 const SfxPoolItem* /*pState*/ )
1477 /* [Bescheibung]
1478
1479 Siehe auch <SfxControllerItem::StateChanged()>. Au\serdem wird
1480 bei eState==SFX_ITEM_DISABLED das Popup gehided und in allen anderen
1481 F"allen, falls es floating ist, wieder angezeigt. Daher mu\s die
1482 Basisklasse i.d.R. gerufen werden.
1483
1484 Es findet wegen des Parents eine Sonderbehandlung f"ur den
1485 Presentationsmodus statt.
1486
1487 */
1488
1489 {
1490 if ( SFX_ITEM_DISABLED == eState )
1491 {
1492 Hide();
1493 }
1494 else if ( m_bFloating )
1495 {
1496 Show( sal_True, SHOW_NOFOCUSCHANGE | SHOW_NOACTIVATE );
1497 }
1498 }
1499
1500 //--------------------------------------------------------------------
1501
IMPL_LINK(SfxPopupWindow,Delete,void *,EMPTYARG)1502 IMPL_LINK( SfxPopupWindow, Delete, void *, EMPTYARG )
1503 {
1504 if ( m_aDeleteLink.IsSet() )
1505 m_aDeleteLink.Call( this );
1506 delete this;
1507 return 0;
1508 }
1509
1510 //--------------------------------------------------------------------
1511
1512