sc/source/core/tool/charthelper.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 "charthelper.hxx"
  21 #include "document.hxx"
  22 #include "drwlayer.hxx"
  23 #include "rangelst.hxx"
  24 #include "chartlis.hxx"
  25 #include "docuno.hxx"
  26
  27 #include <svx/svditer.hxx>
  28 #include <svx/svdoole2.hxx>
  29 #include <svx/svdpage.hxx>
  30 #include <svtools/embedhlp.hxx>
  31
  32 #include <com/sun/star/chart2/data/XDataReceiver.hpp>
  33 #include <com/sun/star/util/XModifiable.hpp>
  34
  35 using namespace com::sun::star;
  36 using ::com::sun::star::uno::Reference;
  37
  38 namespace
  39 {
  40
  41 sal_uInt16 lcl_DoUpdateCharts( const ScAddress& rPos, ScDocument* pDoc, bool bAllCharts )
  42 {
  43     ScDrawLayer* pModel = pDoc->GetDrawLayer();
  44     if (!pModel)
  45         return 0;
  46
  47     sal_uInt16 nFound = 0;
  48
  49     sal_uInt16 nPageCount = pModel->GetPageCount();
  50     for (sal_uInt16 nPageNo=0; nPageNo<nPageCount; nPageNo++)
  51     {
  52         SdrPage* pPage = pModel->GetPage(nPageNo);
  53         OSL_ENSURE(pPage,"Page ?");
  54
  55         SdrObjListIter aIter( *pPage, IM_DEEPNOGROUPS );
  56         SdrObject* pObject = aIter.Next();
  57         while (pObject)
  58         {
  59             if ( pObject->GetObjIdentifier() == OBJ_OLE2 && ScDocument::IsChart( pObject ) )
  60             {
  61                 OUString aName = static_cast<SdrOle2Obj*>(pObject)->GetPersistName();
  62                 bool bHit = true;
  63                 if ( !bAllCharts )
  64                 {
  65                     ScRangeList aRanges;
  66                     bool bColHeaders = false;
  67                     bool bRowHeaders = false;
  68                     pDoc->GetOldChartParameters( aName, aRanges, bColHeaders, bRowHeaders );
  69                     bHit = aRanges.In( rPos );
  70                 }
  71                 if ( bHit )
  72                 {
  73                     pDoc->UpdateChart( aName );
  74                     ++nFound;
  75                 }
  76             }
  77             pObject = aIter.Next();
  78         }
  79     }
  80     return nFound;
  81 }
  82
  83 bool lcl_AdjustRanges( ScRangeList& rRanges, SCTAB nSourceTab, SCTAB nDestTab, SCTAB nTabCount )
  84 {
  85     //TODO: if multiple sheets are copied, update references into the other copied sheets?
  86
  87     bool bChanged = false;
  88
  89     for ( size_t i=0, nCount = rRanges.size(); i < nCount; i++ )
  90     {
  91         ScRange* pRange = rRanges[ i ];
  92         if ( pRange->aStart.Tab() == nSourceTab && pRange->aEnd.Tab() == nSourceTab )
  93         {
  94             pRange->aStart.SetTab( nDestTab );
  95             pRange->aEnd.SetTab( nDestTab );
  96             bChanged = true;
  97         }
  98         if ( pRange->aStart.Tab() >= nTabCount )
  99         {
 100             pRange->aStart.SetTab( nTabCount > 0 ? ( nTabCount - 1 ) : 0 );
 101             bChanged = true;
 102         }
 103         if ( pRange->aEnd.Tab() >= nTabCount )
 104         {
 105             pRange->aEnd.SetTab( nTabCount > 0 ? ( nTabCount - 1 ) : 0 );
 106             bChanged = true;
 107         }
 108     }
 109
 110     return bChanged;
 111 }
 112
 113 }//end anonymous namespace
 114
 115 // ScChartHelper
 116 //static
 117 sal_uInt16 ScChartHelper::DoUpdateAllCharts( ScDocument* pDoc )
 118 {
 119     return lcl_DoUpdateCharts( ScAddress(), pDoc, true );
 120 }
 121
 122 void ScChartHelper::AdjustRangesOfChartsOnDestinationPage( ScDocument* pSrcDoc, ScDocument* pDestDoc, const SCTAB nSrcTab, const SCTAB nDestTab )
 123 {
 124     if( !pSrcDoc || !pDestDoc )
 125         return;
 126     ScDrawLayer* pDrawLayer = pDestDoc->GetDrawLayer();
 127     if( !pDrawLayer )
 128         return;
 129
 130     SdrPage* pDestPage = pDrawLayer->GetPage(static_cast<sal_uInt16>(nDestTab));
 131     if( pDestPage )
 132     {
 133         SdrObjListIter aIter( *pDestPage, IM_FLAT );
 134         SdrObject* pObject = aIter.Next();
 135         while( pObject )
 136         {
 137             if( pObject->GetObjIdentifier() == OBJ_OLE2 && static_cast<SdrOle2Obj*>(pObject)->IsChart() )
 138             {
 139                 OUString aChartName = static_cast<SdrOle2Obj*>(pObject)->GetPersistName();
 140
 141                 Reference< chart2::XChartDocument > xChartDoc( pDestDoc->GetChartByName( aChartName ) );
 142                 Reference< chart2::data::XDataReceiver > xReceiver( xChartDoc, uno::UNO_QUERY );
 143                 if( xChartDoc.is() && xReceiver.is() && !xChartDoc->hasInternalDataProvider() )
 144                 {
 145                     ::std::vector< ScRangeList > aRangesVector;
 146                     pDestDoc->GetChartRanges( aChartName, aRangesVector, pSrcDoc );
 147
 148                     ::std::vector< ScRangeList >::iterator aIt( aRangesVector.begin() );
 149                     for( ; aIt!=aRangesVector.end(); ++aIt )
 150                     {
 151                         ScRangeList& rScRangeList( *aIt );
 152                         lcl_AdjustRanges( rScRangeList, nSrcTab, nDestTab, pDestDoc->GetTableCount() );
 153                     }
 154                     pDestDoc->SetChartRanges( aChartName, aRangesVector );
 155                 }
 156             }
 157             pObject = aIter.Next();
 158         }
 159     }
 160 }
 161
 162 void ScChartHelper::UpdateChartsOnDestinationPage( ScDocument* pDestDoc, const SCTAB nDestTab )
 163 {
 164     if( !pDestDoc )
 165         return;
 166     ScDrawLayer* pDrawLayer = pDestDoc->GetDrawLayer();
 167     if( !pDrawLayer )
 168         return;
 169
 170     SdrPage* pDestPage = pDrawLayer->GetPage(static_cast<sal_uInt16>(nDestTab));
 171     if( pDestPage )
 172     {
 173         SdrObjListIter aIter( *pDestPage, IM_FLAT );
 174         SdrObject* pObject = aIter.Next();
 175         while( pObject )
 176         {
 177             if( pObject->GetObjIdentifier() == OBJ_OLE2 && static_cast<SdrOle2Obj*>(pObject)->IsChart() )
 178             {
 179                 OUString aChartName = static_cast<SdrOle2Obj*>(pObject)->GetPersistName();
 180                 Reference< chart2::XChartDocument > xChartDoc( pDestDoc->GetChartByName( aChartName ) );
 181                 Reference< util::XModifiable > xModif(xChartDoc, uno::UNO_QUERY_THROW);
 182                 xModif->setModified( sal_True);
 183             }
 184             pObject = aIter.Next();
 185         }
 186     }
 187 }
 188
 189 uno::Reference< chart2::XChartDocument > ScChartHelper::GetChartFromSdrObject( SdrObject* pObject )
 190 {
 191     uno::Reference< chart2::XChartDocument > xReturn;
 192     if( pObject )
 193     {
 194         if( pObject->GetObjIdentifier() == OBJ_OLE2 && static_cast<SdrOle2Obj*>(pObject)->IsChart() )
 195         {
 196             uno::Reference< embed::XEmbeddedObject > xIPObj = static_cast<SdrOle2Obj*>(pObject)->GetObjRef();
 197             if( xIPObj.is() )
 198             {
 199                 svt::EmbeddedObjectRef::TryRunningState( xIPObj );
 200                 uno::Reference< util::XCloseable > xComponent = xIPObj->getComponent();
 201                 xReturn.set( uno::Reference< chart2::XChartDocument >( xComponent, uno::UNO_QUERY ) );
 202             }
 203         }
 204     }
 205     return xReturn;
 206 }
 207
 208 void ScChartHelper::GetChartRanges( const uno::Reference< chart2::XChartDocument >& xChartDoc,
 209             uno::Sequence< OUString >& rRanges )
 210 {
 211     rRanges.realloc(0);
 212     uno::Reference< chart2::data::XDataSource > xDataSource( xChartDoc, uno::UNO_QUERY );
 213     if( !xDataSource.is() )
 214         return;
 215
 216     uno::Sequence< uno::Reference< chart2::data::XLabeledDataSequence > > aLabeledDataSequences( xDataSource->getDataSequences() );
 217     rRanges.realloc(2*aLabeledDataSequences.getLength());
 218     sal_Int32 nRealCount=0;
 219     for( sal_Int32 nN=0;nN<aLabeledDataSequences.getLength();nN++)
 220     {
 221         uno::Reference< chart2::data::XLabeledDataSequence > xLabeledSequence( aLabeledDataSequences[nN] );
 222         if(!xLabeledSequence.is())
 223             continue;
 224         uno::Reference< chart2::data::XDataSequence > xLabel( xLabeledSequence->getLabel());
 225         uno::Reference< chart2::data::XDataSequence > xValues( xLabeledSequence->getValues());
 226
 227         if( xLabel.is())
 228             rRanges[nRealCount++] = xLabel->getSourceRangeRepresentation();
 229         if( xValues.is())
 230             rRanges[nRealCount++] = xValues->getSourceRangeRepresentation();
 231     }
 232     rRanges.realloc(nRealCount);
 233 }
 234
 235 void ScChartHelper::SetChartRanges( const uno::Reference< chart2::XChartDocument >& xChartDoc,
 236             const uno::Sequence< OUString >& rRanges )
 237 {
 238     uno::Reference< chart2::data::XDataSource > xDataSource( xChartDoc, uno::UNO_QUERY );
 239     if( !xDataSource.is() )
 240         return;
 241     uno::Reference< chart2::data::XDataProvider > xDataProvider = xChartDoc->getDataProvider();
 242     if( !xDataProvider.is() )
 243         return;
 244
 245     uno::Reference< frame::XModel > xModel( xChartDoc, uno::UNO_QUERY );
 246     if( xModel.is() )
 247         xModel->lockControllers();
 248
 249     try
 250     {
 251         OUString aPropertyNameRole( "Role" );
 252
 253         uno::Sequence< uno::Reference< chart2::data::XLabeledDataSequence > > aLabeledDataSequences( xDataSource->getDataSequences() );
 254         sal_Int32 nRange=0;
 255         for( sal_Int32 nN=0; (nN<aLabeledDataSequences.getLength()) && (nRange<rRanges.getLength()); nN++ )
 256         {
 257             uno::Reference< chart2::data::XLabeledDataSequence > xLabeledSequence( aLabeledDataSequences[nN] );
 258             if(!xLabeledSequence.is())
 259                 continue;
 260             uno::Reference< beans::XPropertySet > xLabel( xLabeledSequence->getLabel(), uno::UNO_QUERY );
 261             uno::Reference< beans::XPropertySet > xValues( xLabeledSequence->getValues(), uno::UNO_QUERY );
 262
 263             if( xLabel.is())
 264             {
 265                 uno::Reference< chart2::data::XDataSequence > xNewSeq(
 266                     xDataProvider->createDataSequenceByRangeRepresentation( rRanges[nRange++] ));
 267
 268                 uno::Reference< beans::XPropertySet > xNewProps( xNewSeq, uno::UNO_QUERY );
 269                 if( xNewProps.is() )
 270                     xNewProps->setPropertyValue( aPropertyNameRole, xLabel->getPropertyValue( aPropertyNameRole ) );
 271
 272                 xLabeledSequence->setLabel( xNewSeq );
 273             }
 274
 275             if( !(nRange<rRanges.getLength()) )
 276                 break;
 277
 278             if( xValues.is())
 279             {
 280                 uno::Reference< chart2::data::XDataSequence > xNewSeq(
 281                     xDataProvider->createDataSequenceByRangeRepresentation( rRanges[nRange++] ));
 282
 283                 uno::Reference< beans::XPropertySet > xNewProps( xNewSeq, uno::UNO_QUERY );
 284                 if( xNewProps.is() )
 285                     xNewProps->setPropertyValue( aPropertyNameRole, xValues->getPropertyValue( aPropertyNameRole ) );
 286
 287                 xLabeledSequence->setValues( xNewSeq );
 288             }
 289         }
 290     }
 291     catch (const uno::Exception&)
 292     {
 293         OSL_FAIL("Exception in ScChartHelper::SetChartRanges - invalid range string?");
 294     }
 295
 296     if( xModel.is() )
 297         xModel->unlockControllers();
 298 }
 299
 300 void ScChartHelper::AddRangesIfProtectedChart( ScRangeListVector& rRangesVector, ScDocument* pDocument, SdrObject* pObject )
 301 {
 302     if ( pDocument && pObject && ( pObject->GetObjIdentifier() == OBJ_OLE2 ) )
 303     {
 304         SdrOle2Obj* pSdrOle2Obj = dynamic_cast< SdrOle2Obj* >( pObject );
 305         if ( pSdrOle2Obj && pSdrOle2Obj->IsChart() )
 306         {
 307             uno::Reference< embed::XEmbeddedObject > xEmbeddedObj = pSdrOle2Obj->GetObjRef();
 308             if ( xEmbeddedObj.is() )
 309             {
 310                 bool bDisableDataTableDialog = false;
 311                 sal_Int32 nOldState = xEmbeddedObj->getCurrentState();
 312                 svt::EmbeddedObjectRef::TryRunningState( xEmbeddedObj );
 313                 uno::Reference< beans::XPropertySet > xProps( xEmbeddedObj->getComponent(), uno::UNO_QUERY );
 314                 if ( xProps.is() &&
 315                      ( xProps->getPropertyValue("DisableDataTableDialog") >>= bDisableDataTableDialog ) &&
 316                      bDisableDataTableDialog )
 317                 {
 318                     ScChartListenerCollection* pCollection = pDocument->GetChartListenerCollection();
 319                     if (pCollection)
 320                     {
 321                         OUString aChartName = pSdrOle2Obj->GetPersistName();
 322                         const ScChartListener* pListener = pCollection->findByName(aChartName);
 323                         if (pListener)
 324                         {
 325                             const ScRangeListRef& rRangeList = pListener->GetRangeList();
 326                             if ( rRangeList.Is() )
 327                             {
 328                                 rRangesVector.push_back( *rRangeList );
 329                             }
 330                         }
 331                     }
 332                 }
 333                 if ( xEmbeddedObj->getCurrentState() != nOldState )
 334                 {
 335                     xEmbeddedObj->changeState( nOldState );
 336                 }
 337             }
 338         }
 339     }
 340 }
 341
 342 void ScChartHelper::FillProtectedChartRangesVector( ScRangeListVector& rRangesVector, ScDocument* pDocument, SdrPage* pPage )
 343 {
 344     if ( pDocument && pPage )
 345     {
 346         SdrObjListIter aIter( *pPage, IM_DEEPNOGROUPS );
 347         SdrObject* pObject = aIter.Next();
 348         while ( pObject )
 349         {
 350             AddRangesIfProtectedChart( rRangesVector, pDocument, pObject );
 351             pObject = aIter.Next();
 352         }
 353     }
 354 }
 355
 356 void ScChartHelper::GetChartNames( ::std::vector< OUString >& rChartNames, SdrPage* pPage )
 357 {
 358     if ( pPage )
 359     {
 360         SdrObjListIter aIter( *pPage, IM_DEEPNOGROUPS );
 361         SdrObject* pObject = aIter.Next();
 362         while ( pObject )
 363         {
 364             if ( pObject->GetObjIdentifier() == OBJ_OLE2 )
 365             {
 366                 SdrOle2Obj* pSdrOle2Obj = dynamic_cast< SdrOle2Obj* >( pObject );
 367                 if ( pSdrOle2Obj && pSdrOle2Obj->IsChart() )
 368                 {
 369                     rChartNames.push_back( pSdrOle2Obj->GetPersistName() );
 370                 }
 371             }
 372             pObject = aIter.Next();
 373         }
 374     }
 375 }
 376
 377 void ScChartHelper::CreateProtectedChartListenersAndNotify( ScDocument* pDoc, SdrPage* pPage, ScModelObj* pModelObj, SCTAB nTab,
 378     const ScRangeListVector& rRangesVector, const ::std::vector< OUString >& rExcludedChartNames, bool bSameDoc )
 379 {
 380     if ( pDoc && pPage && pModelObj )
 381     {
 382         size_t nRangeListCount = rRangesVector.size();
 383         size_t nRangeList = 0;
 384         SdrObjListIter aIter( *pPage, IM_DEEPNOGROUPS );
 385         SdrObject* pObject = aIter.Next();
 386         while ( pObject )
 387         {
 388             if ( pObject->GetObjIdentifier() == OBJ_OLE2 )
 389             {
 390                 SdrOle2Obj* pSdrOle2Obj = dynamic_cast< SdrOle2Obj* >( pObject );
 391                 if ( pSdrOle2Obj && pSdrOle2Obj->IsChart() )
 392                 {
 393                     OUString aChartName = pSdrOle2Obj->GetPersistName();
 394                     ::std::vector< OUString >::const_iterator aEnd = rExcludedChartNames.end();
 395                     ::std::vector< OUString >::const_iterator aFound = ::std::find( rExcludedChartNames.begin(), aEnd, aChartName );
 396                     if ( aFound == aEnd )
 397                     {
 398                         uno::Reference< embed::XEmbeddedObject > xEmbeddedObj = pSdrOle2Obj->GetObjRef();
 399                         if ( xEmbeddedObj.is() && ( nRangeList < nRangeListCount ) )
 400                         {
 401                             bool bDisableDataTableDialog = false;
 402                             svt::EmbeddedObjectRef::TryRunningState( xEmbeddedObj );
 403                             uno::Reference< beans::XPropertySet > xProps( xEmbeddedObj->getComponent(), uno::UNO_QUERY );
 404                             if ( xProps.is() &&
 405                                  ( xProps->getPropertyValue("DisableDataTableDialog") >>= bDisableDataTableDialog ) &&
 406                                  bDisableDataTableDialog )
 407                             {
 408                                 if ( bSameDoc )
 409                                 {
 410                                     ScChartListenerCollection* pCollection = pDoc->GetChartListenerCollection();
 411                                     if (pCollection && !pCollection->findByName(aChartName))
 412                                     {
 413                                         ScRangeList aRangeList( rRangesVector[ nRangeList++ ] );
 414                                         ScRangeListRef rRangeList( new ScRangeList( aRangeList ) );
 415                                         ScChartListener* pChartListener = new ScChartListener( aChartName, pDoc, rRangeList );
 416                                         pCollection->insert( pChartListener );
 417                                         pChartListener->StartListeningTo();
 418                                     }
 419                                 }
 420                                 else
 421                                 {
 422                                     xProps->setPropertyValue("DisableDataTableDialog",
 423                                         uno::makeAny( sal_False ) );
 424                                     xProps->setPropertyValue("DisableComplexChartTypes",
 425                                         uno::makeAny( sal_False ) );
 426                                 }
 427                             }
 428                         }
 429
 430                         if ( pModelObj && pModelObj->HasChangesListeners() )
 431                         {
 432                             Rectangle aRectangle = pSdrOle2Obj->GetSnapRect();
 433                             ScRange aRange( pDoc->GetRange( nTab, aRectangle ) );
 434                             ScRangeList aChangeRanges;
 435                             aChangeRanges.Append( aRange );
 436
 437                             uno::Sequence< beans::PropertyValue > aProperties( 1 );
 438                             aProperties[ 0 ].Name = "Name";
 439                             aProperties[ 0 ].Value <<= aChartName;
 440
 441                             pModelObj->NotifyChanges( OUString( "insert-chart" ), aChangeRanges, aProperties );
 442                         }
 443                     }
 444                 }
 445             }
 446             pObject = aIter.Next();
 447         }
 448     }
 449 }
 450
 451 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */