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