xmloff/source/forms/formcellbinding.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 "formcellbinding.hxx"
  21 #include <com/sun/star/form/binding/XBindableValue.hpp>
  22 #include <com/sun/star/form/binding/XListEntrySink.hpp>
  23 #include <com/sun/star/frame/XModel.hpp>
  24 #include <com/sun/star/container/XChild.hpp>
  25 #include <com/sun/star/lang/XServiceInfo.hpp>
  26 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
  27 #include <com/sun/star/beans/NamedValue.hpp>
  28 #include "strings.hxx"
  29 #include <osl/diagnose.h>
  30 #include <comphelper/diagnose_ex.hxx>
  31
  32 #include <algorithm>
  33
  34 namespace xmloff
  35 {
  36
  37     using namespace ::com::sun::star::uno;
  38     using namespace ::com::sun::star::beans;
  39     using namespace ::com::sun::star::frame;
  40     using namespace ::com::sun::star::sheet;
  41     using namespace ::com::sun::star::container;
  42     using namespace ::com::sun::star::table;
  43     using namespace ::com::sun::star::form;
  44     using namespace ::com::sun::star::lang;
  45     using namespace ::com::sun::star::form::binding;
  46
  47 namespace
  48 {
  49     using ::com::sun::star::uno::Reference;
  50     using ::com::sun::star::uno::XInterface;
  51     using ::com::sun::star::container::XChild;
  52     using ::com::sun::star::frame::XModel;
  53     using ::com::sun::star::uno::UNO_QUERY;
  54
  55     template< class TYPE >
  56     Reference< TYPE > getTypedModelNode( const Reference< XInterface >& _rxModelNode )
  57     {
  58         Reference< TYPE > xTypedNode( _rxModelNode, UNO_QUERY );
  59         if ( xTypedNode.is() )
  60             return xTypedNode;
  61         else
  62         {
  63             Reference< XChild > xChild( _rxModelNode, UNO_QUERY );
  64             if ( xChild.is() )
  65                 return getTypedModelNode< TYPE >( xChild->getParent() );
  66             else
  67                 return nullptr;
  68         }
  69     }
  70
  71     Reference< XModel > getDocument( const Reference< XInterface >& _rxModelNode )
  72     {
  73         return getTypedModelNode< XModel >( _rxModelNode );
  74     }
  75
  76     struct StringCompare
  77     {
  78     private:
  79         const OUString & m_sReference;
  80
  81     public:
  82         explicit StringCompare( const OUString& _rReference ) : m_sReference( _rReference ) { }
  83
  84         bool operator()( std::u16string_view _rCompare )
  85         {
  86             return ( _rCompare == m_sReference );
  87         }
  88     };
  89 }
  90
  91 //= FormCellBindingHelper
  92 FormCellBindingHelper::FormCellBindingHelper( const Reference< XPropertySet >& _rxControlModel, const Reference< XModel >& _rxDocument )
  93     :m_xControlModel( _rxControlModel )
  94     ,m_xDocument( _rxDocument, UNO_QUERY )
  95 {
  96     OSL_ENSURE( m_xControlModel.is(), "FormCellBindingHelper::FormCellBindingHelper: invalid control model!" );
  97
  98     if ( !m_xDocument.is() )
  99         m_xDocument.set(getDocument( m_xControlModel ), css::uno::UNO_QUERY);
 100     OSL_ENSURE( m_xDocument.is(), "FormCellBindingHelper::FormCellBindingHelper: Did not find the spreadsheet document!" );
 101 }
 102
 103 bool FormCellBindingHelper::livesInSpreadsheetDocument( const Reference< XPropertySet >& _rxControlModel )
 104 {
 105     Reference< XSpreadsheetDocument > xDocument( getDocument( _rxControlModel ), UNO_QUERY );
 106     return xDocument.is();
 107 }
 108
 109 bool FormCellBindingHelper::convertStringAddress( const OUString& _rAddressDescription, CellAddress& /* [out] */ _rAddress ) const
 110 {
 111     Any aAddress;
 112     return doConvertAddressRepresentations(
 113                 PROPERTY_FILE_REPRESENTATION,
 114                 Any( _rAddressDescription ),
 115                 PROPERTY_ADDRESS,
 116                 aAddress,
 117                 false
 118            )
 119        &&  ( aAddress >>= _rAddress );
 120 }
 121
 122 bool FormCellBindingHelper::convertStringAddress( const OUString& _rAddressDescription,
 123                         CellRangeAddress& /* [out] */ _rAddress ) const
 124 {
 125     Any aAddress;
 126     return doConvertAddressRepresentations(
 127                 PROPERTY_FILE_REPRESENTATION,
 128                 Any( _rAddressDescription ),
 129                 PROPERTY_ADDRESS,
 130                 aAddress,
 131                 true
 132            )
 133        &&  ( aAddress >>= _rAddress );
 134 }
 135
 136 Reference< XValueBinding > FormCellBindingHelper::createCellBindingFromStringAddress( const OUString& _rAddress, bool _bUseIntegerBinding ) const
 137 {
 138     Reference< XValueBinding > xBinding;
 139     if ( !m_xDocument.is() )
 140         // very bad ...
 141         return xBinding;
 142
 143     // get the UNO representation of the address
 144     CellAddress aAddress;
 145     if ( _rAddress.isEmpty() || !convertStringAddress( _rAddress, aAddress ) )
 146         return xBinding;
 147
 148     xBinding.set(createDocumentDependentInstance(
 149         _bUseIntegerBinding ? SERVICE_LISTINDEXCELLBINDING : SERVICE_CELLVALUEBINDING,
 150         PROPERTY_BOUND_CELL,
 151         Any( aAddress )
 152     ), css::uno::UNO_QUERY);
 153
 154     return xBinding;
 155 }
 156
 157 Reference< XListEntrySource > FormCellBindingHelper::createCellListSourceFromStringAddress( const OUString& _rAddress ) const
 158 {
 159     Reference< XListEntrySource > xSource;
 160
 161     CellRangeAddress aRangeAddress;
 162     if ( !convertStringAddress( _rAddress, aRangeAddress ) )
 163         return xSource;
 164
 165     // create a range object for this address
 166     xSource.set(createDocumentDependentInstance(
 167         SERVICE_CELLRANGELISTSOURCE,
 168         PROPERTY_LIST_CELL_RANGE,
 169         Any( aRangeAddress )
 170     ), css::uno::UNO_QUERY);
 171
 172     return xSource;
 173 }
 174
 175 OUString FormCellBindingHelper::getStringAddressFromCellBinding( const Reference< XValueBinding >& _rxBinding ) const
 176 {
 177     OSL_PRECOND( !_rxBinding.is() || isCellBinding( _rxBinding ), "FormCellBindingHelper::getStringAddressFromCellBinding: this is no cell binding!" );
 178
 179     OUString sAddress;
 180     try
 181     {
 182         Reference< XPropertySet > xBindingProps( _rxBinding, UNO_QUERY );
 183         OSL_ENSURE( xBindingProps.is() || !_rxBinding.is(), "FormCellBindingHelper::getStringAddressFromCellBinding: no property set for the binding!" );
 184         if ( xBindingProps.is() )
 185         {
 186             CellAddress aAddress;
 187             xBindingProps->getPropertyValue( PROPERTY_BOUND_CELL ) >>= aAddress;
 188
 189             Any aStringAddress;
 190             doConvertAddressRepresentations( PROPERTY_ADDRESS, Any( aAddress ),
 191                 PROPERTY_FILE_REPRESENTATION, aStringAddress, false );
 192
 193             aStringAddress >>= sAddress;
 194         }
 195     }
 196     catch( const Exception& )
 197     {
 198         TOOLS_WARN_EXCEPTION( "xmloff", "FormCellBindingHelper::getStringAddressFromCellBinding" );
 199     }
 200
 201     return sAddress;
 202 }
 203
 204 OUString FormCellBindingHelper::getStringAddressFromCellListSource( const Reference< XListEntrySource >& _rxSource ) const
 205 {
 206     OSL_PRECOND( !_rxSource.is() || isCellRangeListSource( _rxSource ), "FormCellBindingHelper::getStringAddressFromCellListSource: this is no cell list source!" );
 207
 208     OUString sAddress;
 209     try
 210     {
 211         Reference< XPropertySet > xSourceProps( _rxSource, UNO_QUERY );
 212         OSL_ENSURE( xSourceProps.is() || !_rxSource.is(), "FormCellBindingHelper::getStringAddressFromCellListSource: no property set for the list source!" );
 213         if ( xSourceProps.is() )
 214         {
 215             CellRangeAddress aRangeAddress;
 216             xSourceProps->getPropertyValue( PROPERTY_LIST_CELL_RANGE ) >>= aRangeAddress;
 217
 218             Any aStringAddress;
 219             doConvertAddressRepresentations( PROPERTY_ADDRESS, Any( aRangeAddress ),
 220                 PROPERTY_FILE_REPRESENTATION, aStringAddress, true );
 221             aStringAddress >>= sAddress;
 222         }
 223     }
 224     catch( const Exception& )
 225     {
 226         TOOLS_WARN_EXCEPTION( "xmloff", "FormCellBindingHelper::getStringAddressFromCellListSource" );
 227     }
 228
 229     return sAddress;
 230 }
 231
 232 bool FormCellBindingHelper::isSpreadsheetDocumentWhichSupplies( const Reference< XSpreadsheetDocument >& _rxDocument, const OUString& _rService )
 233 {
 234     bool bYesItIs = false;
 235
 236     try
 237     {
 238         Reference< XServiceInfo > xSI( _rxDocument, UNO_QUERY );
 239         if ( xSI.is() && xSI->supportsService( SERVICE_SPREADSHEET_DOCUMENT ) )
 240         {
 241             Reference< XMultiServiceFactory > xDocumentFactory( _rxDocument, UNO_QUERY );
 242             OSL_ENSURE( xDocumentFactory.is(), "FormCellBindingHelper::isSpreadsheetDocumentWhichSupplies: spreadsheet document, but no factory?" );
 243
 244             if ( xDocumentFactory.is() )
 245             {
 246                 const Sequence<OUString> aAvailableServices = xDocumentFactory->getAvailableServiceNames( );
 247
 248                 bYesItIs = std::any_of( aAvailableServices.begin(), aAvailableServices.end(), StringCompare( _rService ) );
 249             }
 250         }
 251     }
 252     catch( const Exception& )
 253     {
 254         TOOLS_WARN_EXCEPTION( "xmloff", "FormCellBindingHelper::isSpreadsheetDocumentWhichSupplies" );
 255     }
 256
 257     return bYesItIs;
 258 }
 259
 260 bool FormCellBindingHelper::isSpreadsheetDocumentWhichSupplies( const OUString& _rService ) const
 261 {
 262     return isSpreadsheetDocumentWhichSupplies( m_xDocument, _rService );
 263 }
 264
 265 bool FormCellBindingHelper::isListCellRangeAllowed( const Reference< XModel >& _rxDocument )
 266 {
 267     return isSpreadsheetDocumentWhichSupplies(
 268         Reference< XSpreadsheetDocument >( _rxDocument, UNO_QUERY ),
 269         SERVICE_CELLRANGELISTSOURCE
 270     );
 271 }
 272
 273 bool FormCellBindingHelper::isListCellRangeAllowed( ) const
 274 {
 275     bool bAllow( false );
 276
 277     Reference< XListEntrySink > xSink( m_xControlModel, UNO_QUERY );
 278     if ( xSink.is() )
 279     {
 280         bAllow = isSpreadsheetDocumentWhichSupplies( SERVICE_CELLRANGELISTSOURCE );
 281     }
 282
 283     return bAllow;
 284 }
 285
 286 bool FormCellBindingHelper::isCellBindingAllowed( ) const
 287 {
 288     bool bAllow( false );
 289
 290     Reference< XBindableValue > xBindable( m_xControlModel, UNO_QUERY );
 291     if ( xBindable.is() )
 292     {
 293         // the control can potentially be bound to an external value
 294         // Does it live within a Calc document, and is able to supply CellBindings?
 295         bAllow = isSpreadsheetDocumentWhichSupplies( SERVICE_CELLVALUEBINDING );
 296     }
 297
 298     return bAllow;
 299 }
 300
 301 bool FormCellBindingHelper::isCellBindingAllowed( const Reference< XModel >& _rxDocument )
 302 {
 303     return isSpreadsheetDocumentWhichSupplies(
 304         Reference< XSpreadsheetDocument >( _rxDocument, UNO_QUERY ),
 305         SERVICE_CELLVALUEBINDING
 306     );
 307 }
 308
 309 bool FormCellBindingHelper::isCellBinding( const Reference< XValueBinding >& _rxBinding )
 310 {
 311     return doesComponentSupport( _rxBinding, SERVICE_CELLVALUEBINDING );
 312 }
 313
 314 bool FormCellBindingHelper::isCellIntegerBinding( const Reference< XValueBinding >& _rxBinding )
 315 {
 316     return doesComponentSupport( _rxBinding, SERVICE_LISTINDEXCELLBINDING );
 317 }
 318
 319 bool FormCellBindingHelper::isCellRangeListSource( const Reference< XListEntrySource >& _rxSource )
 320 {
 321     return doesComponentSupport( _rxSource, SERVICE_CELLRANGELISTSOURCE );
 322 }
 323
 324 bool FormCellBindingHelper::doesComponentSupport( const Reference< XInterface >& _rxComponent, const OUString& _rService )
 325 {
 326     Reference< XServiceInfo > xSI( _rxComponent, UNO_QUERY );
 327     bool bDoes = xSI.is() && xSI->supportsService( _rService );
 328     return bDoes;
 329 }
 330
 331 Reference< XValueBinding > FormCellBindingHelper::getCurrentBinding( ) const
 332 {
 333     Reference< XBindableValue > xBindable( m_xControlModel, UNO_QUERY );
 334     if ( xBindable.is() )
 335         return xBindable->getValueBinding();
 336     return Reference<XValueBinding>();
 337 }
 338
 339 Reference< XListEntrySource > FormCellBindingHelper::getCurrentListSource( ) const
 340 {
 341     Reference< XListEntrySink > xSink( m_xControlModel, UNO_QUERY );
 342     if (xSink.is())
 343         return xSink->getListEntrySource();
 344     return Reference<XListEntrySource>();
 345 }
 346
 347 void FormCellBindingHelper::setBinding( const Reference< XValueBinding >& _rxBinding )
 348 {
 349     Reference< XBindableValue > xBindable( m_xControlModel, UNO_QUERY );
 350     OSL_PRECOND( xBindable.is(), "FormCellBindingHelper::setBinding: the object is not bindable!" );
 351     if ( xBindable.is() )
 352         xBindable->setValueBinding( _rxBinding );
 353 }
 354
 355 void FormCellBindingHelper::setListSource( const Reference< XListEntrySource >& _rxSource )
 356 {
 357     Reference< XListEntrySink > xSink( m_xControlModel, UNO_QUERY );
 358     OSL_PRECOND( xSink.is(), "FormCellBindingHelper::setListSource: the object is no list entry sink!" );
 359     if ( xSink.is() )
 360         xSink->setListEntrySource( _rxSource );
 361 }
 362
 363 Reference< XInterface > FormCellBindingHelper::createDocumentDependentInstance( const OUString& _rService, const OUString& _rArgumentName,
 364     const Any& _rArgumentValue ) const
 365 {
 366     Reference< XInterface > xReturn;
 367
 368     Reference< XMultiServiceFactory > xDocumentFactory( m_xDocument, UNO_QUERY );
 369     OSL_ENSURE( xDocumentFactory.is(), "FormCellBindingHelper::createDocumentDependentInstance: no document service factory!" );
 370     if ( xDocumentFactory.is() )
 371     {
 372         try
 373         {
 374             if ( !_rArgumentName.isEmpty() )
 375             {
 376                 NamedValue aArg;
 377                 aArg.Name = _rArgumentName;
 378                 aArg.Value = _rArgumentValue;
 379
 380                 Sequence< Any > aArgs{ Any(aArg) };
 381                 xReturn = xDocumentFactory->createInstanceWithArguments( _rService, aArgs );
 382             }
 383             else
 384             {
 385                 xReturn = xDocumentFactory->createInstance( _rService );
 386             }
 387         }
 388         catch ( const Exception& )
 389         {
 390             OSL_FAIL( "FormCellBindingHelper::createDocumentDependentInstance: could not create the binding at the document!" );
 391         }
 392     }
 393     return xReturn;
 394 }
 395
 396 bool FormCellBindingHelper::doConvertAddressRepresentations( const OUString& _rInputProperty, const Any& _rInputValue,
 397     const OUString& _rOutputProperty, Any& _rOutputValue, bool _bIsRange ) const
 398 {
 399     bool bSuccess = false;
 400
 401     Reference< XPropertySet > xConverter(
 402         createDocumentDependentInstance(
 403             _bIsRange ? SERVICE_RANGEADDRESS_CONVERSION : SERVICE_ADDRESS_CONVERSION,
 404             OUString(),
 405             Any()
 406         ),
 407         UNO_QUERY
 408     );
 409     OSL_ENSURE( xConverter.is(), "FormCellBindingHelper::doConvertAddressRepresentations: could not get a converter service!" );
 410     if ( xConverter.is() )
 411     {
 412         try
 413         {
 414             xConverter->setPropertyValue( _rInputProperty, _rInputValue );
 415             _rOutputValue = xConverter->getPropertyValue( _rOutputProperty );
 416             bSuccess = true;
 417         }
 418         catch( const Exception& )
 419         {
 420             TOOLS_WARN_EXCEPTION( "xmloff", "FormCellBindingHelper::doConvertAddressRepresentations" );
 421         }
 422     }
 423
 424     return bSuccess;
 425 }
 426
 427 }   // namespace xmloff
 428
 429 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */