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