extensions/source/propctrlr/cellbindinghelper.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 "cellbindinghelper.hxx"
  21 #include <com/sun/star/form/binding/XBindableValue.hpp>
  22 #include <com/sun/star/form/binding/XListEntrySink.hpp>
  23 #include <com/sun/star/form/FormComponentType.hpp>
  24 #include <com/sun/star/form/XGridColumnFactory.hpp>
  25 #include <com/sun/star/container/XChild.hpp>
  26 #include <com/sun/star/drawing/XDrawPageSupplier.hpp>
  27 #include <com/sun/star/form/XFormsSupplier.hpp>
  28 #include <com/sun/star/form/XForm.hpp>
  29 #include <com/sun/star/lang/XServiceInfo.hpp>
  30 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
  31 #include <com/sun/star/beans/NamedValue.hpp>
  32 #include <com/sun/star/sheet/XSpreadsheet.hpp>
  33 #include <unotools/transliterationwrapper.hxx>
  34 #include <osl/diagnose.h>
  35 #include <comphelper/diagnose_ex.hxx>
  36 #include "formstrings.hxx"
  37
  38 #include <algorithm>
  39 #include <utility>
  40
  41
  42 namespace pcr
  43 {
  44
  45
  46     using namespace ::com::sun::star::uno;
  47     using namespace ::com::sun::star::beans;
  48     using namespace ::com::sun::star::frame;
  49     using namespace ::com::sun::star::sheet;
  50     using namespace ::com::sun::star::container;
  51     using namespace ::com::sun::star::drawing;
  52     using namespace ::com::sun::star::table;
  53     using namespace ::com::sun::star::form;
  54     using namespace ::com::sun::star::lang;
  55     using namespace ::com::sun::star::form::binding;
  56
  57     namespace
  58     {
  59
  60         struct StringCompare
  61         {
  62         private:
  63             OUString m_sReference;
  64
  65         public:
  66             explicit StringCompare( OUString _aReference ) : m_sReference(std::move( _aReference )) { }
  67
  68             bool operator()( std::u16string_view _rCompare )
  69             {
  70                 return ( _rCompare == m_sReference );
  71             }
  72         };
  73     }
  74
  75
  76     CellBindingHelper::CellBindingHelper( const Reference< XPropertySet >& _rxControlModel, const Reference< XModel >& _rxContextDocument )
  77         :m_xControlModel( _rxControlModel )
  78     {
  79         OSL_ENSURE( m_xControlModel.is(), "CellBindingHelper::CellBindingHelper: invalid control model!" );
  80
  81         m_xDocument.set(_rxContextDocument, css::uno::UNO_QUERY);
  82         OSL_ENSURE( m_xDocument.is(), "CellBindingHelper::CellBindingHelper: This is no spreadsheet document!" );
  83
  84         OSL_ENSURE( isSpreadsheetDocumentWhichSupplies( SERVICE_ADDRESS_CONVERSION ),
  85             "CellBindingHelper::CellBindingHelper: the document cannot convert address representations!" );
  86     }
  87
  88
  89     bool CellBindingHelper::isSpreadsheetDocument( const Reference< XModel >& _rxContextDocument )
  90     {
  91         return Reference< XSpreadsheetDocument >::query( _rxContextDocument ).is();
  92     }
  93
  94
  95     sal_Int16 CellBindingHelper::getControlSheetIndex( Reference< XSpreadsheet >& _out_rxSheet ) const
  96     {
  97         sal_Int16 nSheetIndex = -1;
  98         // every sheet has a draw page, and every draw page has a forms collection.
  99         // Our control, OTOH, belongs to a forms collection. Match these...
 100         try
 101         {
 102             // for determining the draw page, we need the forms collection which
 103             // the object belongs to. This is the first object up the hierarchy which is
 104             // *no* XForm (and, well, no XGridColumnFactory)
 105             Reference< XChild > xCheck( m_xControlModel, UNO_QUERY );
 106             Reference< XForm > xParentAsForm; if ( xCheck.is() ) xParentAsForm.set(xCheck->getParent(), css::uno::UNO_QUERY);
 107             Reference< XGridColumnFactory > xParentAsGrid; if ( xCheck.is() ) xParentAsGrid.set(xCheck->getParent(), css::uno::UNO_QUERY);
 108
 109             while ( ( xParentAsForm.is() || xParentAsGrid.is() ) && xCheck.is() )
 110             {
 111                 xCheck.set(xCheck->getParent(), css::uno::UNO_QUERY);
 112                 xParentAsForm.set(xCheck.is() ? xCheck->getParent() : Reference< XForm >(), css::uno::UNO_QUERY);
 113                 xParentAsGrid.set(xCheck.is() ? xCheck->getParent() : Reference< XGridColumnFactory >(), css::uno::UNO_QUERY);
 114             }
 115             Reference< XInterface > xFormsCollection( xCheck.is() ? xCheck->getParent() : Reference< XInterface >() );
 116
 117             // now iterate through the sheets
 118             Reference< XIndexAccess > xSheets( m_xDocument->getSheets(), UNO_QUERY );
 119             if ( xSheets.is() && xFormsCollection.is() )
 120             {
 121                 for ( sal_Int32 i = 0; i < xSheets->getCount(); ++i )
 122                 {
 123                     Reference< XDrawPageSupplier > xSuppPage( xSheets->getByIndex( i ), UNO_QUERY_THROW );
 124                     Reference< XFormsSupplier > xSuppForms( xSuppPage->getDrawPage(), UNO_QUERY_THROW );
 125
 126                     if ( xSuppForms->getForms() == xFormsCollection )
 127                     {   // found it
 128                         nSheetIndex = static_cast<sal_Int16>(i);
 129                         _out_rxSheet.set( xSuppPage, UNO_QUERY_THROW );
 130                         break;
 131                     }
 132                 }
 133             }
 134         }
 135         catch( const Exception& )
 136         {
 137             DBG_UNHANDLED_EXCEPTION("extensions.propctrlr");
 138         }
 139
 140         return nSheetIndex;
 141     }
 142
 143
 144     bool CellBindingHelper::convertStringAddress( const OUString& _rAddressDescription, CellAddress& /* [out] */ _rAddress ) const
 145     {
 146         Any aAddress;
 147         return doConvertAddressRepresentations(
 148                     PROPERTY_UI_REPRESENTATION,
 149                     Any( _rAddressDescription ),
 150                     PROPERTY_ADDRESS,
 151                     aAddress,
 152                     false
 153                )
 154            &&  ( aAddress >>= _rAddress );
 155     }
 156
 157
 158     bool CellBindingHelper::doConvertAddressRepresentations( const OUString& _rInputProperty, const Any& _rInputValue,
 159         const OUString& _rOutputProperty, Any& _rOutputValue, bool _bIsRange ) const
 160     {
 161         bool bSuccess = false;
 162
 163         Reference< XPropertySet > xConverter(
 164             createDocumentDependentInstance(
 165                 _bIsRange ? SERVICE_RANGEADDRESS_CONVERSION : SERVICE_ADDRESS_CONVERSION,
 166                 OUString(),
 167                 Any()
 168             ),
 169             UNO_QUERY
 170         );
 171         OSL_ENSURE( xConverter.is(), "CellBindingHelper::doConvertAddressRepresentations: could not get a converter service!" );
 172         if ( xConverter.is() )
 173         {
 174             try
 175             {
 176                 Reference< XSpreadsheet > xSheet;
 177                 xConverter->setPropertyValue( PROPERTY_REFERENCE_SHEET, Any( static_cast<sal_Int32>(getControlSheetIndex( xSheet )) ) );
 178                 xConverter->setPropertyValue( _rInputProperty, _rInputValue );
 179                 _rOutputValue = xConverter->getPropertyValue( _rOutputProperty );
 180                 bSuccess = true;
 181             }
 182             catch( const Exception& )
 183             {
 184                 TOOLS_WARN_EXCEPTION( "extensions.propctrlr", "CellBindingHelper::doConvertAddressRepresentations" );
 185             }
 186         }
 187
 188         return bSuccess;
 189     }
 190
 191
 192     bool CellBindingHelper::convertStringAddress( const OUString& _rAddressDescription,
 193                             CellRangeAddress& /* [out] */ _rAddress ) const
 194     {
 195         Any aAddress;
 196         return doConvertAddressRepresentations(
 197                     PROPERTY_UI_REPRESENTATION,
 198                     Any( _rAddressDescription ),
 199                     PROPERTY_ADDRESS,
 200                     aAddress,
 201                     true
 202                )
 203            &&  ( aAddress >>= _rAddress );
 204     }
 205
 206
 207     Reference< XValueBinding > CellBindingHelper::createCellBindingFromAddress( const CellAddress& _rAddress, bool _bSupportIntegerExchange ) const
 208     {
 209         Reference< XValueBinding > xBinding( createDocumentDependentInstance(
 210             _bSupportIntegerExchange ? SERVICE_SHEET_CELL_INT_BINDING : SERVICE_SHEET_CELL_BINDING,
 211             PROPERTY_BOUND_CELL,
 212             Any( _rAddress )
 213         ), UNO_QUERY );
 214
 215         return xBinding;
 216     }
 217
 218
 219     Reference< XValueBinding > CellBindingHelper::createCellBindingFromStringAddress( const OUString& _rAddress, bool _bSupportIntegerExchange ) const
 220     {
 221         Reference< XValueBinding > xBinding;
 222         if ( !m_xDocument.is() )
 223             // very bad ...
 224             return xBinding;
 225
 226         // get the UNO representation of the address
 227         CellAddress aAddress;
 228         if ( _rAddress.isEmpty() || !convertStringAddress( _rAddress, aAddress ) )
 229             return xBinding;
 230
 231         return createCellBindingFromAddress( aAddress, _bSupportIntegerExchange );
 232     }
 233
 234
 235     Reference< XListEntrySource > CellBindingHelper::createCellListSourceFromStringAddress( const OUString& _rAddress ) const
 236     {
 237         Reference< XListEntrySource > xSource;
 238
 239         CellRangeAddress aRangeAddress;
 240         if ( _rAddress.isEmpty() || !convertStringAddress( _rAddress, aRangeAddress ) )
 241             return xSource;
 242
 243         // create a range object for this address
 244         xSource.set(createDocumentDependentInstance(
 245             SERVICE_SHEET_CELLRANGE_LISTSOURCE,
 246             PROPERTY_LIST_CELL_RANGE,
 247             Any( aRangeAddress )
 248         ), css::uno::UNO_QUERY);
 249
 250         return xSource;
 251     }
 252
 253
 254     Reference< XInterface > CellBindingHelper::createDocumentDependentInstance( const OUString& _rService, const OUString& _rArgumentName,
 255         const Any& _rArgumentValue ) const
 256     {
 257         Reference< XInterface > xReturn;
 258
 259         Reference< XMultiServiceFactory > xDocumentFactory( m_xDocument, UNO_QUERY );
 260         OSL_ENSURE( xDocumentFactory.is(), "CellBindingHelper::createDocumentDependentInstance: no document service factory!" );
 261         if ( xDocumentFactory.is() )
 262         {
 263             try
 264             {
 265                 if ( !_rArgumentName.isEmpty() )
 266                 {
 267                     Sequence aArgs{ Any(NamedValue(_rArgumentName, _rArgumentValue)) };
 268                     xReturn = xDocumentFactory->createInstanceWithArguments( _rService, aArgs );
 269                 }
 270                 else
 271                 {
 272                     xReturn = xDocumentFactory->createInstance( _rService );
 273                 }
 274             }
 275             catch ( const Exception& )
 276             {
 277                 OSL_FAIL( "CellBindingHelper::createDocumentDependentInstance: could not create the binding at the document!" );
 278             }
 279         }
 280         return xReturn;
 281     }
 282
 283
 284     bool CellBindingHelper::getAddressFromCellBinding(
 285         const Reference< XValueBinding >& _rxBinding, CellAddress& _rAddress ) const
 286     {
 287         OSL_PRECOND( !_rxBinding.is() || isCellBinding( _rxBinding ), "CellBindingHelper::getAddressFromCellBinding: this is no cell binding!" );
 288
 289         bool bReturn = false;
 290         if ( !m_xDocument.is() )
 291             // very bad ...
 292             return bReturn;
 293
 294         try
 295         {
 296             Reference< XPropertySet > xBindingProps( _rxBinding, UNO_QUERY );
 297             OSL_ENSURE( xBindingProps.is() || !_rxBinding.is(), "CellBindingHelper::getAddressFromCellBinding: no property set for the binding!" );
 298             if ( xBindingProps.is() )
 299             {
 300                 bReturn = ( xBindingProps->getPropertyValue( PROPERTY_BOUND_CELL ) >>= _rAddress );
 301             }
 302         }
 303         catch( const Exception& )
 304         {
 305             TOOLS_WARN_EXCEPTION( "extensions.propctrlr", "CellBindingHelper::getAddressFromCellBinding" );
 306         }
 307
 308         return bReturn;
 309     }
 310
 311
 312     OUString CellBindingHelper::getStringAddressFromCellBinding( const Reference< XValueBinding >& _rxBinding ) const
 313     {
 314         CellAddress aAddress;
 315         OUString sAddress;
 316         if ( getAddressFromCellBinding( _rxBinding, aAddress ) )
 317         {
 318             Any aStringAddress;
 319             doConvertAddressRepresentations( PROPERTY_ADDRESS, Any( aAddress ),
 320                 PROPERTY_UI_REPRESENTATION, aStringAddress, false );
 321
 322             aStringAddress >>= sAddress;
 323         }
 324
 325         return sAddress;
 326     }
 327
 328
 329     OUString CellBindingHelper::getStringAddressFromCellListSource( const Reference< XListEntrySource >& _rxSource ) const
 330     {
 331         OSL_PRECOND( !_rxSource.is() || isCellRangeListSource( _rxSource ), "CellBindingHelper::getStringAddressFromCellListSource: this is no cell list source!" );
 332
 333         OUString sAddress;
 334         if ( !m_xDocument.is() )
 335             // very bad ...
 336             return sAddress;
 337
 338         try
 339         {
 340             Reference< XPropertySet > xSourceProps( _rxSource, UNO_QUERY );
 341             OSL_ENSURE( xSourceProps.is() || !_rxSource.is(), "CellBindingHelper::getStringAddressFromCellListSource: no property set for the list source!" );
 342             if ( xSourceProps.is() )
 343             {
 344                 CellRangeAddress aRangeAddress;
 345                 xSourceProps->getPropertyValue( PROPERTY_LIST_CELL_RANGE ) >>= aRangeAddress;
 346
 347                 Any aStringAddress;
 348                 doConvertAddressRepresentations( PROPERTY_ADDRESS, Any( aRangeAddress ),
 349                     PROPERTY_UI_REPRESENTATION, aStringAddress, true );
 350                 aStringAddress >>= sAddress;
 351             }
 352         }
 353         catch( const Exception& )
 354         {
 355             TOOLS_WARN_EXCEPTION( "extensions.propctrlr", "CellBindingHelper::getStringAddressFromCellListSource" );
 356         }
 357
 358         return sAddress;
 359     }
 360
 361
 362     bool CellBindingHelper::isSpreadsheetDocumentWhichSupplies( const OUString& _rService ) const
 363     {
 364         bool bYesItIs = false;
 365
 366         Reference< XServiceInfo > xSI( m_xDocument, UNO_QUERY );
 367         if ( xSI.is() && xSI->supportsService( SERVICE_SPREADSHEET_DOCUMENT ) )
 368         {
 369             Reference< XMultiServiceFactory > xDocumentFactory( m_xDocument, UNO_QUERY );
 370             OSL_ENSURE( xDocumentFactory.is(), "CellBindingHelper::isSpreadsheetDocumentWhichSupplies: spreadsheet document, but no factory?" );
 371
 372             if ( xDocumentFactory.is() )
 373             {
 374                 const Sequence<OUString> aAvailableServices = xDocumentFactory->getAvailableServiceNames( );
 375
 376                 bYesItIs = std::any_of(
 377                     aAvailableServices.begin(),
 378                     aAvailableServices.end(),
 379                     StringCompare( _rService )
 380                 );
 381             }
 382         }
 383
 384         return bYesItIs;
 385     }
 386
 387
 388     bool CellBindingHelper::isListCellRangeAllowed( ) const
 389     {
 390         bool bAllow( false );
 391
 392         Reference< XListEntrySink > xSink( m_xControlModel, UNO_QUERY );
 393         if ( xSink.is() )
 394         {
 395             bAllow = isSpreadsheetDocumentWhichSupplies( SERVICE_SHEET_CELLRANGE_LISTSOURCE );
 396         }
 397
 398         return bAllow;
 399     }
 400
 401
 402     bool CellBindingHelper::isCellIntegerBindingAllowed( ) const
 403     {
 404         bool bAllow( true );
 405
 406         // first, we only offer this for controls which allow bindings in general
 407         Reference< XBindableValue > xBindable( m_xControlModel, UNO_QUERY );
 408         if ( !xBindable.is() )
 409             bAllow = false;
 410
 411         // then, we must live in a spreadsheet document which can provide the special
 412         // service needed for exchanging integer values
 413         if ( bAllow )
 414             bAllow = isSpreadsheetDocumentWhichSupplies( SERVICE_SHEET_CELL_INT_BINDING );
 415
 416         // then, we only offer this for list boxes
 417         if ( bAllow )
 418         {
 419             try
 420             {
 421                 sal_Int16 nClassId = FormComponentType::CONTROL;
 422                 m_xControlModel->getPropertyValue( PROPERTY_CLASSID ) >>= nClassId;
 423                 if ( FormComponentType::LISTBOX != nClassId )
 424                     bAllow = false;
 425             }
 426             catch( const Exception& )
 427             {
 428                 TOOLS_WARN_EXCEPTION( "extensions.propctrlr", "CellBindingHelper::isCellIntegerBindingAllowed" );
 429                     // are there really control models which survive isCellBindingAllowed, but don't have a ClassId
 430                     // property?
 431                 bAllow = false;
 432             }
 433         }
 434
 435         return bAllow;
 436     }
 437
 438
 439     bool CellBindingHelper::isCellBindingAllowed( ) const
 440     {
 441         bool bAllow( false );
 442
 443         Reference< XBindableValue > xBindable( m_xControlModel, UNO_QUERY );
 444         if ( xBindable.is() )
 445         {
 446             // the control can potentially be bound to an external value
 447             // Does it live within a Calc document, and is able to supply CellBindings?
 448             bAllow = isSpreadsheetDocumentWhichSupplies( SERVICE_SHEET_CELL_BINDING );
 449         }
 450
 451         // disallow for some types
 452         // TODO: shouldn't the XBindableValue supply a list of supported types, and we can distinguish
 453         // using this list? The current behavior below is somewhat hackish...
 454         if ( bAllow )
 455         {
 456             try
 457             {
 458                 sal_Int16 nClassId = FormComponentType::CONTROL;
 459                 m_xControlModel->getPropertyValue( PROPERTY_CLASSID ) >>= nClassId;
 460                 if ( ( FormComponentType::DATEFIELD == nClassId ) || ( FormComponentType::TIMEFIELD == nClassId ) )
 461                     bAllow = false;
 462             }
 463             catch( const Exception& )
 464             {
 465                 TOOLS_WARN_EXCEPTION( "extensions.propctrlr", "CellBindingHelper::isCellBindingAllowed" );
 466                 bAllow = false;
 467             }
 468         }
 469         return bAllow;
 470     }
 471
 472
 473     bool CellBindingHelper::isCellBinding( const Reference< XValueBinding >& _rxBinding )
 474     {
 475         return doesComponentSupport( _rxBinding, SERVICE_SHEET_CELL_BINDING );
 476     }
 477
 478
 479     bool CellBindingHelper::isCellIntegerBinding( const Reference< XValueBinding >& _rxBinding )
 480     {
 481         return doesComponentSupport( _rxBinding, SERVICE_SHEET_CELL_INT_BINDING );
 482     }
 483
 484
 485     bool CellBindingHelper::isCellRangeListSource( const Reference< XListEntrySource >& _rxSource )
 486     {
 487         return doesComponentSupport( _rxSource, SERVICE_SHEET_CELLRANGE_LISTSOURCE );
 488     }
 489
 490
 491     bool CellBindingHelper::doesComponentSupport( const Reference< XInterface >& _rxComponent, const OUString& _rService )
 492     {
 493         Reference< XServiceInfo > xSI( _rxComponent, UNO_QUERY );
 494         bool bDoes = xSI.is() && xSI->supportsService( _rService );
 495         return bDoes;
 496     }
 497
 498     Reference< XValueBinding > CellBindingHelper::getCurrentBinding( ) const
 499     {
 500         Reference< XValueBinding > xBinding;
 501         Reference< XBindableValue > xBindable( m_xControlModel, UNO_QUERY );
 502         if ( xBindable.is() )
 503             xBinding = xBindable->getValueBinding();
 504         return xBinding;
 505     }
 506
 507     Reference< XListEntrySource > CellBindingHelper::getCurrentListSource( ) const
 508     {
 509         Reference< XListEntrySink > xSink( m_xControlModel, UNO_QUERY );
 510         if (xSink.is())
 511             return xSink->getListEntrySource();
 512         return Reference<XListEntrySource>();
 513     }
 514
 515     void CellBindingHelper::setBinding( const Reference< XValueBinding >& _rxBinding )
 516     {
 517         Reference< XBindableValue > xBindable( m_xControlModel, UNO_QUERY );
 518         OSL_PRECOND( xBindable.is(), "CellBindingHelper::setBinding: the object is not bindable!" );
 519         if ( xBindable.is() )
 520             xBindable->setValueBinding( _rxBinding );
 521     }
 522
 523     void CellBindingHelper::setListSource( const Reference< XListEntrySource >& _rxSource )
 524     {
 525         Reference< XListEntrySink > xSink( m_xControlModel, UNO_QUERY );
 526         OSL_PRECOND( xSink.is(), "CellBindingHelper::setListSource: the object is no list entry sink!" );
 527         if ( xSink.is() )
 528             xSink->setListEntrySource( _rxSource );
 529     }
 530
 531 }   // namespace pcr
 532
 533
 534 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */