LCOV - code coverage report
Current view: top level - dbaccess/source/ui/browser - genericcontroller.cxx (source / functions) Hit Total Coverage
Test: commit 10e77ab3ff6f4314137acd6e2702a6e5c1ce1fae Lines: 396 670 59.1 %
Date: 2014-11-03 Functions: 65 108 60.2 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.10