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_dbaccess.hxx"
26 #ifndef DBAUI_GENERICCONTROLLER_HXX
27 #include "genericcontroller.hxx"
28 #endif
29 #ifndef _COMPHELPER_UNO3_HXX_
30 #include <comphelper/uno3.hxx>
31 #endif
32 #ifndef _TOOLKIT_AWT_VCLXWINDOW_HXX_
33 #include <toolkit/awt/vclxwindow.hxx>
34 #endif
35 #ifndef DBACCESS_UI_BROWSER_ID_HXX
36 #include "browserids.hxx"
37 #endif
38 #ifndef _SV_SVAPP_HXX //autogen
39 #include <vcl/svapp.hxx>
40 #endif
41 #ifndef _TOOLKIT_HELPER_VCLUNOHELPER_HXX_
42 #include <toolkit/helper/vclunohelper.hxx>
43 #endif
44 #ifndef DBAUI_DATAVIEW_HXX
45 #include "dataview.hxx"
46 #endif
47 #ifndef _TOOLS_DEBUG_HXX
48 #include <tools/debug.hxx>
49 #endif
50 #ifndef TOOLS_DIAGNOSE_EX_H
51 #include <tools/diagnose_ex.h>
52 #endif
53 #ifndef DBACCESS_SHARED_DBUSTRINGS_HRC
54 #include "dbustrings.hrc"
55 #endif
56 #ifndef _VCL_STDTEXT_HXX
57 #include <vcl/stdtext.hxx>
58 #endif
59 #ifndef _CPPUHELPER_TYPEPROVIDER_HXX_
60 #include <cppuhelper/typeprovider.hxx>
61 #endif
62 #include <framework/titlehelper.hxx>
63 #ifndef _COMPHELPER_SEQUENCE_HXX_
64 #include <comphelper/sequence.hxx>
65 #endif
66 #ifndef _COMPHELPER_EXTRACT_HXX_
67 #include <comphelper/extract.hxx>
68 #endif
69 #ifndef _COM_SUN_STAR_SDBC_XDATASOURCE_HPP_
70 #include <com/sun/star/sdbc/XDataSource.hpp>
71 #endif
72 #ifndef _COM_SUN_STAR_SDB_SQLCONTEXT_HPP_
73 #include <com/sun/star/sdb/SQLContext.hpp>
74 #endif
75 #ifndef _COM_SUN_STAR_SDB_XCOMPLETEDCONNECTION_HPP_
76 #include <com/sun/star/sdb/XCompletedConnection.hpp>
77 #endif
78 #ifndef _COM_SUN_STAR_BEANS_XPROPERTYSET_HPP_
79 #include <com/sun/star/beans/XPropertySet.hpp>
80 #endif
81 #ifndef _COM_SUN_STAR_TASK_XINTERACTIONHANDLER_HPP_
82 #include <com/sun/star/task/XInteractionHandler.hpp>
83 #endif
84 #ifndef _COM_SUN_STAR_UTIL_XCLOSEABLE_HPP_
85 #include <com/sun/star/util/XCloseable.hpp>
86 #endif
87 #ifndef DBAUI_TOOLS_HXX
88 #include "UITools.hxx"
89 #endif
90 #ifndef _DBAUI_COMMON_TYPES_HXX_
91 #include "commontypes.hxx"
92 #endif
93
94 #ifndef _SV_WAITOBJ_HXX
95 #include <vcl/waitobj.hxx>
96 #endif
97 #ifndef _URLOBJ_HXX
98 #include <tools/urlobj.hxx>
99 #endif
100 #ifndef SVTOOLS_URIHELPER_HXX
101 #include <svl/urihelper.hxx>
102 #endif
103 #ifndef _DBAUI_DATASOURCECONNECTOR_HXX_
104 #include "datasourceconnector.hxx"
105 #endif
106 #ifndef INCLUDED_SVTOOLS_MODULEOPTIONS_HXX
107 #include <unotools/moduleoptions.hxx>
108 #endif
109 #ifndef _COM_SUN_STAR_FRAME_FRAMESEARCHFLAG_HPP_
110 #include <com/sun/star/frame/FrameSearchFlag.hpp>
111 #endif
112 #ifndef _COM_SUN_STAR_FRAME_STATUS_VISIBILITY_HPP_
113 #include <com/sun/star/frame/status/Visibility.hpp>
114 #endif
115 #ifndef _COM_SUN_STAR_UTIL_XMODIFIABLE_HPP_
116 #include <com/sun/star/util/XModifiable.hpp>
117 #endif
118 #ifndef _RTL_USTRING_HXX_
119 #include <rtl/ustring.hxx>
120 #endif
121 #ifndef _RTL_LOGFILE_HXX_
122 #include <rtl/logfile.hxx>
123 #endif
124 #include <algorithm>
125 #include <hash_map>
126 #include <cppuhelper/implbase1.hxx>
127 #include <limits>
128
129 using namespace ::com::sun::star;
130 using namespace ::com::sun::star::uno;
131 using namespace ::com::sun::star::beans;
132 using namespace ::com::sun::star::frame;
133 using namespace ::com::sun::star::frame::status;
134 using namespace ::com::sun::star::util;
135 using namespace ::com::sun::star::lang;
136 using namespace ::com::sun::star::container;
137 using namespace ::com::sun::star::sdbc;
138 using namespace ::com::sun::star::sdb;
139 using namespace ::com::sun::star::task;
140 using namespace ::com::sun::star::awt;
141 using namespace ::com::sun::star;
142 using namespace ::dbtools;
143 using namespace ::comphelper;
144
145 // -------------------------------------------------------------------------
146 #define ALL_FEATURES -1
147 #define FIRST_USER_DEFINED_FEATURE ( ::std::numeric_limits< sal_uInt16 >::max() - 1000 )
148 #define LAST_USER_DEFINED_FEATURE ( ::std::numeric_limits< sal_uInt16 >::max() )
149
150 // -------------------------------------------------------------------------
151 typedef ::std::hash_map< sal_Int16, sal_Int16 > CommandHashMap;
152 typedef ::std::list< DispatchInformation > DispatchInfoList;
153
154
155 // -------------------------------------------------------------------------
getConfirmDeletionURL()156 const ::rtl::OUString& getConfirmDeletionURL()
157 {
158 static const ::rtl::OUString sConfirmDeletionURL( RTL_CONSTASCII_USTRINGPARAM( ".uno:FormSlots/ConfirmDeletion" ) );
159 return sConfirmDeletionURL;
160 }
161
162 namespace dbaui
163 {
164
165 //==========================================================================
166 //= UserDefinedFeatures
167 //==========================================================================
168 class UserDefinedFeatures
169 {
170 public:
171 UserDefinedFeatures( const Reference< XController >& _rxController );
172
173 FeatureState getState( const URL& _rFeatureURL );
174 void execute( const URL& _rFeatureURL, const Sequence< PropertyValue>& _rArgs );
175
176 private:
177 ::com::sun::star::uno::WeakReference< XController > m_aController;
178 };
179
180 //--------------------------------------------------------------------------
UserDefinedFeatures(const Reference<XController> & _rxController)181 UserDefinedFeatures::UserDefinedFeatures( const Reference< XController >& _rxController )
182 :m_aController( _rxController )
183 {
184 }
185
186 //--------------------------------------------------------------------------
getState(const URL &)187 FeatureState UserDefinedFeatures::getState( const URL& /*_rFeatureURL*/ )
188 {
189 // for now, enable all the time
190 // TODO: we should ask the dispatcher. However, this is laborious, since you cannot ask a dispatcher
191 // directly, but need to add a status listener.
192 FeatureState aState;
193 aState.bEnabled = sal_True;
194 return aState;
195 }
196
197 //--------------------------------------------------------------------------
execute(const URL & _rFeatureURL,const Sequence<PropertyValue> & _rArgs)198 void UserDefinedFeatures::execute( const URL& _rFeatureURL, const Sequence< PropertyValue>& _rArgs )
199 {
200 try
201 {
202 Reference< XController > xController( (Reference< XController >)m_aController, UNO_SET_THROW );
203 Reference< XDispatchProvider > xDispatchProvider( xController->getFrame(), UNO_QUERY_THROW );
204 Reference< XDispatch > xDispatch( xDispatchProvider->queryDispatch(
205 _rFeatureURL,
206 ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "_self" ) ),
207 FrameSearchFlag::AUTO
208 ) );
209
210 if ( xDispatch == xController )
211 {
212 OSL_ENSURE( false, "UserDefinedFeatures::execute: the controller shouldn't be the dispatcher here!" );
213 xDispatch.clear();
214 }
215
216 if ( xDispatch.is() )
217 xDispatch->dispatch( _rFeatureURL, _rArgs );
218 }
219 catch( const Exception& )
220 {
221 DBG_UNHANDLED_EXCEPTION();
222 }
223 }
224
225 //==========================================================================
226 //= OGenericUnoController_Data
227 //==========================================================================
228 struct OGenericUnoController_Data
229 {
230 ::sfx2::UserInputInterception m_aUserInputInterception;
231 UserDefinedFeatures m_aUserDefinedFeatures;
232
OGenericUnoController_Datadbaui::OGenericUnoController_Data233 OGenericUnoController_Data( OGenericUnoController& _rController, ::osl::Mutex& _rMutex )
234 :m_aUserInputInterception( _rController, _rMutex )
235 ,m_aUserDefinedFeatures( _rController.getXController() )
236 {
237 }
238 };
239
240 //==========================================================================
241 //= OGenericUnoController
242 //==========================================================================
DBG_NAME(OGenericUnoController)243 DBG_NAME(OGenericUnoController)
244 // -------------------------------------------------------------------------
245 OGenericUnoController::OGenericUnoController(const Reference< XMultiServiceFactory >& _rM)
246 :OGenericUnoController_Base( getMutex() )
247 ,m_pView(NULL)
248 #ifdef DBG_UTIL
249 ,m_bDescribingSupportedFeatures( false )
250 #endif
251 ,m_aAsyncInvalidateAll(LINK(this, OGenericUnoController, OnAsyncInvalidateAll))
252 ,m_aAsyncCloseTask(LINK(this, OGenericUnoController, OnAsyncCloseTask))
253 ,m_xServiceFactory(_rM)
254 ,m_aCurrentFrame( *this )
255 ,m_bPreview(sal_False)
256 ,m_bReadOnly(sal_False)
257 ,m_bCurrentlyModified(sal_False)
258 ,m_bExternalTitle(sal_False)
259 {
260 osl_incrementInterlockedCount( &m_refCount );
261 {
262 m_pData.reset( new OGenericUnoController_Data( *this, getMutex() ) );
263 }
264 osl_decrementInterlockedCount( &m_refCount );
265
266 DBG_CTOR(OGenericUnoController,NULL);
267
268 try
269 {
270 m_xUrlTransformer = Reference< XURLTransformer > (_rM->createInstance(::rtl::OUString::createFromAscii("com.sun.star.util.URLTransformer")), UNO_QUERY);
271 }
272 catch(Exception&)
273 {
274 DBG_UNHANDLED_EXCEPTION();
275 }
276 }
277
278 #ifdef WNT
279 // -----------------------------------------------------------------------------
OGenericUnoController()280 OGenericUnoController::OGenericUnoController()
281 :OGenericUnoController_Base( getMutex() )
282 ,m_pView(NULL)
283 #ifdef DBG_UTIL
284 ,m_bDescribingSupportedFeatures( false )
285 #endif
286 ,m_aAsyncInvalidateAll(LINK(this, OGenericUnoController, OnAsyncInvalidateAll))
287 ,m_aAsyncCloseTask(LINK(this, OGenericUnoController, OnAsyncCloseTask))
288 ,m_aCurrentFrame( *this )
289 ,m_bPreview(sal_False)
290 ,m_bReadOnly(sal_False)
291 ,m_bCurrentlyModified(sal_False)
292 {
293 OSL_ENSURE( false, "OGenericUnoController::OGenericUnoController: illegal call!" );
294 // This ctor only exists because the MSVC compiler complained about an unresolved external
295 // symbol. It should not be used at all. Since using it yields strange runtime problems,
296 // we simply abort here.
297 abort();
298 }
299 #endif
300
301 // -----------------------------------------------------------------------------
~OGenericUnoController()302 OGenericUnoController::~OGenericUnoController()
303 {
304
305 DBG_DTOR(OGenericUnoController,NULL);
306 }
307
308 // -----------------------------------------------------------------------------
Construct(Window *)309 sal_Bool OGenericUnoController::Construct(Window* /*pParent*/)
310 {
311 OSL_ENSURE( getView(), "the view is NULL!" );
312
313 if ( getView() )
314 {
315 getView()->Construct();
316 getView()->Show();
317 }
318
319 m_aSupportedFeatures.clear();
320 fillSupportedFeatures();
321
322 // create the database context
323 DBG_ASSERT(getORB().is(), "OGenericUnoController::Construct need a service factory!");
324 try
325 {
326 m_xDatabaseContext = Reference< XNameAccess >(getORB()->createInstance(SERVICE_SDB_DATABASECONTEXT), UNO_QUERY);
327 }
328 catch(Exception&)
329 {
330 DBG_ERROR("OGenericUnoController::Construct: could not create (or start listening at) the database context!");
331 }
332
333 if (!m_xDatabaseContext.is())
334 { // at least notify the user. Though the whole component does not make any sense without the database context ...
335 ShowServiceNotAvailableError(getView(), String(SERVICE_SDB_DATABASECONTEXT), sal_True);
336 }
337 return sal_True;
338 }
339 //------------------------------------------------------------------------------
IMPL_LINK(OGenericUnoController,OnAsyncInvalidateAll,void *,EMPTYARG)340 IMPL_LINK(OGenericUnoController, OnAsyncInvalidateAll, void*, EMPTYARG)
341 {
342 if ( !OGenericUnoController_Base::rBHelper.bInDispose && !OGenericUnoController_Base::rBHelper.bDisposed )
343 InvalidateFeature_Impl();
344 return 0L;
345 }
346 // -----------------------------------------------------------------------------
impl_initialize()347 void OGenericUnoController::impl_initialize()
348 {
349 }
350 // -------------------------------------------------------------------------
initialize(const Sequence<Any> & aArguments)351 void SAL_CALL OGenericUnoController::initialize( const Sequence< Any >& aArguments ) throw(Exception, RuntimeException)
352 {
353 vos::OGuard aSolarGuard( Application::GetSolarMutex() );
354 ::osl::MutexGuard aGuard( getMutex() );
355
356 Reference< XWindow > xParent;
357 Reference< XFrame > xFrame;
358
359 PropertyValue aValue;
360 const Any* pIter = aArguments.getConstArray();
361 const Any* pEnd = pIter + aArguments.getLength();
362
363 for ( ; pIter != pEnd; ++pIter )
364 {
365 if ( ( *pIter >>= aValue ) && ( 0 == aValue.Name.compareToAscii( "Frame" ) ) )
366 {
367 xFrame.set(aValue.Value,UNO_QUERY_THROW);
368 }
369 /* #i42316#
370 else if ( ( *pIter >>= aValue ) && ( 0 == aValue.Name.compareToAscii( "ReadOnly" ) ) )
371 {
372 aValue.Value >>= m_bReadOnly;
373 }
374 */
375 else if ( ( *pIter >>= aValue ) && ( 0 == aValue.Name.compareToAscii( "Preview" ) ) )
376 {
377 aValue.Value >>= m_bPreview;
378 m_bReadOnly = sal_True;
379 }
380 }
381 try
382 {
383 if ( !xFrame.is() )
384 throw IllegalArgumentException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "need a frame" ) ), *this, 1 );
385
386 xParent = xFrame->getContainerWindow();
387 VCLXWindow* pParentComponent = VCLXWindow::GetImplementation(xParent);
388 Window* pParentWin = pParentComponent ? pParentComponent->GetWindow() : NULL;
389 if (!pParentWin)
390 {
391 throw IllegalArgumentException( ::rtl::OUString::createFromAscii( "Parent window is null" ), *this, 1 );
392 }
393
394 m_aInitParameters.assign( aArguments );
395 Construct( pParentWin );
396
397 ODataView* pView = getView();
398 if ( !pView )
399 throw RuntimeException( ::rtl::OUString::createFromAscii( "unable to create a view" ), *this );
400
401 if ( m_bReadOnly || m_bPreview )
402 pView->EnableInput( sal_False );
403
404 impl_initialize();
405 }
406 catch(Exception& e)
407 {
408 // no one clears my view if I won't
409 ::std::auto_ptr<Window> aTemp(m_pView);
410 m_pView = NULL;
411 throw;
412 }
413 }
414
415 //------------------------------------------------------------------------------
acquire()416 void SAL_CALL OGenericUnoController::acquire( ) throw ()
417 {
418 OGenericUnoController_Base::acquire();
419 }
420
421 //------------------------------------------------------------------------------
release()422 void SAL_CALL OGenericUnoController::release( ) throw ()
423 {
424 OGenericUnoController_Base::release();
425 }
426
427 // -------------------------------------------------------------------------
startFrameListening(const Reference<XFrame> & _rxFrame)428 void OGenericUnoController::startFrameListening( const Reference< XFrame >& _rxFrame )
429 {
430 if ( _rxFrame.is() )
431 _rxFrame->addFrameActionListener( this );
432 }
433
434 // -------------------------------------------------------------------------
stopFrameListening(const Reference<XFrame> & _rxFrame)435 void OGenericUnoController::stopFrameListening( const Reference< XFrame >& _rxFrame )
436 {
437 if ( _rxFrame.is() )
438 _rxFrame->removeFrameActionListener( this );
439 }
440
441 // -------------------------------------------------------------------------
disposing(const EventObject & Source)442 void OGenericUnoController::disposing(const EventObject& Source) throw( RuntimeException )
443 {
444 // our frame ?
445 if ( Source.Source == getFrame() )
446 stopFrameListening( getFrame() );
447 }
448 //------------------------------------------------------------------------
modified(const EventObject & aEvent)449 void OGenericUnoController::modified(const EventObject& aEvent) throw( RuntimeException )
450 {
451 ::osl::MutexGuard aGuard( getMutex() );
452 if ( !isDataSourceReadOnly() )
453 {
454 Reference<XModifiable> xModi(aEvent.Source,UNO_QUERY);
455 if ( xModi.is() )
456 m_bCurrentlyModified = xModi->isModified(); // can only be reset by save
457 else
458 m_bCurrentlyModified = sal_True;
459 }
460 InvalidateFeature(ID_BROWSER_SAVEDOC);
461 InvalidateFeature(ID_BROWSER_UNDO);
462 }
463 // -----------------------------------------------------------------------
getComponentWindow()464 Reference< XWindow > SAL_CALL OGenericUnoController::getComponentWindow() throw (RuntimeException)
465 {
466 return VCLUnoHelper::GetInterface( getView() );
467 }
468
469 // -----------------------------------------------------------------------
getViewControllerName()470 ::rtl::OUString SAL_CALL OGenericUnoController::getViewControllerName() throw (::com::sun::star::uno::RuntimeException)
471 {
472 return ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Default" ) );
473 }
474
475 // -----------------------------------------------------------------------
getCreationArguments()476 Sequence< PropertyValue > SAL_CALL OGenericUnoController::getCreationArguments() throw (RuntimeException)
477 {
478 // currently we do not support any creation args, so anything passed to XModel2::createViewController would be
479 // lost, so we can equally return an empty sequence here
480 return Sequence< PropertyValue >();
481 }
482
483 // -----------------------------------------------------------------------
attachFrame(const Reference<XFrame> & _rxFrame)484 void OGenericUnoController::attachFrame( const Reference< XFrame >& _rxFrame ) throw( RuntimeException )
485 {
486 vos::OGuard aSolarGuard( Application::GetSolarMutex() );
487 ::osl::MutexGuard aGuard( getMutex() );
488
489 stopFrameListening( m_aCurrentFrame.getFrame() );
490 Reference< XFrame > xFrame = m_aCurrentFrame.attachFrame( _rxFrame );
491 startFrameListening( xFrame );
492
493 loadMenu( xFrame );
494
495 if ( getView() )
496 getView()->attachFrame( xFrame );
497 }
498
499 // -----------------------------------------------------------------------------
500 struct CommandCollector : public ::std::unary_function< SupportedFeatures::value_type, void>
501 {
502 sal_uInt16 m_nFeature;
503 StringBag& m_rFeatureCommands;
CommandCollectordbaui::CommandCollector504 CommandCollector( sal_uInt16 _nFeature, StringBag& _rFeatureCommands )
505 :m_nFeature ( _nFeature )
506 ,m_rFeatureCommands( _rFeatureCommands )
507 {
508 }
509
operator ()dbaui::CommandCollector510 void operator() ( const SupportedFeatures::value_type& lhs )
511 {
512 if ( lhs.second.nFeatureId == m_nFeature )
513 m_rFeatureCommands.insert( lhs.first );
514 }
515 };
516
517 // -----------------------------------------------------------------------
518 namespace
519 {
520 typedef ::std::vector< Any > States;
521
522 // ...................................................................
lcl_notifyMultipleStates(XStatusListener & _rListener,FeatureStateEvent & _rEvent,const States & _rStates)523 void lcl_notifyMultipleStates( XStatusListener& _rListener, FeatureStateEvent& _rEvent, const States& _rStates )
524 {
525 for ( States::const_iterator state = _rStates.begin();
526 state != _rStates.end();
527 ++state
528 )
529 {
530 _rEvent.State = *state;
531 _rListener.statusChanged( _rEvent );
532 }
533 }
534
535 // ...................................................................
lcl_collectStates(const FeatureState & _rFeatureState,States & _out_rStates)536 void lcl_collectStates( const FeatureState& _rFeatureState, States& _out_rStates )
537 {
538 // order matters, due to a bug in framework which resets the check state when any non-boolean event
539 // arrives
540 // #i68215# is the bug to (re-)introduce this "ordered" notification here
541 // #i67882# is the bug which was caused by the real fix which we did in framework
542 // #i68216# is the bug which requests to fix the code in Draw which relies on
543 // framework's implementation details
544 // 2006-08-07 / frank.schoenheit@sun.com
545 if ( !!_rFeatureState.sTitle )
546 _out_rStates.push_back( makeAny( *_rFeatureState.sTitle ) );
547 if ( !!_rFeatureState.bChecked )
548 _out_rStates.push_back( makeAny( (sal_Bool)*_rFeatureState.bChecked ) );
549 if ( !!_rFeatureState.bInvisible )
550 _out_rStates.push_back( makeAny( Visibility( !*_rFeatureState.bInvisible ) ) );
551 if ( _rFeatureState.aValue.hasValue() )
552 _out_rStates.push_back( _rFeatureState.aValue );
553 if ( _out_rStates.empty() )
554 _out_rStates.push_back( Any() );
555 }
556 }
557
558 // -----------------------------------------------------------------------
ImplBroadcastFeatureState(const::rtl::OUString & _rFeature,const Reference<XStatusListener> & xListener,sal_Bool _bIgnoreCache)559 void OGenericUnoController::ImplBroadcastFeatureState(const ::rtl::OUString& _rFeature, const Reference< XStatusListener > & xListener, sal_Bool _bIgnoreCache)
560 {
561 sal_uInt16 nFeat = m_aSupportedFeatures[ _rFeature ].nFeatureId;
562 FeatureState aFeatState( GetState( nFeat ) );
563
564 FeatureState& rCachedState = m_aStateCache[nFeat]; // creates if neccessary
565 if ( !_bIgnoreCache )
566 {
567 // check if we really need to notify the listeners : this method may be called much more often than needed, so check
568 // the cached state of the feature
569 sal_Bool bAlreadyCached = ( m_aStateCache.find(nFeat) != m_aStateCache.end() );
570 if ( bAlreadyCached )
571 if ( ( rCachedState.bEnabled == aFeatState.bEnabled )
572 && ( rCachedState.bChecked == aFeatState.bChecked )
573 && ( rCachedState.bInvisible == aFeatState.bInvisible )
574 && ( rCachedState.sTitle == aFeatState.sTitle )
575 )
576 return;
577 }
578 rCachedState = aFeatState;
579
580 FeatureStateEvent aEvent;
581 aEvent.FeatureURL.Complete = _rFeature;
582 if (m_xUrlTransformer.is())
583 m_xUrlTransformer->parseStrict(aEvent.FeatureURL);
584 aEvent.Source = (XDispatch*)this;
585 aEvent.IsEnabled = aFeatState.bEnabled;
586
587 // collect all states to be notified
588 States aStates;
589 lcl_collectStates( aFeatState, aStates );
590
591 // a special listener ?
592 if ( xListener.is() )
593 lcl_notifyMultipleStates( *xListener.get(), aEvent, aStates );
594 else
595 { // no -> iterate through all listeners responsible for the URL
596 StringBag aFeatureCommands;
597 ::std::for_each(
598 m_aSupportedFeatures.begin(),
599 m_aSupportedFeatures.end(),
600 CommandCollector( nFeat, aFeatureCommands )
601 );
602
603 // it is possible that listeners are registered or revoked while
604 // we are notifying them, so we must use a copy of m_arrStatusListener, not
605 // m_arrStatusListener itself
606 // #121276# / 2005-05-19 / frank.schoenheit@sun.com
607 Dispatch aNotifyLoop( m_arrStatusListener );
608 DispatchIterator iterSearch = aNotifyLoop.begin();
609 DispatchIterator iterEnd = aNotifyLoop.end();
610
611 while (iterSearch != iterEnd)
612 {
613 DispatchTarget& rCurrent = *iterSearch;
614 if ( aFeatureCommands.find( rCurrent.aURL.Complete ) != aFeatureCommands.end() )
615 {
616 aEvent.FeatureURL = rCurrent.aURL;
617 lcl_notifyMultipleStates( *rCurrent.xListener.get(), aEvent, aStates );
618 }
619 ++iterSearch;
620 }
621 }
622
623 }
624
625 //------------------------------------------------------------------------------
isFeatureSupported(sal_Int32 _nId)626 sal_Bool OGenericUnoController::isFeatureSupported( sal_Int32 _nId )
627 {
628 SupportedFeatures::iterator aFeaturePos = ::std::find_if(
629 m_aSupportedFeatures.begin(),
630 m_aSupportedFeatures.end(),
631 ::std::bind2nd( CompareFeatureById(), _nId )
632 );
633
634 return ( m_aSupportedFeatures.end() != aFeaturePos && aFeaturePos->first.getLength());
635 }
636
637 // -----------------------------------------------------------------------
InvalidateFeature(const::rtl::OUString & _rURLPath,const Reference<XStatusListener> & _xListener,sal_Bool _bForceBroadcast)638 void OGenericUnoController::InvalidateFeature(const ::rtl::OUString& _rURLPath, const Reference< XStatusListener > & _xListener, sal_Bool _bForceBroadcast)
639 {
640 ImplInvalidateFeature( m_aSupportedFeatures[ _rURLPath ].nFeatureId, _xListener, _bForceBroadcast );
641 }
642
643 // -----------------------------------------------------------------------------
InvalidateFeature_Impl()644 void OGenericUnoController::InvalidateFeature_Impl()
645 {
646 #ifdef DBG_UTIL
647 static sal_Int32 s_nRecursions = 0;
648 ++s_nRecursions;
649 #endif
650
651 sal_Bool bEmpty = sal_True;
652 FeatureListener aNextFeature;
653 {
654 ::osl::MutexGuard aGuard( m_aFeatureMutex);
655 bEmpty = m_aFeaturesToInvalidate.empty();
656 if (!bEmpty)
657 aNextFeature = m_aFeaturesToInvalidate.front();
658 }
659 while(!bEmpty)
660 {
661 if ( ALL_FEATURES == aNextFeature.nId )
662 {
663 InvalidateAll_Impl();
664 break;
665 }
666 else
667 {
668 SupportedFeatures::iterator aFeaturePos = ::std::find_if(
669 m_aSupportedFeatures.begin(),
670 m_aSupportedFeatures.end(),
671 ::std::bind2nd( CompareFeatureById(), aNextFeature.nId )
672 );
673
674 #if OSL_DEBUG_LEVEL > 0
675 if ( m_aSupportedFeatures.end() == aFeaturePos )
676 {
677 ::rtl::OString sMessage( "OGenericUnoController::InvalidateFeature_Impl: feature id " );
678 sMessage += ::rtl::OString::valueOf( aNextFeature.nId );
679 sMessage += ::rtl::OString( " has been invalidated, but is not supported!" );
680 OSL_ENSURE( false, sMessage.getStr() );
681 }
682 #endif
683 if ( m_aSupportedFeatures.end() != aFeaturePos )
684 // we really know this feature
685 ImplBroadcastFeatureState( aFeaturePos->first, aNextFeature.xListener, aNextFeature.bForceBroadcast );
686 }
687
688 ::osl::MutexGuard aGuard( m_aFeatureMutex);
689 m_aFeaturesToInvalidate.pop_front();
690 bEmpty = m_aFeaturesToInvalidate.empty();
691 if (!bEmpty)
692 aNextFeature = m_aFeaturesToInvalidate.front();
693 }
694
695 #ifdef DBG_UTIL
696 --s_nRecursions;
697 #endif
698 }
699
700 // -----------------------------------------------------------------------
ImplInvalidateFeature(sal_Int32 _nId,const Reference<XStatusListener> & _xListener,sal_Bool _bForceBroadcast)701 void OGenericUnoController::ImplInvalidateFeature( sal_Int32 _nId, const Reference< XStatusListener >& _xListener, sal_Bool _bForceBroadcast )
702 {
703 #if OSL_DEBUG_LEVEL > 0
704 if ( _nId != -1 )
705 {
706 SupportedFeatures::iterator aFeaturePos = ::std::find_if(
707 m_aSupportedFeatures.begin(),
708 m_aSupportedFeatures.end(),
709 ::std::bind2nd( CompareFeatureById(), _nId )
710 );
711 OSL_ENSURE( aFeaturePos != m_aSupportedFeatures.end(), "OGenericUnoController::ImplInvalidateFeature: invalidating an unsupported feature is suspicious, at least!" );
712 }
713 #endif
714
715 FeatureListener aListener;
716 aListener.nId = _nId;
717 aListener.xListener = _xListener;
718 aListener.bForceBroadcast = _bForceBroadcast;
719
720 sal_Bool bWasEmpty;
721 {
722 ::osl::MutexGuard aGuard( m_aFeatureMutex );
723 bWasEmpty = m_aFeaturesToInvalidate.empty();
724 m_aFeaturesToInvalidate.push_back( aListener );
725 }
726
727 if ( bWasEmpty )
728 m_aAsyncInvalidateAll.Call();
729 }
730
731 // -----------------------------------------------------------------------
InvalidateFeature(sal_uInt16 _nId,const Reference<XStatusListener> & _xListener,sal_Bool _bForceBroadcast)732 void OGenericUnoController::InvalidateFeature(sal_uInt16 _nId, const Reference< XStatusListener > & _xListener, sal_Bool _bForceBroadcast)
733 {
734 ImplInvalidateFeature( _nId, _xListener, _bForceBroadcast );
735 }
736
737 // -----------------------------------------------------------------------
InvalidateAll()738 void OGenericUnoController::InvalidateAll()
739 {
740 ImplInvalidateFeature( ALL_FEATURES, NULL, sal_True );
741 }
742
743 // -----------------------------------------------------------------------------
InvalidateAll_Impl()744 void OGenericUnoController::InvalidateAll_Impl()
745 {
746 // ---------------------------------
747 // invalidate all aupported features
748
749 for ( SupportedFeatures::const_iterator aIter = m_aSupportedFeatures.begin();
750 aIter != m_aSupportedFeatures.end();
751 ++aIter
752 )
753 ImplBroadcastFeatureState( aIter->first, NULL, sal_True );
754
755 {
756 ::osl::MutexGuard aGuard( m_aFeatureMutex);
757 DBG_ASSERT(m_aFeaturesToInvalidate.size(), "OGenericUnoController::InvalidateAll_Impl: to be called from within InvalidateFeature_Impl only!");
758 m_aFeaturesToInvalidate.pop_front();
759 if(!m_aFeaturesToInvalidate.empty())
760 m_aAsyncInvalidateAll.Call();
761 }
762 }
763
764 // -----------------------------------------------------------------------
queryDispatch(const URL & aURL,const::rtl::OUString & aTargetFrameName,sal_Int32 nSearchFlags)765 Reference< XDispatch > OGenericUnoController::queryDispatch(const URL& aURL, const ::rtl::OUString& aTargetFrameName, sal_Int32 nSearchFlags) throw( RuntimeException )
766 {
767 Reference< XDispatch > xReturn;
768
769 OSL_PRECOND( !m_aSupportedFeatures.empty(), "OGenericUnoController::queryDispatch: shouldn't this be filled at construction time?" );
770 if ( m_aSupportedFeatures.empty() )
771 fillSupportedFeatures();
772
773 // URL's we can handle ourself?
774 if ( aURL.Complete.equals( getConfirmDeletionURL() )
775 || ( ( m_aSupportedFeatures.find( aURL.Complete ) != m_aSupportedFeatures.end() )
776 && !isUserDefinedFeature( aURL.Complete )
777 )
778 )
779 {
780 xReturn = this;
781 }
782 // no? -> ask the slave dispatcher
783 else if ( m_xSlaveDispatcher.is() )
784 {
785 xReturn = m_xSlaveDispatcher->queryDispatch(aURL, aTargetFrameName, nSearchFlags);
786 }
787
788 // outta here
789 return xReturn;
790 }
791
792 // -----------------------------------------------------------------------
queryDispatches(const Sequence<DispatchDescriptor> & aDescripts)793 Sequence< Reference< XDispatch > > OGenericUnoController::queryDispatches(const Sequence< DispatchDescriptor >& aDescripts) throw( RuntimeException )
794 {
795 Sequence< Reference< XDispatch > > aReturn;
796 sal_Int32 nLen = aDescripts.getLength();
797 if ( nLen )
798 {
799 aReturn.realloc( nLen );
800 Reference< XDispatch >* pReturn = aReturn.getArray();
801 const Reference< XDispatch >* pReturnEnd = aReturn.getArray() + nLen;
802 const DispatchDescriptor* pDescripts = aDescripts.getConstArray();
803
804 for ( ; pReturn != pReturnEnd; ++ pReturn, ++pDescripts )
805 {
806 *pReturn = queryDispatch( pDescripts->FeatureURL, pDescripts->FrameName, pDescripts->SearchFlags );
807 }
808 }
809
810 return aReturn;
811 }
812
813 // -----------------------------------------------------------------------
getSlaveDispatchProvider(void)814 Reference< XDispatchProvider > OGenericUnoController::getSlaveDispatchProvider(void) throw( RuntimeException )
815 {
816 return m_xSlaveDispatcher;
817 }
818
819 // -----------------------------------------------------------------------
setSlaveDispatchProvider(const Reference<XDispatchProvider> & _xNewProvider)820 void OGenericUnoController::setSlaveDispatchProvider(const Reference< XDispatchProvider > & _xNewProvider) throw( RuntimeException )
821 {
822 m_xSlaveDispatcher = _xNewProvider;
823 }
824
825 // -----------------------------------------------------------------------
getMasterDispatchProvider(void)826 Reference< XDispatchProvider > OGenericUnoController::getMasterDispatchProvider(void) throw( RuntimeException )
827 {
828 return m_xMasterDispatcher;
829 }
830
831 // -----------------------------------------------------------------------
setMasterDispatchProvider(const Reference<XDispatchProvider> & _xNewProvider)832 void OGenericUnoController::setMasterDispatchProvider(const Reference< XDispatchProvider > & _xNewProvider) throw( RuntimeException )
833 {
834 m_xMasterDispatcher = _xNewProvider;
835 }
836
837 // -----------------------------------------------------------------------
dispatch(const URL & _aURL,const Sequence<PropertyValue> & aArgs)838 void OGenericUnoController::dispatch(const URL& _aURL, const Sequence< PropertyValue >& aArgs) throw(RuntimeException)
839 {
840 ::vos::OGuard aSolarGuard( Application::GetSolarMutex() );
841 // Since the fix for #123967#, the SolarMutex is not locked anymore when the framework calls into
842 // here. So, lock it ourself. The real solution would be to lock it only in the places
843 // where it's needed, but a) this might turn out difficult, since we then also need to care
844 // for locking in the proper order (SolarMutex and m_aMutex), and b) this would be too many places
845 // for the time frame of the fix.
846 // #i52602# / frank.schoenheit@sun.com / 2005-07-29
847
848 #ifdef TIMELOG
849 ::rtl::OString sLog( "OGenericUnoController::dispatch( '" );
850 sLog += ::rtl::OString( _aURL.Main.getStr(), _aURL.Main.getLength(), osl_getThreadTextEncoding() );
851 sLog += ::rtl::OString( "' )" );
852 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "frank.schoenheit@sun.com", sLog.getStr() );
853 #endif
854
855 executeChecked(_aURL,aArgs);
856 }
857
858 // -----------------------------------------------------------------------
addStatusListener(const Reference<XStatusListener> & aListener,const URL & _rURL)859 void OGenericUnoController::addStatusListener(const Reference< XStatusListener > & aListener, const URL& _rURL) throw(RuntimeException)
860 {
861 // parse the ULR now and here, this saves later parsing in each notification round
862 URL aParsedURL( _rURL );
863 if ( m_xUrlTransformer.is() )
864 m_xUrlTransformer->parseStrict( aParsedURL );
865
866 // remeber the listener together with the URL
867 m_arrStatusListener.insert( m_arrStatusListener.end(), DispatchTarget( aParsedURL, aListener ) );
868
869 // initially broadcast the state
870 ImplBroadcastFeatureState( aParsedURL.Complete, aListener, sal_True );
871 // force the new state to be broadcasted to the new listener
872 }
873
874 // -----------------------------------------------------------------------
removeStatusListener(const Reference<XStatusListener> & aListener,const URL & _rURL)875 void OGenericUnoController::removeStatusListener(const Reference< XStatusListener > & aListener, const URL& _rURL) throw(RuntimeException)
876 {
877 DispatchIterator iterSearch = m_arrStatusListener.begin();
878
879 sal_Bool bRemoveForAll = (_rURL.Complete.getLength() == 0);
880 while ( iterSearch != m_arrStatusListener.end() )
881 {
882 DispatchTarget& rCurrent = *iterSearch;
883 if ( (rCurrent.xListener == aListener)
884 && ( bRemoveForAll
885 || (rCurrent.aURL.Complete.equals(_rURL.Complete))
886 )
887 )
888 {
889 m_arrStatusListener.erase( iterSearch );
890 if (!bRemoveForAll)
891 // remove the listener only for the given URL, so we can exit the loop after deletion
892 break;
893 }
894 else
895 ++iterSearch;
896 }
897
898 OSL_PRECOND( !m_aSupportedFeatures.empty(), "OGenericUnoController::removeStatusListener: shouldn't this be filled at construction time?" );
899 if ( m_aSupportedFeatures.empty() )
900 fillSupportedFeatures();
901
902 SupportedFeatures::const_iterator aIter = m_aSupportedFeatures.find(_rURL.Complete);
903 if (aIter != m_aSupportedFeatures.end())
904 { // clear the cache for that feature
905 StateCacheIterator aCachePos = m_aStateCache.find( aIter->second.nFeatureId );
906 if ( aCachePos != m_aStateCache.end() )
907 m_aStateCache.erase( aCachePos );
908 }
909
910 // now remove the listener from the deque
911 ::osl::MutexGuard aGuard( m_aFeatureMutex );
912 m_aFeaturesToInvalidate.erase(
913 ::std::remove_if( m_aFeaturesToInvalidate.begin(),
914 m_aFeaturesToInvalidate.end(),
915 ::std::bind2nd(FindFeatureListener(),aListener))
916 ,m_aFeaturesToInvalidate.end());
917 }
918 // -----------------------------------------------------------------------------
releaseNumberForComponent()919 void OGenericUnoController::releaseNumberForComponent()
920 {
921 try
922 {
923 Reference< XUntitledNumbers > xUntitledProvider(getPrivateModel(), UNO_QUERY );
924 if ( xUntitledProvider.is() )
925 xUntitledProvider->releaseNumberForComponent(static_cast<XWeak*>(this));
926 }
927 catch( const Exception& )
928 {
929 // NII
930 }
931 }
932 // -----------------------------------------------------------------------
disposing()933 void OGenericUnoController::disposing()
934 {
935 {
936 EventObject aDisposeEvent;
937 aDisposeEvent.Source = static_cast<XWeak*>(this);
938 Dispatch aStatusListener = m_arrStatusListener;
939 Dispatch::iterator aEnd = aStatusListener.end();
940 for (Dispatch::iterator aIter = aStatusListener.begin(); aIter != aEnd; ++aIter)
941 {
942 aIter->xListener->disposing(aDisposeEvent);
943 }
944 m_arrStatusListener.clear();
945 }
946
947 m_xDatabaseContext = NULL;
948 {
949 ::osl::MutexGuard aGuard( m_aFeatureMutex);
950 m_aAsyncInvalidateAll.CancelCall();
951 m_aFeaturesToInvalidate.clear();
952 }
953
954 releaseNumberForComponent();
955
956 // check out from all the objects we are listening
957 // the frame
958 stopFrameListening( m_aCurrentFrame.getFrame() );
959 m_aCurrentFrame.attachFrame( NULL );
960
961 m_xMasterDispatcher = NULL;
962 m_xSlaveDispatcher = NULL;
963 m_xServiceFactory = NULL;
964 m_xTitleHelper.clear();
965 m_xUrlTransformer.clear();
966 m_aInitParameters.clear();
967 }
968
969 // -----------------------------------------------------------------------------
addEventListener(const Reference<XEventListener> & xListener)970 void SAL_CALL OGenericUnoController::addEventListener( const Reference< XEventListener >& xListener ) throw (RuntimeException)
971 {
972 // disambiguate
973 OGenericUnoController_Base::WeakComponentImplHelperBase::addEventListener( xListener );
974 }
975
976 // -----------------------------------------------------------------------------
removeEventListener(const Reference<XEventListener> & xListener)977 void SAL_CALL OGenericUnoController::removeEventListener( const Reference< XEventListener >& xListener ) throw (RuntimeException)
978 {
979 // disambiguate
980 OGenericUnoController_Base::WeakComponentImplHelperBase::removeEventListener( xListener );
981 }
982
983 //------------------------------------------------------------------------------
frameAction(const FrameActionEvent & aEvent)984 void OGenericUnoController::frameAction(const FrameActionEvent& aEvent) throw( RuntimeException )
985 {
986 ::osl::MutexGuard aGuard( getMutex() );
987 if ( aEvent.Frame == m_aCurrentFrame.getFrame() )
988 m_aCurrentFrame.frameAction( aEvent.Action );
989 }
990
991 //------------------------------------------------------------------------------
implDescribeSupportedFeature(const sal_Char * _pAsciiCommandURL,sal_uInt16 _nFeatureId,sal_Int16 _nCommandGroup)992 void OGenericUnoController::implDescribeSupportedFeature( const sal_Char* _pAsciiCommandURL,
993 sal_uInt16 _nFeatureId, sal_Int16 _nCommandGroup )
994 {
995 #ifdef DBG_UTIL
996 DBG_ASSERT( m_bDescribingSupportedFeatures, "OGenericUnoController::implDescribeSupportedFeature: bad timing for this call!" );
997 #endif
998 OSL_PRECOND( _nFeatureId < FIRST_USER_DEFINED_FEATURE, "OGenericUnoController::implDescribeSupportedFeature: invalid feature id!" );
999
1000 ControllerFeature aFeature;
1001 aFeature.Command = ::rtl::OUString::createFromAscii( _pAsciiCommandURL );
1002 aFeature.nFeatureId = _nFeatureId;
1003 aFeature.GroupId = _nCommandGroup;
1004
1005 #if OSL_DEBUG_LEVEL > 0
1006 OSL_ENSURE( m_aSupportedFeatures.find( aFeature.Command ) == m_aSupportedFeatures.end(),
1007 "OGenericUnoController::implDescribeSupportedFeature: this feature is already there!" );
1008 #endif
1009 m_aSupportedFeatures[ aFeature.Command ] = aFeature;
1010 }
1011
1012 //------------------------------------------------------------------------------
describeSupportedFeatures()1013 void OGenericUnoController::describeSupportedFeatures()
1014 {
1015 // add all supported features
1016 implDescribeSupportedFeature( ".uno:Copy", ID_BROWSER_COPY, CommandGroup::EDIT );
1017 implDescribeSupportedFeature( ".uno:Cut", ID_BROWSER_CUT, CommandGroup::EDIT );
1018 implDescribeSupportedFeature( ".uno:Paste", ID_BROWSER_PASTE, CommandGroup::EDIT );
1019 implDescribeSupportedFeature( ".uno:ClipboardFormatItems", ID_BROWSER_CLIPBOARD_FORMAT_ITEMS );
1020 implDescribeSupportedFeature( ".uno:DSBEditDoc", ID_BROWSER_EDITDOC, CommandGroup::DOCUMENT );
1021 }
1022
1023 //------------------------------------------------------------------------------
GetState(sal_uInt16 _nId) const1024 FeatureState OGenericUnoController::GetState( sal_uInt16 _nId ) const
1025 {
1026 FeatureState aReturn;
1027 // (disabled automatically)
1028
1029 switch ( _nId )
1030 {
1031 case ID_BROWSER_UNDO:
1032 case ID_BROWSER_SAVEDOC:
1033 aReturn.bEnabled = sal_True;
1034 break;
1035 default:
1036 aReturn = m_pData->m_aUserDefinedFeatures.getState( getURLForId( _nId ) );
1037 break;
1038 }
1039
1040 return aReturn;
1041 }
1042
1043 //------------------------------------------------------------------------------
Execute(sal_uInt16 _nId,const Sequence<PropertyValue> & _rArgs)1044 void OGenericUnoController::Execute( sal_uInt16 _nId, const Sequence< PropertyValue>& _rArgs )
1045 {
1046 OSL_ENSURE( isUserDefinedFeature( _nId ),
1047 "OGenericUnoController::Execute: responsible for user defined features only!" );
1048
1049 // user defined features can be handled by dispatch interceptors resp. protocol handlers only.
1050 // So, we need to do a queryDispatch, and dispatch the URL
1051 m_pData->m_aUserDefinedFeatures.execute( getURLForId( _nId ), _rArgs );
1052 }
1053
1054 //------------------------------------------------------------------------------
getURLForId(sal_Int32 _nId) const1055 URL OGenericUnoController::getURLForId(sal_Int32 _nId) const
1056 {
1057 URL aReturn;
1058 if ( m_xUrlTransformer.is() )
1059 {
1060 SupportedFeatures::const_iterator aIter = ::std::find_if(
1061 m_aSupportedFeatures.begin(),
1062 m_aSupportedFeatures.end(),
1063 ::std::bind2nd( CompareFeatureById(), _nId )
1064 );
1065
1066 if ( m_aSupportedFeatures.end() != aIter && aIter->first.getLength() )
1067 {
1068 aReturn.Complete = aIter->first;
1069 m_xUrlTransformer->parseStrict( aReturn );
1070 }
1071 }
1072 return aReturn;
1073 }
1074
1075 //-------------------------------------------------------------------------
isUserDefinedFeature(const sal_uInt16 _nFeatureId) const1076 bool OGenericUnoController::isUserDefinedFeature( const sal_uInt16 _nFeatureId ) const
1077 {
1078 return ( _nFeatureId >= FIRST_USER_DEFINED_FEATURE ) && ( _nFeatureId < LAST_USER_DEFINED_FEATURE );
1079 }
1080
1081 //-------------------------------------------------------------------------
isUserDefinedFeature(const::rtl::OUString & _rFeatureURL) const1082 bool OGenericUnoController::isUserDefinedFeature( const ::rtl::OUString& _rFeatureURL ) const
1083 {
1084 SupportedFeatures::const_iterator pos = m_aSupportedFeatures.find( _rFeatureURL );
1085 OSL_PRECOND( pos != m_aSupportedFeatures.end(),
1086 "OGenericUnoController::isUserDefinedFeature: this is no supported feature at all!" );
1087
1088 return ( pos != m_aSupportedFeatures.end() ) ? isUserDefinedFeature( pos->second.nFeatureId ) : false;
1089 }
1090
1091 //-------------------------------------------------------------------------
supportsService(const::rtl::OUString & ServiceName)1092 sal_Bool SAL_CALL OGenericUnoController::supportsService(const ::rtl::OUString& ServiceName) throw(RuntimeException)
1093 {
1094 Sequence< ::rtl::OUString > aSupported(getSupportedServiceNames());
1095
1096 const ::rtl::OUString* pArray = aSupported.getConstArray();
1097 const ::rtl::OUString* pArrayEnd = aSupported.getConstArray() + aSupported.getLength();
1098
1099 for ( ;( pArray != pArrayEnd ) && !pArray->equals( ServiceName ); ++pArray )
1100 ;
1101 return pArray != pArrayEnd;
1102 }
1103
1104 // -----------------------------------------------------------------------------
startConnectionListening(const Reference<XConnection> & _rxConnection)1105 void OGenericUnoController::startConnectionListening(const Reference< XConnection >& _rxConnection)
1106 {
1107 // we have to remove ourself before dispoing the connection
1108 Reference< XComponent > xComponent(_rxConnection, UNO_QUERY);
1109 if (xComponent.is())
1110 xComponent->addEventListener(static_cast<XFrameActionListener*>(this));
1111 }
1112
1113 // -----------------------------------------------------------------------------
stopConnectionListening(const Reference<XConnection> & _rxConnection)1114 void OGenericUnoController::stopConnectionListening(const Reference< XConnection >& _rxConnection)
1115 {
1116 // we have to remove ourself before dispoing the connection
1117 Reference< XComponent > xComponent(_rxConnection, UNO_QUERY);
1118 if (xComponent.is())
1119 xComponent->removeEventListener(static_cast<XFrameActionListener*>(this));
1120 }
1121 // -----------------------------------------------------------------------------
connect(const Reference<XDataSource> & _xDataSource,::dbtools::SQLExceptionInfo * _pErrorInfo)1122 Reference< XConnection > OGenericUnoController::connect( const Reference< XDataSource>& _xDataSource,
1123 ::dbtools::SQLExceptionInfo* _pErrorInfo )
1124 {
1125 WaitObject aWaitCursor( getView() );
1126
1127 ODatasourceConnector aConnector( getORB(), getView(), ::rtl::OUString() );
1128 Reference< XConnection > xConnection = aConnector.connect( _xDataSource, _pErrorInfo );
1129 startConnectionListening( xConnection );
1130
1131 return xConnection;
1132 }
1133 // -----------------------------------------------------------------------------
connect(const::rtl::OUString & _rDataSourceName,const::rtl::OUString & _rContextInformation,::dbtools::SQLExceptionInfo * _pErrorInfo)1134 Reference< XConnection > OGenericUnoController::connect( const ::rtl::OUString& _rDataSourceName,
1135 const ::rtl::OUString& _rContextInformation, ::dbtools::SQLExceptionInfo* _pErrorInfo )
1136 {
1137 WaitObject aWaitCursor( getView() );
1138
1139 ODatasourceConnector aConnector( getORB(), getView(), _rContextInformation );
1140 Reference<XConnection> xConnection = aConnector.connect( _rDataSourceName, _pErrorInfo );
1141 startConnectionListening( xConnection );
1142
1143 return xConnection;
1144 }
1145
1146 // -----------------------------------------------------------------------------
showError(const SQLExceptionInfo & _rInfo)1147 void OGenericUnoController::showError(const SQLExceptionInfo& _rInfo)
1148 {
1149 ::dbaui::showError(_rInfo,getView(),getORB());
1150 }
1151 // -----------------------------------------------------------------------------
getLayoutManager(const Reference<XFrame> & _xFrame) const1152 Reference< XLayoutManager > OGenericUnoController::getLayoutManager(const Reference< XFrame >& _xFrame) const
1153 {
1154 Reference< XPropertySet > xPropSet( _xFrame, UNO_QUERY );
1155 Reference< XLayoutManager > xLayoutManager;
1156 if ( xPropSet.is() )
1157 {
1158 try
1159 {
1160 xLayoutManager.set(xPropSet->getPropertyValue( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "LayoutManager" ))),UNO_QUERY);
1161 }
1162 catch ( Exception& )
1163 {
1164 }
1165 }
1166 return xLayoutManager;
1167 }
1168 // -----------------------------------------------------------------------------
loadMenu(const Reference<XFrame> & _xFrame)1169 void OGenericUnoController::loadMenu(const Reference< XFrame >& _xFrame)
1170 {
1171 Reference< XLayoutManager > xLayoutManager = getLayoutManager(_xFrame);
1172 if ( xLayoutManager.is() )
1173 {
1174 xLayoutManager->lock();
1175 xLayoutManager->createElement( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "private:resource/menubar/menubar" )));
1176 xLayoutManager->createElement( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "private:resource/toolbar/toolbar" )));
1177 xLayoutManager->unlock();
1178 xLayoutManager->doLayout();
1179 }
1180
1181 onLoadedMenu( xLayoutManager );
1182 }
1183
1184 // -----------------------------------------------------------------------------
onLoadedMenu(const Reference<XLayoutManager> &)1185 void OGenericUnoController::onLoadedMenu(const Reference< XLayoutManager >& /*_xLayoutManager*/)
1186 {
1187 // not interested in
1188 }
1189
1190 // -----------------------------------------------------------------------------
closeTask()1191 void OGenericUnoController::closeTask()
1192 {
1193 m_aAsyncCloseTask.Call();
1194 }
1195 // -----------------------------------------------------------------------------
IMPL_LINK(OGenericUnoController,OnAsyncCloseTask,void *,EMPTYARG)1196 IMPL_LINK(OGenericUnoController, OnAsyncCloseTask, void*, EMPTYARG)
1197 {
1198 if ( !OGenericUnoController_Base::rBHelper.bInDispose )
1199 {
1200 try
1201 {
1202 Reference< util::XCloseable > xCloseable( m_aCurrentFrame.getFrame(), UNO_QUERY_THROW );
1203 xCloseable->close( sal_False ); // false - holds the owner ship for this frame inside this object!
1204 }
1205 catch( const Exception& )
1206 {
1207 DBG_UNHANDLED_EXCEPTION();
1208 }
1209 }
1210 return 0L;
1211 }
1212 // -----------------------------------------------------------------------------
getViewData(void)1213 Any SAL_CALL OGenericUnoController::getViewData(void) throw( RuntimeException )
1214 {
1215 return Any();
1216 }
1217 // -----------------------------------------------------------------------------
restoreViewData(const Any &)1218 void SAL_CALL OGenericUnoController::restoreViewData(const Any& /*Data*/) throw( RuntimeException )
1219 {
1220 }
1221
1222 // -----------------------------------------------------------------------------
getModel(void)1223 Reference< XModel > SAL_CALL OGenericUnoController::getModel(void) throw( RuntimeException )
1224 {
1225 return Reference< XModel >();
1226 }
1227
1228 // -----------------------------------------------------------------------------
getFrame(void)1229 Reference< XFrame > SAL_CALL OGenericUnoController::getFrame(void) throw( RuntimeException )
1230 {
1231 ::osl::MutexGuard aGuard( getMutex() );
1232 return m_aCurrentFrame.getFrame();
1233 }
1234
1235 // -----------------------------------------------------------------------------
attachModel(const Reference<XModel> &)1236 sal_Bool SAL_CALL OGenericUnoController::attachModel(const Reference< XModel > & /*xModel*/) throw( RuntimeException )
1237 {
1238 OSL_ENSURE( false, "OGenericUnoController::attachModel: not supported!" );
1239 return sal_False;
1240 }
1241
1242 // -----------------------------------------------------------------------------
executeUnChecked(sal_uInt16 _nCommandId,const Sequence<PropertyValue> & aArgs)1243 void OGenericUnoController::executeUnChecked(sal_uInt16 _nCommandId, const Sequence< PropertyValue >& aArgs)
1244 {
1245 Execute(_nCommandId, aArgs);
1246 }
1247 // -----------------------------------------------------------------------------
executeUnChecked(const util::URL & _rCommand,const Sequence<PropertyValue> & aArgs)1248 void OGenericUnoController::executeUnChecked(const util::URL& _rCommand, const Sequence< PropertyValue >& aArgs)
1249 {
1250 OSL_PRECOND( !m_aSupportedFeatures.empty(), "OGenericUnoController::executeUnChecked: shouldn't this be filled at construction time?" );
1251 if ( m_aSupportedFeatures.empty() )
1252 fillSupportedFeatures();
1253
1254 SupportedFeatures::const_iterator aIter = m_aSupportedFeatures.find( _rCommand.Complete );
1255 if (aIter != m_aSupportedFeatures.end())
1256 Execute( aIter->second.nFeatureId, aArgs );
1257 }
1258 // -----------------------------------------------------------------------------
executeChecked(const util::URL & _rCommand,const Sequence<PropertyValue> & aArgs)1259 void OGenericUnoController::executeChecked(const util::URL& _rCommand, const Sequence< PropertyValue >& aArgs)
1260 {
1261 OSL_PRECOND( !m_aSupportedFeatures.empty(), "OGenericUnoController::executeChecked: shouldn't this be filled at construction time?" );
1262 if ( m_aSupportedFeatures.empty() )
1263 fillSupportedFeatures();
1264
1265 SupportedFeatures::const_iterator aIter = m_aSupportedFeatures.find( _rCommand.Complete );
1266 if ( aIter != m_aSupportedFeatures.end() )
1267 {
1268 sal_uInt16 nFeatureId = aIter->second.nFeatureId;
1269 if ( GetState( nFeatureId ).bEnabled )
1270 Execute( nFeatureId, aArgs );
1271 }
1272 }
1273 // -----------------------------------------------------------------------------
1274 //------------------------------------------------------------------------------
1275 namespace
1276 {
lcl_getModuleHelpModuleName(const Reference<XFrame> & _rxFrame)1277 ::rtl::OUString lcl_getModuleHelpModuleName( const Reference< XFrame >& _rxFrame )
1278 {
1279 const sal_Char* pReturn = NULL;
1280
1281 try
1282 {
1283 // get the model of the document in the given frame
1284 Reference< XController > xController;
1285 if ( _rxFrame.is() )
1286 xController = _rxFrame->getController();
1287 Reference< XModel > xModel;
1288 if ( xController.is() )
1289 xModel = xController->getModel();
1290 Reference< XServiceInfo > xSI( xModel, UNO_QUERY );
1291
1292 if ( !xSI.is() )
1293 { // try to go up the frame hierarchy
1294
1295 Reference< XFrame > xParentFrame;
1296 if ( _rxFrame.is() )
1297 xParentFrame = xParentFrame.query( _rxFrame->getCreator() );
1298 // did we find a parent frame? Which is no top-level frame?
1299 if ( xParentFrame.is() && !_rxFrame->isTop() )
1300 // TODO: to prevent framework assertions, re-insert this "isTop" once 98303 is fixed
1301 return lcl_getModuleHelpModuleName( xParentFrame );
1302 }
1303 else
1304 {
1305 #if OSL_DEBUG_LEVEL > 0
1306 Sequence< ::rtl::OUString > sServiceNames = xSI->getSupportedServiceNames();
1307 const ::rtl::OUString* pLoop = sServiceNames.getConstArray();
1308 for ( sal_Int32 i=0; i<sServiceNames.getLength(); ++i, ++pLoop )
1309 {
1310 sal_Int32 nDummy = 0;
1311 (void)nDummy;
1312 }
1313 #endif
1314
1315 // check which service we know ....
1316 static const sal_Char* pTransTable[] = {
1317 "com.sun.star.sdb.OfficeDatabaseDocument","sdatabase",
1318 "com.sun.star.report.ReportDefinition","sdatabase",
1319 "com.sun.star.text.TextDocument", "swriter",
1320 "com.sun.star.sheet.SpreadsheetDocument", "scalc",
1321 "com.sun.star.presentation.PresentationDocument", "simpress",
1322 "com.sun.star.drawing.DrawingDocument", "sdraw",
1323 "com.sun.star.formula.FormularProperties", "smath",
1324 "com.sun.star.chart.ChartDocument", "schart"
1325 };
1326 OSL_ENSURE( ( sizeof( pTransTable ) / sizeof( pTransTable[0] ) ) % 2 == 0,
1327 "lcl_getModuleHelpModuleName: odd size of translation table!" );
1328
1329 // loop through the table
1330 sal_Int32 nTableEntries = ( sizeof( pTransTable ) / sizeof( pTransTable[0] ) ) / 2;
1331 const sal_Char** pDocumentService = pTransTable;
1332 const sal_Char** pHelpModuleName = pTransTable + 1;
1333 for ( sal_Int32 j=0; j<nTableEntries; ++j )
1334 {
1335 if ( xSI->supportsService( ::rtl::OUString::createFromAscii( *pDocumentService ) ) )
1336 { // found a table entry which matches the model's services
1337 pReturn = *pHelpModuleName;
1338 break;
1339 }
1340
1341 ++pDocumentService; ++pDocumentService;
1342 ++pHelpModuleName; ++pHelpModuleName;
1343 }
1344 }
1345
1346 if ( !pReturn )
1347 {
1348 // could not determine the document type we're living in
1349 // ->fallback
1350 SvtModuleOptions aModOpt;
1351 if ( aModOpt.IsModuleInstalled( SvtModuleOptions::E_SWRITER ) )
1352 pReturn = "swriter";
1353 else if ( aModOpt.IsModuleInstalled( SvtModuleOptions::E_SDATABASE ) )
1354 pReturn = "sdatabase";
1355 else if ( aModOpt.IsModuleInstalled( SvtModuleOptions::E_SCALC ) )
1356 pReturn = "scalc";
1357 else if ( aModOpt.IsModuleInstalled( SvtModuleOptions::E_SIMPRESS ) )
1358 pReturn = "simpress";
1359 else if ( aModOpt.IsModuleInstalled( SvtModuleOptions::E_SDRAW ) )
1360 pReturn = "sdraw";
1361 else if ( aModOpt.IsModuleInstalled( SvtModuleOptions::E_SMATH ) )
1362 pReturn = "smath";
1363 else if ( aModOpt.IsModuleInstalled( SvtModuleOptions::E_SCHART ) )
1364 pReturn = "schart";
1365 else if ( aModOpt.IsModuleInstalled( SvtModuleOptions::E_SBASIC ) )
1366 pReturn = "sbasic";
1367 else
1368 {
1369 OSL_ENSURE( sal_False, "lcl_getModuleHelpModuleName: no installed module found" );
1370 }
1371 }
1372 }
1373 catch( const Exception& )
1374 {
1375 DBG_UNHANDLED_EXCEPTION();
1376 }
1377
1378 if ( !pReturn )
1379 pReturn = "swriter";
1380
1381 return ::rtl::OUString::createFromAscii( pReturn );
1382 }
1383 }
1384
1385 // -----------------------------------------------------------------------------
1386
openHelpAgent(rtl::OUString const & _suHelpStringURL)1387 void OGenericUnoController::openHelpAgent(rtl::OUString const& _suHelpStringURL )
1388 {
1389 rtl::OUString suURL(_suHelpStringURL);
1390 rtl::OUString sLanguage = rtl::OUString::createFromAscii("Language=");
1391 if (suURL.indexOf(sLanguage) == -1)
1392 {
1393 AppendConfigToken(suURL, sal_False /* sal_False := add '&' */ );
1394 }
1395 URL aURL;
1396 aURL.Complete = suURL;
1397
1398 openHelpAgent( aURL );
1399 }
1400
openHelpAgent(const rtl::OString & _sHelpId)1401 void OGenericUnoController::openHelpAgent(const rtl::OString& _sHelpId)
1402 {
1403 openHelpAgent( createHelpAgentURL( lcl_getModuleHelpModuleName( getFrame() ), _sHelpId ) );
1404 }
1405
openHelpAgent(const URL & _rURL)1406 void OGenericUnoController::openHelpAgent( const URL& _rURL )
1407 {
1408 try
1409 {
1410 URL aURL( _rURL );
1411
1412 if ( m_xUrlTransformer.is() )
1413 m_xUrlTransformer->parseStrict(aURL);
1414
1415 Reference< XDispatchProvider > xDispProv( m_aCurrentFrame.getFrame(), UNO_QUERY );
1416 Reference< XDispatch > xHelpDispatch;
1417 if ( xDispProv.is() )
1418 xHelpDispatch = xDispProv->queryDispatch(aURL, ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("_helpagent")), FrameSearchFlag::PARENT | FrameSearchFlag::SELF);
1419 OSL_ENSURE(xHelpDispatch.is(), "SbaTableQueryBrowser::openHelpAgent: could not get a dispatcher!");
1420 if (xHelpDispatch.is())
1421 {
1422 xHelpDispatch->dispatch(aURL, Sequence< PropertyValue >());
1423 }
1424 }
1425 catch( const Exception& )
1426 {
1427 DBG_UNHANDLED_EXCEPTION();
1428 }
1429 }
1430 // -----------------------------------------------------------------------------
getTopMostContainerWindow() const1431 Reference< awt::XWindow> OGenericUnoController::getTopMostContainerWindow() const
1432 {
1433 Reference< ::com::sun::star::awt::XWindow> xWindow;
1434
1435 // get the top most window
1436 Reference< XFrame > xFrame( m_aCurrentFrame.getFrame() );
1437 if ( xFrame.is() )
1438 {
1439 xWindow = xFrame->getContainerWindow();
1440
1441 while ( xFrame.is() && !xFrame->isTop() )
1442 {
1443 xFrame.set( xFrame->getCreator(), UNO_QUERY );
1444 }
1445 if ( xFrame.is() )
1446 xWindow = xFrame->getContainerWindow();
1447 }
1448 return xWindow;
1449 }
1450 // -----------------------------------------------------------------------------
impl_getTitleHelper_throw()1451 Reference< XTitle > OGenericUnoController::impl_getTitleHelper_throw()
1452 {
1453 ::vos::OGuard aSolarGuard( Application::GetSolarMutex() );
1454 ::osl::MutexGuard aGuard( getMutex() );
1455
1456 if ( ! m_xTitleHelper.is ())
1457 {
1458 Reference< XUntitledNumbers > xUntitledProvider(getPrivateModel(), UNO_QUERY );
1459 Reference< XController > xThis(static_cast< XController* >(this), UNO_QUERY_THROW);
1460
1461 ::framework::TitleHelper* pHelper = new ::framework::TitleHelper(m_xServiceFactory);
1462 m_xTitleHelper.set( static_cast< ::cppu::OWeakObject* >(pHelper), UNO_QUERY_THROW);
1463
1464 pHelper->setOwner (xThis );
1465 pHelper->connectWithUntitledNumbers (xUntitledProvider);
1466 }
1467
1468 return m_xTitleHelper;
1469 }
1470
1471 //=============================================================================
1472 // XTitle
getTitle()1473 ::rtl::OUString SAL_CALL OGenericUnoController::getTitle()
1474 throw (RuntimeException)
1475 {
1476 ::osl::MutexGuard aGuard( getMutex() );
1477 if ( m_bExternalTitle )
1478 return impl_getTitleHelper_throw()->getTitle ();
1479 return getPrivateTitle() + impl_getTitleHelper_throw()->getTitle ();
1480 }
1481
1482 //=============================================================================
1483 // XTitle
setTitle(const::rtl::OUString & sTitle)1484 void SAL_CALL OGenericUnoController::setTitle(const ::rtl::OUString& sTitle)
1485 throw (RuntimeException)
1486 {
1487 vos::OGuard aSolarGuard( Application::GetSolarMutex() );
1488 ::osl::MutexGuard aGuard( getMutex() );
1489 m_bExternalTitle = sal_True;
1490 impl_getTitleHelper_throw()->setTitle (sTitle);
1491 }
1492
1493 //=============================================================================
1494 // XTitleChangeBroadcaster
addTitleChangeListener(const Reference<XTitleChangeListener> & xListener)1495 void SAL_CALL OGenericUnoController::addTitleChangeListener(const Reference< XTitleChangeListener >& xListener)
1496 throw (RuntimeException)
1497 {
1498 Reference< XTitleChangeBroadcaster > xBroadcaster(impl_getTitleHelper_throw(), UNO_QUERY);
1499 if (xBroadcaster.is ())
1500 xBroadcaster->addTitleChangeListener (xListener);
1501 }
1502
1503 // -----------------------------------------------------------------------------
removeTitleChangeListener(const Reference<XTitleChangeListener> & xListener)1504 void SAL_CALL OGenericUnoController::removeTitleChangeListener(const Reference< XTitleChangeListener >& xListener)
1505 throw (RuntimeException)
1506 {
1507 Reference< XTitleChangeBroadcaster > xBroadcaster(impl_getTitleHelper_throw(), UNO_QUERY);
1508 if (xBroadcaster.is ())
1509 xBroadcaster->removeTitleChangeListener (xListener);
1510 }
1511
1512 // =============================================================================
1513 // XUserInputInterception
1514 // -----------------------------------------------------------------------------
addKeyHandler(const Reference<XKeyHandler> & _rxHandler)1515 void SAL_CALL OGenericUnoController::addKeyHandler( const Reference< XKeyHandler >& _rxHandler ) throw (RuntimeException)
1516 {
1517 if ( _rxHandler.is() )
1518 m_pData->m_aUserInputInterception.addKeyHandler( _rxHandler );
1519 }
1520
1521 // -----------------------------------------------------------------------------
removeKeyHandler(const Reference<XKeyHandler> & _rxHandler)1522 void SAL_CALL OGenericUnoController::removeKeyHandler( const Reference< XKeyHandler >& _rxHandler ) throw (RuntimeException)
1523 {
1524 m_pData->m_aUserInputInterception.removeKeyHandler( _rxHandler );
1525 }
1526
1527 // -----------------------------------------------------------------------------
addMouseClickHandler(const Reference<XMouseClickHandler> & _rxHandler)1528 void SAL_CALL OGenericUnoController::addMouseClickHandler( const Reference< XMouseClickHandler >& _rxHandler ) throw (RuntimeException)
1529 {
1530 if ( _rxHandler.is() )
1531 m_pData->m_aUserInputInterception.addMouseClickHandler( _rxHandler );
1532 }
1533
1534 // -----------------------------------------------------------------------------
removeMouseClickHandler(const Reference<XMouseClickHandler> & _rxHandler)1535 void SAL_CALL OGenericUnoController::removeMouseClickHandler( const Reference< XMouseClickHandler >& _rxHandler ) throw (RuntimeException)
1536 {
1537 m_pData->m_aUserInputInterception.removeMouseClickHandler( _rxHandler );
1538 }
1539
1540 // =============================================================================
1541 // -----------------------------------------------------------------------------
executeChecked(sal_uInt16 _nCommandId,const Sequence<PropertyValue> & aArgs)1542 void OGenericUnoController::executeChecked(sal_uInt16 _nCommandId, const Sequence< PropertyValue >& aArgs)
1543 {
1544 if ( isCommandEnabled(_nCommandId) )
1545 Execute(_nCommandId, aArgs);
1546 }
1547
1548 // -----------------------------------------------------------------------------
isCommandEnabled(sal_uInt16 _nCommandId) const1549 sal_Bool OGenericUnoController::isCommandEnabled(sal_uInt16 _nCommandId) const
1550 {
1551 return GetState( _nCommandId ).bEnabled;
1552 }
1553
1554 // -----------------------------------------------------------------------------
registerCommandURL(const::rtl::OUString & _rCompleteCommandURL)1555 sal_uInt16 OGenericUnoController::registerCommandURL( const ::rtl::OUString& _rCompleteCommandURL )
1556 {
1557 if ( !_rCompleteCommandURL.getLength() )
1558 return 0;
1559
1560 SupportedFeatures::const_iterator aIter = m_aSupportedFeatures.find( _rCompleteCommandURL );
1561 if ( aIter != m_aSupportedFeatures.end() )
1562 return aIter->second.nFeatureId;
1563
1564 // this is a previously unkwnon command
1565 sal_uInt16 nFeatureId = FIRST_USER_DEFINED_FEATURE;
1566 while ( isFeatureSupported( nFeatureId ) && ( nFeatureId < LAST_USER_DEFINED_FEATURE ) )
1567 ++nFeatureId;
1568 if ( nFeatureId == LAST_USER_DEFINED_FEATURE )
1569 {
1570 OSL_ENSURE( false, "OGenericUnoController::registerCommandURL: no more space for user defined features!" );
1571 return 0L;
1572 }
1573
1574 ControllerFeature aFeature;
1575 aFeature.Command = _rCompleteCommandURL;
1576 aFeature.nFeatureId = nFeatureId;
1577 aFeature.GroupId = CommandGroup::INTERNAL;
1578 m_aSupportedFeatures[ aFeature.Command ] = aFeature;
1579
1580 return nFeatureId;
1581 }
1582
1583 // -----------------------------------------------------------------------------
notifyHiContrastChanged()1584 void OGenericUnoController::notifyHiContrastChanged()
1585 {
1586 }
1587
1588 // -----------------------------------------------------------------------------
isDataSourceReadOnly() const1589 sal_Bool OGenericUnoController::isDataSourceReadOnly() const
1590 {
1591 return sal_False;
1592 }
1593
1594 // -----------------------------------------------------------------------------
getXController()1595 Reference< XController > OGenericUnoController::getXController() throw( RuntimeException )
1596 {
1597 return this;
1598 }
1599
1600 // -----------------------------------------------------------------------------
interceptUserInput(const NotifyEvent & _rEvent)1601 bool OGenericUnoController::interceptUserInput( const NotifyEvent& _rEvent )
1602 {
1603 return m_pData->m_aUserInputInterception.handleNotifyEvent( _rEvent );
1604 }
1605
1606 // -----------------------------------------------------------------------------
isCommandChecked(sal_uInt16 _nCommandId) const1607 sal_Bool OGenericUnoController::isCommandChecked(sal_uInt16 _nCommandId) const
1608 {
1609 FeatureState aState = GetState( _nCommandId );
1610
1611 return aState.bChecked && (sal_Bool)*aState.bChecked;
1612 }
1613 // -----------------------------------------------------------------------------
isCommandEnabled(const::rtl::OUString & _rCompleteCommandURL) const1614 sal_Bool OGenericUnoController::isCommandEnabled( const ::rtl::OUString& _rCompleteCommandURL ) const
1615 {
1616 OSL_ENSURE( _rCompleteCommandURL.getLength(), "OGenericUnoController::isCommandEnabled: Empty command url!" );
1617
1618 sal_Bool bIsEnabled = sal_False;
1619 SupportedFeatures::const_iterator aIter = m_aSupportedFeatures.find( _rCompleteCommandURL );
1620 if ( aIter != m_aSupportedFeatures.end() )
1621 bIsEnabled = isCommandEnabled( aIter->second.nFeatureId );
1622
1623 return bIsEnabled;
1624 }
1625
1626 // -----------------------------------------------------------------------------
getSupportedCommandGroups()1627 Sequence< ::sal_Int16 > SAL_CALL OGenericUnoController::getSupportedCommandGroups() throw (RuntimeException)
1628 {
1629 CommandHashMap aCmdHashMap;
1630 for ( SupportedFeatures::const_iterator aIter = m_aSupportedFeatures.begin();
1631 aIter != m_aSupportedFeatures.end();
1632 ++aIter
1633 )
1634 if ( aIter->second.GroupId != CommandGroup::INTERNAL )
1635 aCmdHashMap.insert( CommandHashMap::value_type( aIter->second.GroupId, 0 ));
1636
1637 Sequence< sal_Int16 > aCommandGroups( aCmdHashMap.size() );
1638 ::std::transform( aCmdHashMap.begin(),
1639 aCmdHashMap.end(),
1640 aCommandGroups.getArray(),
1641 ::std::select1st< CommandHashMap::value_type >()
1642 );
1643
1644 return aCommandGroups;
1645 }
1646
1647 // -----------------------------------------------------------------------------
getConfigurableDispatchInformation(::sal_Int16 CommandGroup)1648 Sequence< DispatchInformation > SAL_CALL OGenericUnoController::getConfigurableDispatchInformation( ::sal_Int16 CommandGroup ) throw (RuntimeException)
1649 {
1650 DispatchInfoList aInformationList;
1651 DispatchInformation aDispatchInfo;
1652 for ( SupportedFeatures::const_iterator aIter = m_aSupportedFeatures.begin();
1653 aIter != m_aSupportedFeatures.end();
1654 ++aIter
1655 )
1656 {
1657 if ( sal_Int16( aIter->second.GroupId ) == CommandGroup )
1658 {
1659 aDispatchInfo = aIter->second;
1660 aInformationList.push_back( aDispatchInfo );
1661 }
1662 }
1663
1664 Sequence< DispatchInformation > aInformation( aInformationList.size() );
1665 ::std::transform( aInformationList.begin(),
1666 aInformationList.end(),
1667 aInformation.getArray(),
1668 ::std::identity< DispatchInformation >()
1669 );
1670
1671 return aInformation;
1672 }
1673 // -----------------------------------------------------------------------------
fillSupportedFeatures()1674 void OGenericUnoController::fillSupportedFeatures()
1675 {
1676 #ifdef DBG_UTIL
1677 m_bDescribingSupportedFeatures = true;
1678 #endif
1679 describeSupportedFeatures();
1680 // -----------------------------------------------------------------------------
1681 #ifdef DBG_UTIL
1682 m_bDescribingSupportedFeatures = false;
1683 #endif
1684 }
1685
1686
dispose()1687 void SAL_CALL OGenericUnoController::dispose() throw(::com::sun::star::uno::RuntimeException)
1688 {
1689 ::vos::OGuard aSolarGuard(Application::GetSolarMutex());
1690 OGenericUnoController_Base::dispose();
1691 }
1692 } // namespace dbaui
1693
1694