dbaccess/source/core/dataaccess/intercept.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20
  21 #include "intercept.hxx"
  22
  23 #include <comphelper/diagnose_ex.hxx>
  24
  25 #include <memory>
  26
  27 namespace dbaccess
  28 {
  29 using namespace ::com::sun::star::uno;
  30 using namespace ::com::sun::star::util;
  31 using namespace ::com::sun::star::beans;
  32 using namespace ::com::sun::star::lang;
  33 using namespace ::com::sun::star::sdbc;
  34 using namespace ::com::sun::star::frame;
  35 using namespace ::com::sun::star::io;
  36 using namespace ::com::sun::star::container;
  37 using namespace ::comphelper;
  38 using namespace ::cppu;
  39
  40 #define DISPATCH_SAVEAS     0
  41 #define DISPATCH_SAVE       1
  42 #define DISPATCH_CLOSEDOC   2
  43 #define DISPATCH_CLOSEWIN   3
  44 #define DISPATCH_CLOSEFRAME 4
  45 #define DISPATCH_RELOAD     5
  46 // the OSL_ENSURE in CTOR has to be changed too, when adding new defines
  47
  48 void OInterceptor::dispose()
  49 {
  50     EventObject aEvt( *this );
  51
  52     osl::MutexGuard aGuard(m_aMutex);
  53
  54     if ( m_pStatCL )
  55         m_pStatCL->disposeAndClear( aEvt );
  56
  57     m_xSlaveDispatchProvider.clear();
  58     m_xMasterDispatchProvider.clear();
  59
  60     m_pContentHolder = nullptr;
  61 }
  62
  63
  64 OInterceptor::OInterceptor( ODocumentDefinition* _pContentHolder )
  65     :m_pContentHolder( _pContentHolder )
  66     ,m_aInterceptedURL{ /* DISPATCH_SAVEAS     */ u".uno:SaveAs"_ustr,
  67                         /* DISPATCH_SAVE       */ u".uno:Save"_ustr,
  68                         /* DISPATCH_CLOSEDOC   */ u".uno:CloseDoc"_ustr,
  69                         /* DISPATCH_CLOSEWIN   */ u".uno:CloseWin"_ustr,
  70                         /* DISPATCH_CLOSEFRAME */ u".uno:CloseFrame"_ustr,
  71                         /* DISPATCH_RELOAD     */ u".uno:Reload"_ustr }
  72 {
  73     OSL_ENSURE(DISPATCH_RELOAD < m_aInterceptedURL.getLength(),"Illegal size.");
  74 }
  75
  76
  77 OInterceptor::~OInterceptor()
  78 {
  79 }
  80
  81 namespace {
  82
  83 struct DispatchHelper
  84 {
  85     URL aURL;
  86     Sequence<PropertyValue > aArguments;
  87 };
  88
  89 }
  90
  91 //XDispatch
  92 void SAL_CALL OInterceptor::dispatch( const URL& URL,const Sequence<PropertyValue >& Arguments )
  93 {
  94     ::osl::MutexGuard aGuard( m_aMutex );
  95     if ( !m_pContentHolder )
  96         return;
  97
  98     if ( URL.Complete == m_aInterceptedURL[ DISPATCH_SAVE ] )
  99     {
 100         m_pContentHolder->save(false, css::uno::Reference<css::awt::XTopWindow>());
 101         return;
 102     }
 103
 104     if ( URL.Complete == m_aInterceptedURL[ DISPATCH_RELOAD ] )
 105     {
 106         ODocumentDefinition::fillReportData(
 107             m_pContentHolder->getContext(),
 108             m_pContentHolder->getComponent(),
 109             m_pContentHolder->getConnection()
 110         );
 111         return;
 112     }
 113
 114     if( URL.Complete == m_aInterceptedURL[ DISPATCH_SAVEAS ] )
 115     {
 116         if ( m_pContentHolder->isNewReport() )
 117         {
 118             m_pContentHolder->saveAs();
 119         }
 120         else if ( m_xSlaveDispatchProvider.is() )
 121         {
 122             Sequence< PropertyValue > aNewArgs = Arguments;
 123             sal_Int32 nInd = 0;
 124
 125             while( nInd < aNewArgs.getLength() )
 126             {
 127                 if ( aNewArgs[nInd].Name == "SaveTo" )
 128                 {
 129                     aNewArgs.getArray()[nInd].Value <<= true;
 130                     break;
 131                 }
 132                 nInd++;
 133             }
 134
 135             if ( nInd == aNewArgs.getLength() )
 136             {
 137                 aNewArgs.realloc( nInd + 1 );
 138                 auto pNewArgs = aNewArgs.getArray();
 139                 pNewArgs[nInd].Name = "SaveTo";
 140                 pNewArgs[nInd].Value <<= true;
 141             }
 142
 143             Reference< XDispatch > xDispatch = m_xSlaveDispatchProvider->queryDispatch(URL, u"_self"_ustr, 0 );
 144             if ( xDispatch.is() )
 145                 xDispatch->dispatch( URL, aNewArgs );
 146         }
 147         return;
 148     }
 149
 150     if  (   URL.Complete == m_aInterceptedURL[ DISPATCH_CLOSEDOC ]
 151         ||  URL.Complete == m_aInterceptedURL[ DISPATCH_CLOSEWIN ]
 152         ||  URL.Complete == m_aInterceptedURL[ DISPATCH_CLOSEFRAME ]
 153         )
 154     {
 155         DispatchHelper* pHelper = new DispatchHelper;
 156         pHelper->aArguments = Arguments;
 157         pHelper->aURL = URL;
 158         Application::PostUserEvent( LINK( this, OInterceptor, OnDispatch ), pHelper );
 159         return;
 160     }
 161 }
 162
 163 IMPL_LINK( OInterceptor, OnDispatch, void*, _pDispatcher, void )
 164 {
 165     std::unique_ptr<DispatchHelper> pHelper( static_cast< DispatchHelper* >( _pDispatcher ) );
 166     try
 167     {
 168         if ( m_pContentHolder && m_pContentHolder->prepareClose() && m_xSlaveDispatchProvider.is() )
 169         {
 170             Reference< XDispatch > xDispatch = m_xSlaveDispatchProvider->queryDispatch(pHelper->aURL, u"_self"_ustr, 0 );
 171             if ( xDispatch.is() )
 172             {
 173                 Reference< XInterface > xKeepContentHolderAlive( *m_pContentHolder );
 174                 xDispatch->dispatch( pHelper->aURL,pHelper->aArguments);
 175             }
 176         }
 177     }
 178     catch ( const Exception& )
 179     {
 180         DBG_UNHANDLED_EXCEPTION("dbaccess");
 181     }
 182 }
 183
 184 void SAL_CALL OInterceptor::addStatusListener(
 185     const Reference<
 186     XStatusListener >& Control,
 187     const URL& URL )
 188 {
 189     if(!Control.is())
 190         return;
 191
 192     if ( m_pContentHolder && URL.Complete == m_aInterceptedURL[DISPATCH_SAVEAS] )
 193     {   // SaveAs
 194
 195         if ( !m_pContentHolder->isNewReport() )
 196         {
 197             FeatureStateEvent aStateEvent;
 198             aStateEvent.FeatureURL.Complete = m_aInterceptedURL[DISPATCH_SAVEAS];
 199             aStateEvent.FeatureDescriptor = "SaveCopyTo";
 200             aStateEvent.IsEnabled = true;
 201             aStateEvent.Requery = false;
 202             aStateEvent.State <<= u"($3)"_ustr;
 203             Control->statusChanged(aStateEvent);
 204         }
 205
 206         {
 207             osl::MutexGuard aGuard(m_aMutex);
 208             if(!m_pStatCL)
 209                 m_pStatCL.reset( new StatusListenerContainer(m_aMutex) );
 210         }
 211
 212         m_pStatCL->addInterface(URL.Complete,Control);
 213     }
 214     else if ( m_pContentHolder && URL.Complete == m_aInterceptedURL[DISPATCH_SAVE] )
 215     {   // Save
 216         FeatureStateEvent aStateEvent;
 217         aStateEvent.FeatureURL.Complete = m_aInterceptedURL[DISPATCH_SAVE];
 218         aStateEvent.FeatureDescriptor = "Update";
 219         aStateEvent.IsEnabled = true;
 220         aStateEvent.Requery = false;
 221
 222         Control->statusChanged(aStateEvent);
 223         {
 224             osl::MutexGuard aGuard(m_aMutex);
 225             if(!m_pStatCL)
 226                 m_pStatCL.reset( new StatusListenerContainer(m_aMutex) );
 227         }
 228
 229         m_pStatCL->addInterface(URL.Complete,Control);
 230     }
 231     else
 232     {
 233         sal_Int32 i = 2;
 234         if(URL.Complete == m_aInterceptedURL[i] ||
 235             URL.Complete == m_aInterceptedURL[++i] ||
 236             URL.Complete == m_aInterceptedURL[++i] ||
 237             URL.Complete == m_aInterceptedURL[i = DISPATCH_RELOAD] )
 238         {   // Close and return
 239             FeatureStateEvent aStateEvent;
 240             aStateEvent.FeatureURL.Complete = m_aInterceptedURL[i];
 241             aStateEvent.FeatureDescriptor = "Close and Return";
 242             aStateEvent.IsEnabled = true;
 243             aStateEvent.Requery = false;
 244             Control->statusChanged(aStateEvent);
 245
 246
 247             {
 248                 osl::MutexGuard aGuard(m_aMutex);
 249                 if(!m_pStatCL)
 250                     m_pStatCL.reset( new StatusListenerContainer(m_aMutex) );
 251             }
 252
 253             m_pStatCL->addInterface(URL.Complete,Control);
 254             return;
 255         }
 256     }
 257 }
 258
 259
 260 void SAL_CALL OInterceptor::removeStatusListener(
 261     const Reference<
 262     XStatusListener >& Control,
 263     const URL& URL )
 264 {
 265     if(!(Control.is() && m_pStatCL))
 266         return;
 267     else
 268     {
 269         m_pStatCL->removeInterface(URL.Complete,Control);
 270         return;
 271     }
 272 }
 273
 274
 275 //XInterceptorInfo
 276 Sequence< OUString > SAL_CALL OInterceptor::getInterceptedURLs(  )
 277 {
 278     // now implemented as update
 279     return m_aInterceptedURL;
 280 }
 281
 282
 283 // XDispatchProvider
 284
 285 Reference< XDispatch > SAL_CALL OInterceptor::queryDispatch( const URL& URL,const OUString& TargetFrameName,sal_Int32 SearchFlags )
 286 {
 287     osl::MutexGuard aGuard(m_aMutex);
 288     for (auto& interceptedUrl : m_aInterceptedURL)
 289         if (URL.Complete == interceptedUrl)
 290             return static_cast<XDispatch*>(this);
 291
 292     if(m_xSlaveDispatchProvider.is())
 293         return m_xSlaveDispatchProvider->queryDispatch(URL,TargetFrameName,SearchFlags);
 294     else
 295         return Reference<XDispatch>();
 296 }
 297
 298 Sequence< Reference< XDispatch > > SAL_CALL OInterceptor::queryDispatches(  const Sequence<DispatchDescriptor >& Requests )
 299 {
 300     osl::MutexGuard aGuard(m_aMutex);
 301     typedef Sequence<Reference<XDispatch>> DispatchSeq;
 302     DispatchSeq aRet = m_xSlaveDispatchProvider.is() ?
 303         m_xSlaveDispatchProvider->queryDispatches(Requests) :
 304         DispatchSeq(Requests.getLength());
 305
 306     auto aRetRange = asNonConstRange(aRet);
 307     for(sal_Int32 i = 0; i < Requests.getLength(); ++i)
 308     {
 309         for (auto& interceptedUrl : m_aInterceptedURL)
 310         {
 311             if (Requests[i].FeatureURL.Complete == interceptedUrl)
 312             {
 313                 aRetRange[i] = static_cast<XDispatch*>(this);
 314                 break;
 315             }
 316         }
 317     }
 318
 319     return aRet;
 320 }
 321
 322
 323 //XDispatchProviderInterceptor
 324
 325 Reference< XDispatchProvider > SAL_CALL OInterceptor::getSlaveDispatchProvider(  )
 326 {
 327     osl::MutexGuard aGuard(m_aMutex);
 328     return m_xSlaveDispatchProvider;
 329 }
 330
 331 void SAL_CALL
 332 OInterceptor::setSlaveDispatchProvider( const Reference< XDispatchProvider >& NewDispatchProvider )
 333 {
 334     osl::MutexGuard aGuard(m_aMutex);
 335     m_xSlaveDispatchProvider = NewDispatchProvider;
 336 }
 337
 338
 339 Reference< XDispatchProvider > SAL_CALL OInterceptor::getMasterDispatchProvider(  )
 340 {
 341     osl::MutexGuard aGuard(m_aMutex);
 342     return m_xMasterDispatchProvider;
 343 }
 344
 345
 346 void SAL_CALL OInterceptor::setMasterDispatchProvider(
 347     const Reference< XDispatchProvider >& NewSupplier )
 348 {
 349     osl::MutexGuard aGuard(m_aMutex);
 350     m_xMasterDispatchProvider = NewSupplier;
 351 }
 352
 353 }   // namespace dbaccess
 354
 355 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */