sc/source/ui/unoobj/dispuno.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <sfx2/viewfrm.hxx>
  21 #include <svx/dataaccessdescriptor.hxx>
  22 #include <svl/smplhint.hxx>
  23 #include <vcl/svapp.hxx>
  24
  25 #include <com/sun/star/frame/XDispatchProviderInterception.hpp>
  26 #include <com/sun/star/view/XSelectionSupplier.hpp>
  27 #include <com/sun/star/sdb/CommandType.hpp>
  28
  29 #include "dispuno.hxx"
  30 #include "tabvwsh.hxx"
  31 #include "dbdocfun.hxx"
  32 #include "dbdata.hxx"
  33
  34 using namespace com::sun::star;
  35
  36 static const char* cURLInsertColumns = ".uno:DataSourceBrowser/InsertColumns"; //data into text
  37 static const char* cURLDocDataSource = ".uno:DataSourceBrowser/DocumentDataSource";
  38
  39 static uno::Reference<view::XSelectionSupplier> lcl_GetSelectionSupplier( SfxViewShell* pViewShell )
  40 {
  41     if ( pViewShell )
  42     {
  43         SfxViewFrame* pViewFrame = pViewShell->GetViewFrame();
  44         if (pViewFrame)
  45         {
  46             return uno::Reference<view::XSelectionSupplier>( pViewFrame->GetFrame().GetController(), uno::UNO_QUERY );
  47         }
  48     }
  49     return uno::Reference<view::XSelectionSupplier>();
  50 }
  51
  52 ScDispatchProviderInterceptor::ScDispatchProviderInterceptor(ScTabViewShell* pViewSh) :
  53     pViewShell( pViewSh )
  54 {
  55     if ( pViewShell )
  56     {
  57         m_xIntercepted.set(uno::Reference<frame::XDispatchProviderInterception>(pViewShell->GetViewFrame()->GetFrame().GetFrameInterface(), uno::UNO_QUERY));
  58         if (m_xIntercepted.is())
  59         {
  60             osl_atomic_increment( &m_refCount );
  61
  62             m_xIntercepted->registerDispatchProviderInterceptor(
  63                         static_cast<frame::XDispatchProviderInterceptor*>(this));
  64             // this should make us the top-level dispatch-provider for the component, via a call to our
  65             // setDispatchProvider we should have got an fallback for requests we (i.e. our master) cannot fulfill
  66             uno::Reference<lang::XComponent> xInterceptedComponent(m_xIntercepted, uno::UNO_QUERY);
  67             if (xInterceptedComponent.is())
  68                 xInterceptedComponent->addEventListener(static_cast<lang::XEventListener*>(this));
  69
  70             osl_atomic_decrement( &m_refCount );
  71         }
  72
  73         StartListening(*pViewShell);
  74     }
  75 }
  76
  77 ScDispatchProviderInterceptor::~ScDispatchProviderInterceptor()
  78 {
  79     if (pViewShell)
  80         EndListening(*pViewShell);
  81 }
  82
  83 void ScDispatchProviderInterceptor::Notify( SfxBroadcaster&, const SfxHint& rHint )
  84 {
  85     const SfxSimpleHint* pSimpleHint = dynamic_cast<const SfxSimpleHint*>(&rHint);
  86     if ( pSimpleHint && pSimpleHint->GetId() == SFX_HINT_DYING )
  87         pViewShell = NULL;
  88 }
  89
  90 // XDispatchProvider
  91
  92 uno::Reference<frame::XDispatch> SAL_CALL ScDispatchProviderInterceptor::queryDispatch(
  93                         const util::URL& aURL, const OUString& aTargetFrameName,
  94                         sal_Int32 nSearchFlags )
  95                         throw(uno::RuntimeException, std::exception)
  96 {
  97     SolarMutexGuard aGuard;
  98
  99     uno::Reference<frame::XDispatch> xResult;
 100     // create some dispatch ...
 101     if ( pViewShell && (
 102         aURL.Complete.equalsAscii(cURLInsertColumns) ||
 103         aURL.Complete.equalsAscii(cURLDocDataSource) ) )
 104     {
 105         if (!m_xMyDispatch.is())
 106             m_xMyDispatch = new ScDispatch( pViewShell );
 107         xResult = m_xMyDispatch;
 108     }
 109
 110     // ask our slave provider
 111     if (!xResult.is() && m_xSlaveDispatcher.is())
 112         xResult = m_xSlaveDispatcher->queryDispatch(aURL, aTargetFrameName, nSearchFlags);
 113
 114     return xResult;
 115 }
 116
 117 uno::Sequence< uno::Reference<frame::XDispatch> > SAL_CALL
 118                         ScDispatchProviderInterceptor::queryDispatches(
 119                         const uno::Sequence<frame::DispatchDescriptor>& aDescripts )
 120                         throw(uno::RuntimeException, std::exception)
 121 {
 122     SolarMutexGuard aGuard;
 123
 124     uno::Sequence< uno::Reference< frame::XDispatch> > aReturn(aDescripts.getLength());
 125     uno::Reference< frame::XDispatch>* pReturn = aReturn.getArray();
 126     const frame::DispatchDescriptor* pDescripts = aDescripts.getConstArray();
 127     for (sal_Int16 i=0; i<aDescripts.getLength(); ++i, ++pReturn, ++pDescripts)
 128     {
 129         *pReturn = queryDispatch(pDescripts->FeatureURL,
 130                 pDescripts->FrameName, pDescripts->SearchFlags);
 131     }
 132     return aReturn;
 133 }
 134
 135 // XDispatchProviderInterceptor
 136
 137 uno::Reference<frame::XDispatchProvider> SAL_CALL
 138                         ScDispatchProviderInterceptor::getSlaveDispatchProvider()
 139                         throw(uno::RuntimeException, std::exception)
 140 {
 141     SolarMutexGuard aGuard;
 142     return m_xSlaveDispatcher;
 143 }
 144
 145 void SAL_CALL ScDispatchProviderInterceptor::setSlaveDispatchProvider(
 146                         const uno::Reference<frame::XDispatchProvider>& xNewDispatchProvider )
 147                         throw(uno::RuntimeException, std::exception)
 148 {
 149     SolarMutexGuard aGuard;
 150     m_xSlaveDispatcher.set(xNewDispatchProvider);
 151 }
 152
 153 uno::Reference<frame::XDispatchProvider> SAL_CALL
 154                         ScDispatchProviderInterceptor::getMasterDispatchProvider()
 155                         throw(uno::RuntimeException, std::exception)
 156 {
 157     SolarMutexGuard aGuard;
 158     return m_xMasterDispatcher;
 159 }
 160
 161 void SAL_CALL ScDispatchProviderInterceptor::setMasterDispatchProvider(
 162                         const uno::Reference<frame::XDispatchProvider>& xNewSupplier )
 163                         throw(uno::RuntimeException, std::exception)
 164 {
 165     SolarMutexGuard aGuard;
 166     m_xMasterDispatcher.set(xNewSupplier);
 167 }
 168
 169 // XEventListener
 170
 171 void SAL_CALL ScDispatchProviderInterceptor::disposing( const lang::EventObject& /* Source */ )
 172                                 throw(::com::sun::star::uno::RuntimeException, std::exception)
 173 {
 174     SolarMutexGuard aGuard;
 175
 176     if (m_xIntercepted.is())
 177     {
 178         m_xIntercepted->releaseDispatchProviderInterceptor(
 179                 static_cast<frame::XDispatchProviderInterceptor*>(this));
 180         uno::Reference<lang::XComponent> xInterceptedComponent(m_xIntercepted, uno::UNO_QUERY);
 181         if (xInterceptedComponent.is())
 182             xInterceptedComponent->removeEventListener(static_cast<lang::XEventListener*>(this));
 183
 184         m_xMyDispatch = NULL;
 185     }
 186     m_xIntercepted = NULL;
 187 }
 188
 189 ScDispatch::ScDispatch(ScTabViewShell* pViewSh) :
 190     pViewShell( pViewSh ),
 191     bListeningToView( false )
 192 {
 193     if (pViewShell)
 194         StartListening(*pViewShell);
 195 }
 196
 197 ScDispatch::~ScDispatch()
 198 {
 199     if (pViewShell)
 200         EndListening(*pViewShell);
 201
 202     if (bListeningToView && pViewShell)
 203     {
 204         uno::Reference<view::XSelectionSupplier> xSupplier(lcl_GetSelectionSupplier( pViewShell ));
 205         if ( xSupplier.is() )
 206             xSupplier->removeSelectionChangeListener(this);
 207     }
 208 }
 209
 210 void ScDispatch::Notify( SfxBroadcaster&, const SfxHint& rHint )
 211 {
 212     const SfxSimpleHint* pSimpleHint = dynamic_cast<const SfxSimpleHint*>(&rHint);
 213     if ( pSimpleHint && pSimpleHint->GetId() == SFX_HINT_DYING )
 214         pViewShell = NULL;
 215 }
 216
 217 // XDispatch
 218
 219 void SAL_CALL ScDispatch::dispatch( const util::URL& aURL,
 220                                 const uno::Sequence<beans::PropertyValue>& aArgs )
 221                                 throw(uno::RuntimeException, std::exception)
 222 {
 223     SolarMutexGuard aGuard;
 224
 225     bool bDone = false;
 226     if ( pViewShell && aURL.Complete.equalsAscii(cURLInsertColumns) )
 227     {
 228         ScViewData& rViewData = pViewShell->GetViewData();
 229         ScAddress aPos( rViewData.GetCurX(), rViewData.GetCurY(), rViewData.GetTabNo() );
 230
 231         ScDBDocFunc aFunc( *rViewData.GetDocShell() );
 232         bDone = aFunc.DoImportUno( aPos, aArgs );
 233     }
 234     // cURLDocDataSource is never dispatched
 235
 236     if (!bDone)
 237         throw uno::RuntimeException();
 238 }
 239
 240 static void lcl_FillDataSource( frame::FeatureStateEvent& rEvent, const ScImportParam& rParam )
 241 {
 242     rEvent.IsEnabled = rParam.bImport;
 243
 244     svx::ODataAccessDescriptor aDescriptor;
 245     if ( rParam.bImport )
 246     {
 247         sal_Int32 nType = rParam.bSql ? sdb::CommandType::COMMAND :
 248                     ( (rParam.nType == ScDbQuery) ? sdb::CommandType::QUERY :
 249                                                     sdb::CommandType::TABLE );
 250
 251         aDescriptor.setDataSource(rParam.aDBName);
 252         aDescriptor[svx::daCommand]     <<= rParam.aStatement;
 253         aDescriptor[svx::daCommandType] <<= nType;
 254     }
 255     else
 256     {
 257         //  descriptor has to be complete anyway
 258
 259         OUString aEmpty;
 260         aDescriptor[svx::daDataSource]  <<= aEmpty;
 261         aDescriptor[svx::daCommand]     <<= aEmpty;
 262         aDescriptor[svx::daCommandType] <<= (sal_Int32)sdb::CommandType::TABLE;
 263     }
 264     rEvent.State <<= aDescriptor.createPropertyValueSequence();
 265 }
 266
 267 void SAL_CALL ScDispatch::addStatusListener(
 268     const uno::Reference<frame::XStatusListener>& xListener,
 269     const util::URL& aURL)
 270         throw(uno::RuntimeException, std::exception)
 271 {
 272     SolarMutexGuard aGuard;
 273
 274     if (!pViewShell)
 275         throw uno::RuntimeException();
 276
 277     //  initial state
 278     frame::FeatureStateEvent aEvent;
 279     aEvent.IsEnabled = sal_True;
 280     aEvent.Source.set(static_cast<cppu::OWeakObject*>(this));
 281     aEvent.FeatureURL = aURL;
 282
 283     if ( aURL.Complete.equalsAscii(cURLDocDataSource) )
 284     {
 285         uno::Reference<frame::XStatusListener>* pObj =
 286                 new uno::Reference<frame::XStatusListener>( xListener );
 287         aDataSourceListeners.push_back( pObj );
 288
 289         if (!bListeningToView)
 290         {
 291             uno::Reference<view::XSelectionSupplier> xSupplier(lcl_GetSelectionSupplier( pViewShell ));
 292             if ( xSupplier.is() )
 293                 xSupplier->addSelectionChangeListener(this);
 294             bListeningToView = true;
 295         }
 296
 297         ScDBData* pDBData = pViewShell->GetDBData(false,SC_DB_OLD);
 298         if ( pDBData )
 299             pDBData->GetImportParam( aLastImport );
 300         lcl_FillDataSource( aEvent, aLastImport );          // modifies State, IsEnabled
 301     }
 302     //! else add to listener for "enabled" changes?
 303
 304     xListener->statusChanged( aEvent );
 305 }
 306
 307 void SAL_CALL ScDispatch::removeStatusListener(
 308                                 const uno::Reference<frame::XStatusListener>& xListener,
 309                                 const util::URL& aURL )
 310                                 throw(uno::RuntimeException, std::exception)
 311 {
 312     SolarMutexGuard aGuard;
 313
 314     if ( aURL.Complete.equalsAscii(cURLDocDataSource) )
 315     {
 316         sal_uInt16 nCount = aDataSourceListeners.size();
 317         for ( sal_uInt16 n=nCount; n--; )
 318         {
 319             uno::Reference<frame::XStatusListener>& rObj = aDataSourceListeners[n];
 320             if ( rObj == xListener )
 321             {
 322                 aDataSourceListeners.erase( aDataSourceListeners.begin() + n );
 323                 break;
 324             }
 325         }
 326
 327         if ( aDataSourceListeners.empty() && pViewShell )
 328         {
 329             uno::Reference<view::XSelectionSupplier> xSupplier(lcl_GetSelectionSupplier( pViewShell ));
 330             if ( xSupplier.is() )
 331                 xSupplier->removeSelectionChangeListener(this);
 332             bListeningToView = false;
 333         }
 334     }
 335 }
 336
 337 // XSelectionChangeListener
 338
 339 void SAL_CALL ScDispatch::selectionChanged( const ::com::sun::star::lang::EventObject& /* aEvent */ )
 340     throw (::com::sun::star::uno::RuntimeException, std::exception)
 341 {
 342     //  currently only called for URL cURLDocDataSource
 343
 344     if ( pViewShell )
 345     {
 346         ScImportParam aNewImport;
 347         ScDBData* pDBData = pViewShell->GetDBData(false,SC_DB_OLD);
 348         if ( pDBData )
 349             pDBData->GetImportParam( aNewImport );
 350
 351         //  notify listeners only if data source has changed
 352         if ( aNewImport.bImport    != aLastImport.bImport ||
 353              aNewImport.aDBName    != aLastImport.aDBName ||
 354              aNewImport.aStatement != aLastImport.aStatement ||
 355              aNewImport.bSql       != aLastImport.bSql ||
 356              aNewImport.nType      != aLastImport.nType )
 357         {
 358             frame::FeatureStateEvent aEvent;
 359             aEvent.Source.set(static_cast<cppu::OWeakObject*>(this));
 360             aEvent.FeatureURL.Complete = OUString::createFromAscii( cURLDocDataSource );
 361
 362             lcl_FillDataSource( aEvent, aNewImport );       // modifies State, IsEnabled
 363
 364             for ( sal_uInt16 n=0; n<aDataSourceListeners.size(); n++ )
 365                 aDataSourceListeners[n]->statusChanged( aEvent );
 366
 367             aLastImport = aNewImport;
 368         }
 369     }
 370 }
 371
 372 // XEventListener
 373
 374 void SAL_CALL ScDispatch::disposing( const ::com::sun::star::lang::EventObject& rSource )
 375                                 throw (::com::sun::star::uno::RuntimeException, std::exception)
 376 {
 377     uno::Reference<view::XSelectionSupplier> xSupplier(rSource.Source, uno::UNO_QUERY);
 378     xSupplier->removeSelectionChangeListener(this);
 379     bListeningToView = false;
 380
 381     lang::EventObject aEvent;
 382     aEvent.Source.set(static_cast<cppu::OWeakObject*>(this));
 383     for ( sal_uInt16 n=0; n<aDataSourceListeners.size(); n++ )
 384         aDataSourceListeners[n]->disposing( aEvent );
 385
 386     pViewShell = NULL;
 387 }
 388
 389 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */