svx/source/form/formcontrolling.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 <sal/macros.h>
  22 #include "formcontrolling.hxx"
  23 #include "fmurl.hxx"
  24 #include "svx/svxids.hrc"
  25 #include "fmprop.hrc"
  26 #include "svx/fmtools.hxx"
  27
  28 #include <com/sun/star/form/runtime/FormOperations.hpp>
  29 #include <com/sun/star/form/runtime/FormFeature.hpp>
  30 #include <com/sun/star/beans/XPropertySet.hpp>
  31 #include <com/sun/star/sdb/XSQLErrorBroadcaster.hpp>
  32
  33 #include <tools/diagnose_ex.h>
  34 #include <comphelper/anytostring.hxx>
  35 #include <comphelper/processfactory.hxx>
  36 #include <cppuhelper/exc_hlp.hxx>
  37 #include <osl/diagnose.h>
  38
  39 #include <functional>
  40 #include <algorithm>
  41
  42
  43 namespace svx
  44 {
  45
  46
  47     using ::com::sun::star::uno::Reference;
  48     using ::com::sun::star::uno::XComponentContext;
  49     using ::com::sun::star::form::runtime::XFormController;
  50     using ::com::sun::star::form::XForm;
  51     using ::com::sun::star::form::runtime::FormOperations;
  52     using ::com::sun::star::uno::Exception;
  53     using ::com::sun::star::sdbc::XRowSet;
  54     using ::com::sun::star::form::runtime::FeatureState;
  55     using ::com::sun::star::uno::Any;
  56     using ::com::sun::star::uno::Sequence;
  57     using ::com::sun::star::beans::NamedValue;
  58     using ::com::sun::star::uno::RuntimeException;
  59     using ::com::sun::star::beans::XPropertySet;
  60     using ::com::sun::star::uno::UNO_QUERY_THROW;
  61     using ::com::sun::star::sdbc::SQLException;
  62     using ::com::sun::star::sdb::XSQLErrorBroadcaster;
  63     using ::com::sun::star::sdb::SQLErrorEvent;
  64     using ::com::sun::star::lang::EventObject;
  65
  66     namespace FormFeature = ::com::sun::star::form::runtime::FormFeature;
  67
  68
  69     //= FeatureSlotTranslation
  70
  71     namespace
  72     {
  73         struct FeatureDescription
  74         {
  75             OUString sURL;           // the URL
  76             sal_Int32       nSlotId;        // the SFX-compatible slot ID
  77             sal_Int16       nFormFeature;   // the css.form.runtime.FormFeature ID
  78         };
  79         typedef ::std::vector< FeatureDescription > FeatureDescriptions;
  80
  81
  82         const FeatureDescriptions& getFeatureDescriptions()
  83         {
  84             static FeatureDescriptions s_aFeatureDescriptions;
  85             if ( s_aFeatureDescriptions.empty() )
  86             {
  87                 ::osl::MutexGuard aGuard( ::osl::Mutex::getGlobalMutex() );
  88                 if ( s_aFeatureDescriptions.empty() )
  89                 {
  90                     FeatureDescription aDescriptions[] = {
  91                         { FMURL_FORM_POSITION,        SID_FM_RECORD_ABSOLUTE,     FormFeature::MoveAbsolute },
  92                         { FMURL_FORM_RECORDCOUNT,     SID_FM_RECORD_TOTAL,        FormFeature::TotalRecords },
  93                         { FMURL_RECORD_MOVEFIRST,     SID_FM_RECORD_FIRST,        FormFeature::MoveToFirst },
  94                         { FMURL_RECORD_MOVEPREV,      SID_FM_RECORD_PREV,         FormFeature::MoveToPrevious },
  95                         { FMURL_RECORD_MOVENEXT,      SID_FM_RECORD_NEXT,         FormFeature::MoveToNext },
  96                         { FMURL_RECORD_MOVELAST,      SID_FM_RECORD_LAST,         FormFeature::MoveToLast },
  97                         { FMURL_RECORD_MOVETONEW,     SID_FM_RECORD_NEW,          FormFeature::MoveToInsertRow },
  98                         { FMURL_RECORD_SAVE,          SID_FM_RECORD_SAVE,         FormFeature::SaveRecordChanges },
  99                         { FMURL_RECORD_DELETE,        SID_FM_RECORD_DELETE,       FormFeature::DeleteRecord },
 100                         { FMURL_FORM_REFRESH,         SID_FM_REFRESH,             FormFeature::ReloadForm },
 101                         { FMURL_FORM_REFRESH_CURRENT_CONTROL,
 102                                                       SID_FM_REFRESH_FORM_CONTROL,FormFeature::RefreshCurrentControl },
 103                         { FMURL_RECORD_UNDO,          SID_FM_RECORD_UNDO,         FormFeature::UndoRecordChanges },
 104                         { FMURL_FORM_SORT_UP,         SID_FM_SORTUP,              FormFeature::SortAscending },
 105                         { FMURL_FORM_SORT_DOWN,       SID_FM_SORTDOWN,            FormFeature::SortDescending },
 106                         { FMURL_FORM_SORT,            SID_FM_ORDERCRIT,           FormFeature::InteractiveSort },
 107                         { FMURL_FORM_AUTO_FILTER,     SID_FM_AUTOFILTER,          FormFeature::AutoFilter },
 108                         { FMURL_FORM_FILTER,          SID_FM_FILTERCRIT,          FormFeature::InteractiveFilter },
 109                         { FMURL_FORM_APPLY_FILTER,    SID_FM_FORM_FILTERED,       FormFeature::ToggleApplyFilter },
 110                         { FMURL_FORM_REMOVE_FILTER,   SID_FM_REMOVE_FILTER_SORT,  FormFeature::RemoveFilterAndSort }
 111                     };
 112                     for ( size_t i=0; i<sizeof(aDescriptions)/sizeof(aDescriptions[0]); ++i )
 113                         s_aFeatureDescriptions.push_back( aDescriptions[i] );
 114                 }
 115             };
 116             return s_aFeatureDescriptions;
 117         }
 118     }
 119
 120
 121     namespace
 122     {
 123
 124         struct MatchFeatureDescriptionByURL : public ::std::unary_function< FeatureDescription, bool >
 125         {
 126             const OUString&  m_rURL;
 127             MatchFeatureDescriptionByURL( const OUString& _rURL ) :m_rURL( _rURL ) { }
 128
 129             bool operator()( const FeatureDescription& _compare )
 130             {
 131                 return m_rURL == _compare.sURL;
 132             }
 133         };
 134
 135
 136         struct MatchFeatureDescriptionBySlotId : public ::std::unary_function< FeatureDescription, bool >
 137         {
 138             sal_Int32   m_nSlotId;
 139             MatchFeatureDescriptionBySlotId( sal_Int32 _nSlotId ) :m_nSlotId( _nSlotId ) { }
 140
 141             bool operator()( const FeatureDescription& _compare )
 142             {
 143                 return m_nSlotId == _compare.nSlotId;
 144             }
 145         };
 146
 147
 148         struct MatchFeatureDescriptionByFormFeature : public ::std::unary_function< FeatureDescription, bool >
 149         {
 150             sal_Int32   m_nFormFeature;
 151             MatchFeatureDescriptionByFormFeature( sal_Int32 _nFormFeature ) :m_nFormFeature( _nFormFeature ) { }
 152
 153             bool operator()( const FeatureDescription& _compare )
 154             {
 155                 return m_nFormFeature == _compare.nFormFeature;
 156             }
 157         };
 158
 159
 160         struct FormFeatureToSlotId : public ::std::unary_function< sal_Int16, sal_Int32 >
 161         {
 162             sal_Int32 operator()( sal_Int16 _FormFeature )
 163             {
 164                 return FeatureSlotTranslation::getSlotIdForFormFeature( _FormFeature );
 165             }
 166         };
 167     }
 168
 169
 170     sal_Int32 FeatureSlotTranslation::getControllerFeatureSlotIdForURL( const OUString& _rMainURL )
 171     {
 172         const FeatureDescriptions& rDescriptions( getFeatureDescriptions() );
 173         FeatureDescriptions::const_iterator pos = ::std::find_if( rDescriptions.begin(), rDescriptions.end(), MatchFeatureDescriptionByURL( _rMainURL ) );
 174         return ( pos != rDescriptions.end() ) ? pos->nSlotId : -1;
 175     }
 176
 177
 178     sal_Int16 FeatureSlotTranslation::getFormFeatureForSlotId( sal_Int32 _nSlotId )
 179     {
 180         const FeatureDescriptions& rDescriptions( getFeatureDescriptions() );
 181         FeatureDescriptions::const_iterator pos = ::std::find_if( rDescriptions.begin(), rDescriptions.end(), MatchFeatureDescriptionBySlotId( _nSlotId ) );
 182         OSL_ENSURE( pos != rDescriptions.end(), "FeatureSlotTranslation::getFormFeatureForSlotId: not found!" );
 183         return ( pos != rDescriptions.end() ) ? pos->nFormFeature : -1;
 184     }
 185
 186
 187     sal_Int32 FeatureSlotTranslation::getSlotIdForFormFeature( sal_Int16 _nFormFeature )
 188     {
 189         const FeatureDescriptions& rDescriptions( getFeatureDescriptions() );
 190         FeatureDescriptions::const_iterator pos = ::std::find_if( rDescriptions.begin(), rDescriptions.end(), MatchFeatureDescriptionByFormFeature( _nFormFeature ) );
 191         OSL_ENSURE( pos != rDescriptions.end(), "FeatureSlotTranslation::getSlotIdForFormFeature: not found!" );
 192         return ( pos != rDescriptions.end() ) ? pos->nSlotId : -1;
 193     }
 194
 195
 196     //= ControllerFeatures
 197
 198
 199     ControllerFeatures::ControllerFeatures( IControllerFeatureInvalidation* _pInvalidationCallback )
 200         :m_pInvalidationCallback( _pInvalidationCallback )
 201         ,m_pImpl( NULL )
 202     {
 203     }
 204
 205
 206     ControllerFeatures::ControllerFeatures( const Reference< XFormController >& _rxController, IControllerFeatureInvalidation* _pInvalidationCallback )
 207         :m_pInvalidationCallback( _pInvalidationCallback )
 208         ,m_pImpl( NULL )
 209     {
 210         assign( _rxController );
 211     }
 212
 213
 214     void ControllerFeatures::assign( const Reference< XFormController >& _rxController )
 215     {
 216         dispose();
 217         m_pImpl = new FormControllerHelper( _rxController, m_pInvalidationCallback );
 218         m_pImpl->acquire();
 219     }
 220
 221
 222     ControllerFeatures::~ControllerFeatures()
 223     {
 224         dispose();
 225     }
 226
 227
 228     void ControllerFeatures::dispose()
 229     {
 230         if ( m_pImpl )
 231         {
 232             m_pImpl->dispose();
 233             m_pImpl->release();
 234             m_pImpl = NULL;
 235         }
 236     }
 237
 238
 239     //= FormControllerHelper
 240
 241
 242     FormControllerHelper::FormControllerHelper( const Reference< XFormController >& _rxController, IControllerFeatureInvalidation* _pInvalidationCallback )
 243         :m_pInvalidationCallback( _pInvalidationCallback )
 244     {
 245         osl_atomic_increment( &m_refCount );
 246         try
 247         {
 248             m_xFormOperations = FormOperations::createWithFormController( comphelper::getProcessComponentContext(), _rxController );
 249             if ( m_xFormOperations.is() )
 250                 m_xFormOperations->setFeatureInvalidation( this );
 251
 252             // to prevent the controller from displaying any error messages which happen while we operate on it,
 253             // we add ourself as XSQLErrorListener. By contract, a FormController displays errors if and only if
 254             // no SQLErrorListeners are registered.
 255             _rxController->addSQLErrorListener( this );
 256         }
 257         catch( const Exception& )
 258         {
 259             DBG_UNHANDLED_EXCEPTION();
 260         }
 261         osl_atomic_decrement( &m_refCount );
 262     }
 263
 264
 265     FormControllerHelper::~FormControllerHelper( )
 266     {
 267         try
 268         {
 269             acquire();
 270             dispose();
 271         }
 272         catch( const Exception& )
 273         {
 274             DBG_UNHANDLED_EXCEPTION();
 275         }
 276     }
 277
 278
 279     void FormControllerHelper::dispose()
 280     {
 281         if ( m_xFormOperations.is() )
 282             m_xFormOperations->dispose();
 283         m_xFormOperations.clear();
 284     }
 285
 286
 287     bool FormControllerHelper::isEnabled( sal_Int32 _nSlotId ) const
 288     {
 289         if ( !m_xFormOperations.is() )
 290             return false;
 291         return m_xFormOperations->isEnabled( FeatureSlotTranslation::getFormFeatureForSlotId( _nSlotId ) );
 292     }
 293
 294
 295     Reference< XRowSet > FormControllerHelper::getCursor() const
 296     {
 297         Reference< XRowSet > xCursor;
 298         if ( m_xFormOperations.is() )
 299             xCursor = m_xFormOperations->getCursor();
 300         return xCursor;
 301     }
 302
 303
 304     void FormControllerHelper::getState( sal_Int32 _nSlotId, FeatureState& _rState ) const
 305     {
 306         if ( m_xFormOperations.is() )
 307             _rState = m_xFormOperations->getState( FeatureSlotTranslation::getFormFeatureForSlotId( _nSlotId ) );
 308     }
 309
 310
 311     bool FormControllerHelper::commitCurrentControl( ) const
 312     {
 313         return impl_operateForm_nothrow( COMMIT_CONTROL );
 314     }
 315
 316
 317     bool FormControllerHelper::commitCurrentRecord() const
 318     {
 319         return impl_operateForm_nothrow( COMMIT_RECORD );
 320     }
 321
 322
 323     void FormControllerHelper::execute( sal_Int32 _nSlotId, const OUString& _rParamName, const Any& _rParamValue ) const
 324     {
 325         Sequence< NamedValue > aArguments(1);
 326         aArguments[0].Name = _rParamName;
 327         aArguments[0].Value = _rParamValue;
 328
 329         impl_operateForm_nothrow( EXECUTE_ARGS, FeatureSlotTranslation::getFormFeatureForSlotId( _nSlotId ), aArguments );
 330     }
 331
 332
 333     bool FormControllerHelper::impl_operateForm_nothrow( const FormOperation _eWhat, const sal_Int16 _nFeature,
 334             const Sequence< NamedValue >& _rArguments ) const
 335     {
 336         if ( !m_xFormOperations.is() )
 337             return false;
 338
 339         Any aError;
 340         bool bSuccess = false;
 341         const_cast< FormControllerHelper* >( this )->m_aOperationError.clear();
 342         try
 343         {
 344             switch ( _eWhat )
 345             {
 346             case COMMIT_CONTROL:
 347                 bSuccess = m_xFormOperations->commitCurrentControl();
 348                 break;
 349
 350             case COMMIT_RECORD:
 351             {
 352                 sal_Bool bDummy( sal_False );
 353                 bSuccess = m_xFormOperations->commitCurrentRecord( bDummy );
 354             }
 355             break;
 356
 357             case EXECUTE:
 358                 m_xFormOperations->execute( _nFeature );
 359                 bSuccess = true;
 360                 break;
 361
 362             case EXECUTE_ARGS:
 363                 m_xFormOperations->executeWithArguments( _nFeature, _rArguments );
 364                 bSuccess = true;
 365                 break;
 366             }
 367         }
 368         catch ( const SQLException& )
 369         {
 370             aError = ::cppu::getCaughtException();
 371         }
 372         catch( const Exception& )
 373         {
 374             SQLException aFallbackError;
 375             aFallbackError.Message = ::comphelper::anyToString( ::cppu::getCaughtException() );
 376             aError <<= aFallbackError;
 377         }
 378
 379         if ( bSuccess )
 380             return true;
 381
 382         // display the error. Prefer the one reported in errorOccurred over the one caught.
 383         if ( m_aOperationError.hasValue() )
 384             displayException( m_aOperationError );
 385         else if ( aError.hasValue() )
 386             displayException( aError );
 387         else
 388             OSL_FAIL( "FormControllerHelper::impl_operateForm_nothrow: no success, but no error?" );
 389
 390         return false;
 391     }
 392
 393
 394     void FormControllerHelper::execute( sal_Int32 _nSlotId ) const
 395     {
 396         impl_operateForm_nothrow( EXECUTE, FeatureSlotTranslation::getFormFeatureForSlotId( _nSlotId ),
 397             Sequence< NamedValue >() );
 398     }
 399
 400
 401     void SAL_CALL FormControllerHelper::invalidateFeatures( const Sequence< ::sal_Int16 >& _Features ) throw (RuntimeException, std::exception)
 402     {
 403         if ( !m_pInvalidationCallback )
 404             // nobody's interested in ...
 405             return;
 406
 407         ::std::vector< sal_Int32 > aFeatures( _Features.getLength() );
 408         ::std::transform(
 409             _Features.getConstArray(),
 410             _Features.getConstArray() + _Features.getLength(),
 411             aFeatures.begin(),
 412             FormFeatureToSlotId()
 413         );
 414
 415         m_pInvalidationCallback->invalidateFeatures( aFeatures );
 416     }
 417
 418
 419     void SAL_CALL FormControllerHelper::invalidateAllFeatures() throw (RuntimeException, std::exception)
 420     {
 421         if ( !m_pInvalidationCallback )
 422             // nobody's interested in ...
 423             return;
 424
 425         // actually, it's a little bit more than the supported features,
 426         // but on the medium term, we are to support everything listed
 427         // here
 428         ::std::vector< sal_Int32 > aSupportedFeatures;
 429         sal_Int32 pSupportedFeatures[] =
 430         {
 431             SID_FM_RECORD_FIRST,
 432             SID_FM_RECORD_NEXT,
 433             SID_FM_RECORD_PREV,
 434             SID_FM_RECORD_LAST,
 435             SID_FM_RECORD_NEW,
 436             SID_FM_RECORD_DELETE,
 437             SID_FM_RECORD_ABSOLUTE,
 438             SID_FM_RECORD_TOTAL,
 439             SID_FM_RECORD_SAVE,
 440             SID_FM_RECORD_UNDO,
 441             SID_FM_REMOVE_FILTER_SORT,
 442             SID_FM_SORTUP,
 443             SID_FM_SORTDOWN,
 444             SID_FM_ORDERCRIT,
 445             SID_FM_AUTOFILTER,
 446             SID_FM_FILTERCRIT,
 447             SID_FM_FORM_FILTERED,
 448             SID_FM_REFRESH,
 449             SID_FM_REFRESH_FORM_CONTROL,
 450             SID_FM_SEARCH,
 451             SID_FM_FILTER_START,
 452             SID_FM_VIEW_AS_GRID
 453         };
 454         sal_Int32 nFeatureCount = sizeof( pSupportedFeatures ) / sizeof( pSupportedFeatures[ 0 ] );
 455         aSupportedFeatures.resize( nFeatureCount );
 456         ::std::copy( pSupportedFeatures, pSupportedFeatures + nFeatureCount, aSupportedFeatures.begin() );
 457
 458         m_pInvalidationCallback->invalidateFeatures( aSupportedFeatures );
 459     }
 460
 461
 462     void SAL_CALL FormControllerHelper::errorOccured( const SQLErrorEvent& _Event ) throw (RuntimeException, std::exception)
 463     {
 464         OSL_ENSURE( !m_aOperationError.hasValue(), "FormControllerHelper::errorOccurred: two errors during one operation?" );
 465         m_aOperationError = _Event.Reason;
 466     }
 467
 468
 469     void SAL_CALL FormControllerHelper::disposing( const EventObject& /*_Source*/ ) throw (RuntimeException, std::exception)
 470     {
 471         // not interested in
 472     }
 473
 474
 475     bool FormControllerHelper::isInsertionRow() const
 476     {
 477         bool bIs = false;
 478         if ( m_xFormOperations.is() )
 479             bIs = m_xFormOperations->isInsertionRow();
 480         return bIs;
 481     }
 482
 483
 484     bool FormControllerHelper::isModifiedRow() const
 485     {
 486         bool bIs = false;
 487         if ( m_xFormOperations.is() )
 488             bIs = m_xFormOperations->isModifiedRow();
 489         return bIs;
 490     }
 491
 492     bool FormControllerHelper::canDoFormFilter() const
 493     {
 494         if ( !m_xFormOperations.is() )
 495             return false;
 496
 497         bool bCanDo = false;
 498         try
 499         {
 500             Reference< XPropertySet > xCursorProperties( m_xFormOperations->getCursor(), UNO_QUERY_THROW );
 501
 502             bool bEscapeProcessing( false );
 503             OSL_VERIFY( xCursorProperties->getPropertyValue( FM_PROP_ESCAPE_PROCESSING ) >>= bEscapeProcessing );
 504
 505             OUString sActiveCommand;
 506             OSL_VERIFY( xCursorProperties->getPropertyValue( FM_PROP_ACTIVECOMMAND ) >>= sActiveCommand );
 507
 508             bool bInsertOnlyForm( false );
 509             OSL_VERIFY( xCursorProperties->getPropertyValue( FM_PROP_INSERTONLY ) >>= bInsertOnlyForm );
 510
 511             bCanDo = bEscapeProcessing && !sActiveCommand.isEmpty() && !bInsertOnlyForm;
 512         }
 513         catch( const Exception& )
 514         {
 515             DBG_UNHANDLED_EXCEPTION();
 516         }
 517         return bCanDo;
 518     }
 519
 520
 521 }   // namespace svx
 522
 523
 524 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */