sc/source/core/tool/chartlis.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 <vcl/svapp.hxx>
  21
  22 #include "chartlis.hxx"
  23 #include "brdcst.hxx"
  24 #include "document.hxx"
  25 #include "reftokenhelper.hxx"
  26 #include "stlalgorithm.hxx"
  27
  28 using namespace com::sun::star;
  29 using ::std::vector;
  30 using ::std::list;
  31 using ::std::auto_ptr;
  32 using ::std::unary_function;
  33 using ::std::for_each;
  34
  35 // Update chart listeners quickly, to get a similar behavior to loaded charts
  36 // which register UNO listeners.
  37 #define SC_CHARTTIMEOUT 10
  38
  39 class ScChartUnoData
  40 {
  41     uno::Reference< chart::XChartDataChangeEventListener >  xListener;
  42     uno::Reference< chart::XChartData >                     xSource;
  43
  44 public:
  45             ScChartUnoData( const uno::Reference< chart::XChartDataChangeEventListener >& rL,
  46                             const uno::Reference< chart::XChartData >& rS ) :
  47                     xListener( rL ), xSource( rS ) {}
  48             ~ScChartUnoData() {}
  49
  50     const uno::Reference< chart::XChartDataChangeEventListener >& GetListener() const   { return xListener; }
  51     const uno::Reference< chart::XChartData >& GetSource() const                        { return xSource; }
  52 };
  53
  54 // ScChartListener
  55 ScChartListener::ExternalRefListener::ExternalRefListener(ScChartListener& rParent, ScDocument* pDoc) :
  56     mrParent(rParent), mpDoc(pDoc)
  57 {
  58 }
  59
  60 ScChartListener::ExternalRefListener::~ExternalRefListener()
  61 {
  62     if (!mpDoc || mpDoc->IsInDtorClear())
  63         // The document is being destroyed.  Do nothing.
  64         return;
  65
  66     // Make sure to remove all pointers to this object.
  67     mpDoc->GetExternalRefManager()->removeLinkListener(this);
  68 }
  69
  70 void ScChartListener::ExternalRefListener::notify(sal_uInt16 nFileId, ScExternalRefManager::LinkUpdateType eType)
  71 {
  72     switch (eType)
  73     {
  74         case ScExternalRefManager::LINK_MODIFIED:
  75         {
  76             if (maFileIds.count(nFileId))
  77                 // We are listening to this external document.  Send an update
  78                 // requst to the chart.
  79                 mrParent.SetUpdateQueue();
  80         }
  81         break;
  82         case ScExternalRefManager::LINK_BROKEN:
  83             removeFileId(nFileId);
  84         break;
  85     }
  86 }
  87
  88 void ScChartListener::ExternalRefListener::addFileId(sal_uInt16 nFileId)
  89 {
  90     maFileIds.insert(nFileId);
  91 }
  92
  93 void ScChartListener::ExternalRefListener::removeFileId(sal_uInt16 nFileId)
  94 {
  95     maFileIds.erase(nFileId);
  96 }
  97
  98 boost::unordered_set<sal_uInt16>& ScChartListener::ExternalRefListener::getAllFileIds()
  99 {
 100     return maFileIds;
 101 }
 102
 103 ScChartListener::ScChartListener( const OUString& rName, ScDocument* pDocP,
 104         const ScRangeListRef& rRangeList ) :
 105     SvtListener(),
 106     mpExtRefListener(NULL),
 107     mpTokens(new vector<ScTokenRef>),
 108     maName(rName),
 109     pUnoData( NULL ),
 110     mpDoc( pDocP ),
 111     bUsed( false ),
 112     bDirty( false ),
 113     bSeriesRangesScheduled( false )
 114 {
 115     ScRefTokenHelper::getTokensFromRangeList(*mpTokens, *rRangeList);
 116 }
 117
 118 ScChartListener::ScChartListener( const OUString& rName, ScDocument* pDocP, vector<ScTokenRef>* pTokens ) :
 119     SvtListener(),
 120     mpExtRefListener(NULL),
 121     mpTokens(pTokens),
 122     maName(rName),
 123     pUnoData( NULL ),
 124     mpDoc( pDocP ),
 125     bUsed( false ),
 126     bDirty( false ),
 127     bSeriesRangesScheduled( false )
 128 {
 129 }
 130
 131 ScChartListener::ScChartListener( const ScChartListener& r ) :
 132     SvtListener(),
 133     mpExtRefListener(NULL),
 134     mpTokens(new vector<ScTokenRef>(*r.mpTokens)),
 135     maName(r.maName),
 136     pUnoData( NULL ),
 137     mpDoc( r.mpDoc ),
 138     bUsed( false ),
 139     bDirty( r.bDirty ),
 140     bSeriesRangesScheduled( r.bSeriesRangesScheduled )
 141 {
 142     if ( r.pUnoData )
 143         pUnoData = new ScChartUnoData( *r.pUnoData );
 144
 145     if (r.mpExtRefListener.get())
 146     {
 147         // Re-register this new listener for the files that the old listener
 148         // was listening to.
 149
 150         ScExternalRefManager* pRefMgr = mpDoc->GetExternalRefManager();
 151         const boost::unordered_set<sal_uInt16>& rFileIds = r.mpExtRefListener->getAllFileIds();
 152         mpExtRefListener.reset(new ExternalRefListener(*this, mpDoc));
 153         boost::unordered_set<sal_uInt16>::const_iterator itr = rFileIds.begin(), itrEnd = rFileIds.end();
 154         for (; itr != itrEnd; ++itr)
 155         {
 156             pRefMgr->addLinkListener(*itr, mpExtRefListener.get());
 157             mpExtRefListener->addFileId(*itr);
 158         }
 159     }
 160 }
 161
 162 ScChartListener::~ScChartListener()
 163 {
 164     if ( HasBroadcaster() )
 165         EndListeningTo();
 166     delete pUnoData;
 167
 168     if (mpExtRefListener.get())
 169     {
 170         // Stop listening to all external files.
 171         ScExternalRefManager* pRefMgr = mpDoc->GetExternalRefManager();
 172         const boost::unordered_set<sal_uInt16>& rFileIds = mpExtRefListener->getAllFileIds();
 173         boost::unordered_set<sal_uInt16>::const_iterator itr = rFileIds.begin(), itrEnd = rFileIds.end();
 174         for (; itr != itrEnd; ++itr)
 175             pRefMgr->removeLinkListener(*itr, mpExtRefListener.get());
 176     }
 177 }
 178
 179 const OUString& ScChartListener::GetName() const
 180 {
 181     return maName;
 182 }
 183
 184 void ScChartListener::SetUno(
 185         const uno::Reference< chart::XChartDataChangeEventListener >& rListener,
 186         const uno::Reference< chart::XChartData >& rSource )
 187 {
 188     delete pUnoData;
 189     pUnoData = new ScChartUnoData( rListener, rSource );
 190 }
 191
 192 uno::Reference< chart::XChartDataChangeEventListener > ScChartListener::GetUnoListener() const
 193 {
 194     if ( pUnoData )
 195         return pUnoData->GetListener();
 196     return uno::Reference< chart::XChartDataChangeEventListener >();
 197 }
 198
 199 uno::Reference< chart::XChartData > ScChartListener::GetUnoSource() const
 200 {
 201     if ( pUnoData )
 202         return pUnoData->GetSource();
 203     return uno::Reference< chart::XChartData >();
 204 }
 205
 206 void ScChartListener::Notify( SvtBroadcaster&, const SfxHint& rHint )
 207 {
 208     const ScHint* p = dynamic_cast<const ScHint*>(&rHint);
 209     if (p && (p->GetId() & SC_HINT_DATACHANGED))
 210         SetUpdateQueue();
 211 }
 212
 213 void ScChartListener::Update()
 214 {
 215     if ( mpDoc->IsInInterpreter() )
 216     {   // If interpreting do nothing and restart timer so we don't
 217         // interfere with interpreter and don't produce an Err522 or similar.
 218         // This may happen if we are rescheduled via Basic function.
 219         mpDoc->GetChartListenerCollection()->StartTimer();
 220         return ;
 221     }
 222     if ( pUnoData )
 223     {
 224         bDirty = false;
 225         // recognize some day what has changed inside the Chart
 226         chart::ChartDataChangeEvent aEvent( pUnoData->GetSource(),
 227                                         chart::ChartDataChangeType_ALL,
 228                                         0, 0, 0, 0 );
 229         pUnoData->GetListener()->chartDataChanged( aEvent );
 230     }
 231     else if ( mpDoc->GetAutoCalc() )
 232     {
 233         bDirty = false;
 234         mpDoc->UpdateChart(GetName());
 235     }
 236 }
 237
 238 ScRangeListRef ScChartListener::GetRangeList() const
 239 {
 240     ScRangeListRef aRLRef(new ScRangeList);
 241     ScRefTokenHelper::getRangeListFromTokens(*aRLRef, *mpTokens, ScAddress());
 242     return aRLRef;
 243 }
 244
 245 void ScChartListener::SetRangeList( const ScRangeListRef& rNew )
 246 {
 247     vector<ScTokenRef> aTokens;
 248     ScRefTokenHelper::getTokensFromRangeList(aTokens, *rNew);
 249     mpTokens->swap(aTokens);
 250 }
 251
 252 namespace {
 253
 254 class StartEndListening : public unary_function<ScTokenRef, void>
 255 {
 256 public:
 257     StartEndListening(ScDocument* pDoc, ScChartListener& rParent, bool bStart) :
 258         mpDoc(pDoc), mrParent(rParent), mbStart(bStart) {}
 259
 260     void operator() (const ScTokenRef& pToken)
 261     {
 262         if (!ScRefTokenHelper::isRef(pToken))
 263             return;
 264
 265         bool bExternal = ScRefTokenHelper::isExternalRef(pToken);
 266         if (bExternal)
 267         {
 268             sal_uInt16 nFileId = pToken->GetIndex();
 269             ScExternalRefManager* pRefMgr = mpDoc->GetExternalRefManager();
 270             ScChartListener::ExternalRefListener* pExtRefListener = mrParent.GetExtRefListener();
 271             if (mbStart)
 272             {
 273                 pRefMgr->addLinkListener(nFileId, pExtRefListener);
 274                 pExtRefListener->addFileId(nFileId);
 275             }
 276             else
 277             {
 278                 pRefMgr->removeLinkListener(nFileId, pExtRefListener);
 279                 pExtRefListener->removeFileId(nFileId);
 280             }
 281         }
 282         else
 283         {
 284             ScRange aRange;
 285             ScRefTokenHelper::getRangeFromToken(aRange, pToken, ScAddress(), bExternal);
 286             if (mbStart)
 287                 startListening(aRange);
 288             else
 289                 endListening(aRange);
 290         }
 291     }
 292 private:
 293     void startListening(const ScRange& rRange)
 294     {
 295         if (rRange.aStart == rRange.aEnd)
 296             mpDoc->StartListeningCell(rRange.aStart, &mrParent);
 297         else
 298             mpDoc->StartListeningArea(rRange, &mrParent);
 299     }
 300
 301     void endListening(const ScRange& rRange)
 302     {
 303         if (rRange.aStart == rRange.aEnd)
 304             mpDoc->EndListeningCell(rRange.aStart, &mrParent);
 305         else
 306             mpDoc->EndListeningArea(rRange, &mrParent);
 307     }
 308 private:
 309     ScDocument* mpDoc;
 310     ScChartListener& mrParent;
 311     bool mbStart;
 312 };
 313
 314 }
 315
 316 void ScChartListener::StartListeningTo()
 317 {
 318     if (!mpTokens.get() || mpTokens->empty())
 319         // no references to listen to.
 320         return;
 321
 322     for_each(mpTokens->begin(), mpTokens->end(), StartEndListening(mpDoc, *this, true));
 323 }
 324
 325 void ScChartListener::EndListeningTo()
 326 {
 327     if (!mpTokens.get() || mpTokens->empty())
 328         // no references to listen to.
 329         return;
 330
 331     for_each(mpTokens->begin(), mpTokens->end(), StartEndListening(mpDoc, *this, false));
 332 }
 333
 334 void ScChartListener::ChangeListening( const ScRangeListRef& rRangeListRef,
 335                                        bool bDirtyP )
 336 {
 337     EndListeningTo();
 338     SetRangeList( rRangeListRef );
 339     StartListeningTo();
 340     if ( bDirtyP )
 341         SetDirty( true );
 342 }
 343
 344 void ScChartListener::UpdateScheduledSeriesRanges()
 345 {
 346     if ( bSeriesRangesScheduled )
 347     {
 348         bSeriesRangesScheduled = false;
 349         UpdateSeriesRanges();
 350     }
 351 }
 352
 353 void ScChartListener::UpdateChartIntersecting( const ScRange& rRange )
 354 {
 355     ScTokenRef pToken;
 356     ScRefTokenHelper::getTokenFromRange(pToken, rRange);
 357
 358     if (ScRefTokenHelper::intersects(*mpTokens, pToken, ScAddress()))
 359     {
 360         // force update (chart has to be loaded), don't use ScChartListener::Update
 361         mpDoc->UpdateChart(GetName());
 362     }
 363 }
 364
 365 void ScChartListener::UpdateSeriesRanges()
 366 {
 367     ScRangeListRef pRangeList(new ScRangeList);
 368     ScRefTokenHelper::getRangeListFromTokens(*pRangeList, *mpTokens, ScAddress());
 369     mpDoc->SetChartRangeList(GetName(), pRangeList);
 370 }
 371
 372 ScChartListener::ExternalRefListener* ScChartListener::GetExtRefListener()
 373 {
 374     if (!mpExtRefListener.get())
 375         mpExtRefListener.reset(new ExternalRefListener(*this, mpDoc));
 376
 377     return mpExtRefListener.get();
 378 }
 379
 380 void ScChartListener::SetUpdateQueue()
 381 {
 382     bDirty = true;
 383     mpDoc->GetChartListenerCollection()->StartTimer();
 384 }
 385
 386 bool ScChartListener::operator==( const ScChartListener& r ) const
 387 {
 388     bool b1 = (mpTokens.get() && !mpTokens->empty());
 389     bool b2 = (r.mpTokens.get() && !r.mpTokens->empty());
 390
 391     if (mpDoc != r.mpDoc || bUsed != r.bUsed || bDirty != r.bDirty ||
 392         bSeriesRangesScheduled != r.bSeriesRangesScheduled ||
 393         GetName() != r.GetName() || b1 != b2)
 394         return false;
 395
 396     if (!b1 && !b2)
 397         // both token list instances are empty.
 398         return true;
 399
 400     return *mpTokens == *r.mpTokens;
 401 }
 402
 403 bool ScChartListener::operator!=( const ScChartListener& r ) const
 404 {
 405     return !operator==(r);
 406 }
 407
 408 ScChartHiddenRangeListener::ScChartHiddenRangeListener()
 409 {
 410 }
 411
 412 ScChartHiddenRangeListener::~ScChartHiddenRangeListener()
 413 {
 414     // empty d'tor
 415 }
 416
 417 // ScChartListenerCollection
 418 ScChartListenerCollection::RangeListenerItem::RangeListenerItem(const ScRange& rRange, ScChartHiddenRangeListener* p) :
 419     maRange(rRange), mpListener(p)
 420 {
 421 }
 422
 423 ScChartListenerCollection::ScChartListenerCollection( ScDocument* pDocP ) :
 424     pDoc( pDocP )
 425 {
 426     aTimer.SetTimeoutHdl( LINK( this, ScChartListenerCollection, TimerHdl ) );
 427 }
 428
 429 ScChartListenerCollection::ScChartListenerCollection(
 430         const ScChartListenerCollection& rColl ) :
 431     pDoc( rColl.pDoc )
 432 {
 433     aTimer.SetTimeoutHdl( LINK( this, ScChartListenerCollection, TimerHdl ) );
 434 }
 435
 436 ScChartListenerCollection::~ScChartListenerCollection()
 437 {
 438     //  remove ChartListener objects before aTimer dtor is called, because
 439     //  ScChartListener::EndListeningTo may cause ScChartListenerCollection::StartTimer
 440     //  to be called if an empty ScNoteCell is deleted
 441
 442     maListeners.clear();
 443 }
 444
 445 void ScChartListenerCollection::StartAllListeners()
 446 {
 447     ListenersType::iterator it = maListeners.begin(), itEnd = maListeners.end();
 448     for (; it != itEnd; ++it)
 449         it->second->StartListeningTo();
 450 }
 451
 452 void ScChartListenerCollection::insert(ScChartListener* pListener)
 453 {
 454     OUString aName = pListener->GetName();
 455     maListeners.insert(aName, pListener);
 456 }
 457
 458 void ScChartListenerCollection::removeByName(const OUString& rName)
 459 {
 460     maListeners.erase(rName);
 461 }
 462
 463 ScChartListener* ScChartListenerCollection::findByName(const OUString& rName)
 464 {
 465     ListenersType::iterator it = maListeners.find(rName);
 466     return it == maListeners.end() ? NULL : it->second;
 467 }
 468
 469 const ScChartListener* ScChartListenerCollection::findByName(const OUString& rName) const
 470 {
 471     ListenersType::const_iterator it = maListeners.find(rName);
 472     return it == maListeners.end() ? NULL : it->second;
 473 }
 474
 475 bool ScChartListenerCollection::hasListeners() const
 476 {
 477     return !maListeners.empty();
 478 }
 479
 480 const ScChartListenerCollection::ListenersType& ScChartListenerCollection::getListeners() const
 481 {
 482     return maListeners;
 483 }
 484
 485 ScChartListenerCollection::ListenersType& ScChartListenerCollection::getListeners()
 486 {
 487     return maListeners;
 488 }
 489
 490 ScChartListenerCollection::StringSetType& ScChartListenerCollection::getNonOleObjectNames()
 491 {
 492     return maNonOleObjectNames;
 493 }
 494
 495 OUString ScChartListenerCollection::getUniqueName(const OUString& rPrefix) const
 496 {
 497     for (sal_Int32 nNum = 1; nNum < 10000; ++nNum) // arbitrary limit to prevent infinite loop.
 498     {
 499         OUStringBuffer aBuf(rPrefix);
 500         aBuf.append(nNum);
 501         OUString aTestName = aBuf.makeStringAndClear();
 502         if (maListeners.find(aTestName) == maListeners.end())
 503             return aTestName;
 504     }
 505     return OUString();
 506 }
 507
 508 void ScChartListenerCollection::ChangeListening( const OUString& rName,
 509         const ScRangeListRef& rRangeListRef, bool bDirty )
 510 {
 511     ScChartListener* pCL = findByName(rName);
 512     if (pCL)
 513     {
 514         pCL->EndListeningTo();
 515         pCL->SetRangeList( rRangeListRef );
 516     }
 517     else
 518     {
 519         pCL = new ScChartListener(rName, pDoc, rRangeListRef);
 520         insert(pCL);
 521     }
 522     pCL->StartListeningTo();
 523     if ( bDirty )
 524         pCL->SetDirty( true );
 525 }
 526
 527 namespace {
 528
 529 class InsertChartListener : public std::unary_function<ScChartListener*, void>
 530 {
 531     ScChartListenerCollection::ListenersType& mrListeners;
 532 public:
 533     InsertChartListener(ScChartListenerCollection::ListenersType& rListeners) :
 534         mrListeners(rListeners) {}
 535
 536     void operator() (ScChartListener* p)
 537     {
 538         OUString aName = p->GetName();
 539         mrListeners.insert(aName, p);
 540     }
 541 };
 542
 543 }
 544
 545 void ScChartListenerCollection::FreeUnused()
 546 {
 547     std::vector<ScChartListener*> aUsed, aUnused;
 548
 549     // First, filter each listener into 'used' and 'unused' categories.
 550     {
 551         ListenersType::iterator it = maListeners.begin(), itEnd = maListeners.end();
 552         for (; it != itEnd; ++it)
 553         {
 554             ScChartListener* p = it->second;
 555             if (p->IsUno())
 556             {
 557                 // We don't delete UNO charts; they are to be deleted separately via FreeUno().
 558                 aUsed.push_back(p);
 559                 continue;
 560             }
 561
 562             if (p->IsUsed())
 563             {
 564                 p->SetUsed(false);
 565                 aUsed.push_back(p);
 566             }
 567             else
 568                 aUnused.push_back(p);
 569         }
 570     }
 571
 572     // Release all pointers currently managed by the ptr_map container.
 573     maListeners.release().release();
 574
 575     // Re-insert the listeners we need to keep.
 576     std::for_each(aUsed.begin(), aUsed.end(), InsertChartListener(maListeners));
 577
 578     // Now, delete the ones no longer needed.
 579     std::for_each(aUnused.begin(), aUnused.end(), ScDeleteObjectByPtr<ScChartListener>());
 580 }
 581
 582 void ScChartListenerCollection::FreeUno( const uno::Reference< chart::XChartDataChangeEventListener >& rListener,
 583                                          const uno::Reference< chart::XChartData >& rSource )
 584 {
 585     std::vector<ScChartListener*> aUsed, aUnused;
 586
 587     // First, filter each listener into 'used' and 'unused' categories.
 588     {
 589         ListenersType::iterator it = maListeners.begin(), itEnd = maListeners.end();
 590         for (; it != itEnd; ++it)
 591         {
 592             ScChartListener* p = it->second;
 593             if (p->IsUno() && p->GetUnoListener() == rListener && p->GetUnoSource() == rSource)
 594                 aUnused.push_back(p);
 595             else
 596                 aUsed.push_back(p);
 597         }
 598     }
 599
 600     // Release all pointers currently managed by the ptr_map container.
 601     maListeners.release().release();
 602
 603     // Re-insert the listeners we need to keep.
 604     std::for_each(aUsed.begin(), aUsed.end(), InsertChartListener(maListeners));
 605
 606     // Now, delete the ones no longer needed.
 607     std::for_each(aUnused.begin(), aUnused.end(), ScDeleteObjectByPtr<ScChartListener>());
 608 }
 609
 610 void ScChartListenerCollection::StartTimer()
 611 {
 612     aTimer.SetTimeout( SC_CHARTTIMEOUT );
 613     aTimer.Start();
 614 }
 615
 616 IMPL_LINK_NOARG(ScChartListenerCollection, TimerHdl)
 617 {
 618     if ( Application::AnyInput( VCL_INPUT_KEYBOARD ) )
 619     {
 620         aTimer.Start();
 621         return 0;
 622     }
 623     UpdateDirtyCharts();
 624     return 0;
 625 }
 626
 627 void ScChartListenerCollection::UpdateDirtyCharts()
 628 {
 629     ListenersType::iterator it = maListeners.begin(), itEnd = maListeners.end();
 630     for (; it != itEnd; ++it)
 631     {
 632         ScChartListener* p = it->second;
 633         if (p->IsDirty())
 634             p->Update();
 635
 636         if (aTimer.IsActive() && !pDoc->IsImportingXML())
 637             break;                      // one interfered
 638     }
 639 }
 640
 641 void ScChartListenerCollection::SetDirty()
 642 {
 643     ListenersType::iterator it = maListeners.begin(), itEnd = maListeners.end();
 644     for (; it != itEnd; ++it)
 645         it->second->SetDirty(true);
 646
 647     StartTimer();
 648 }
 649
 650 void ScChartListenerCollection::SetDiffDirty(
 651             const ScChartListenerCollection& rCmp, bool bSetChartRangeLists )
 652 {
 653     bool bDirty = false;
 654     ListenersType::iterator it = maListeners.begin(), itEnd = maListeners.end();
 655     for (; it != itEnd; ++it)
 656     {
 657         ScChartListener* pCL = it->second;
 658         OSL_ASSERT(pCL);
 659         const ScChartListener* pCLCmp = rCmp.findByName(pCL->GetName());
 660         if (!pCLCmp || *pCL != *pCLCmp)
 661         {
 662             if ( bSetChartRangeLists )
 663             {
 664                 if (pCLCmp)
 665                 {
 666                     const ScRangeListRef& rList1 = pCL->GetRangeList();
 667                     const ScRangeListRef& rList2 = pCLCmp->GetRangeList();
 668                     bool b1 = rList1.Is();
 669                     bool b2 = rList2.Is();
 670                     if ( b1 != b2 || (b1 && b2 && (*rList1 != *rList2)) )
 671                         pDoc->SetChartRangeList( pCL->GetName(), rList1 );
 672                 }
 673                 else
 674                     pDoc->SetChartRangeList( pCL->GetName(), pCL->GetRangeList() );
 675             }
 676             bDirty = true;
 677             pCL->SetDirty( true );
 678         }
 679     }
 680     if ( bDirty )
 681         StartTimer();
 682 }
 683
 684 void ScChartListenerCollection::SetRangeDirty( const ScRange& rRange )
 685 {
 686     bool bDirty = false;
 687     ListenersType::iterator it = maListeners.begin(), itEnd = maListeners.end();
 688     for (; it != itEnd; ++it)
 689     {
 690         ScChartListener* pCL = it->second;
 691         const ScRangeListRef& rList = pCL->GetRangeList();
 692         if ( rList.Is() && rList->Intersects( rRange ) )
 693         {
 694             bDirty = true;
 695             pCL->SetDirty( true );
 696         }
 697     }
 698     if ( bDirty )
 699         StartTimer();
 700
 701     // New hidden range listener implementation
 702     for (list<RangeListenerItem>::iterator itr = maHiddenListeners.begin(), itrEnd = maHiddenListeners.end();
 703           itr != itrEnd; ++itr)
 704     {
 705         if (itr->maRange.Intersects(rRange))
 706             itr->mpListener->notify();
 707     }
 708 }
 709
 710 void ScChartListenerCollection::UpdateScheduledSeriesRanges()
 711 {
 712     ListenersType::iterator it = maListeners.begin(), itEnd = maListeners.end();
 713     for (; it != itEnd; ++it)
 714         it->second->UpdateScheduledSeriesRanges();
 715 }
 716
 717 void ScChartListenerCollection::UpdateChartsContainingTab( SCTAB nTab )
 718 {
 719     ScRange aRange( 0, 0, nTab, MAXCOL, MAXROW, nTab );
 720     ListenersType::iterator it = maListeners.begin(), itEnd = maListeners.end();
 721     for (; it != itEnd; ++it)
 722         it->second->UpdateChartIntersecting(aRange);
 723 }
 724
 725 bool ScChartListenerCollection::operator==( const ScChartListenerCollection& r ) const
 726 {
 727     // Do not use ScStrCollection::operator==() here that uses IsEqual und Compare.
 728     // Use ScChartListener::operator==() instead.
 729     if (pDoc != r.pDoc || maListeners.size() != r.maListeners.size())
 730         return false;
 731
 732     ListenersType::const_iterator it = maListeners.begin(), itEnd = maListeners.end();
 733     ListenersType::const_iterator it2 = r.maListeners.begin();
 734     for (; it != itEnd; ++it, ++it2)
 735     {
 736         if (*it != *it2)
 737             return false;
 738     }
 739     return true;
 740 }
 741
 742 bool ScChartListenerCollection::operator!=( const ScChartListenerCollection& r ) const
 743 {
 744     return !operator==(r);
 745 }
 746
 747 void ScChartListenerCollection::StartListeningHiddenRange( const ScRange& rRange, ScChartHiddenRangeListener* pListener )
 748 {
 749     RangeListenerItem aItem(rRange, pListener);
 750     maHiddenListeners.push_back(aItem);
 751 }
 752
 753 namespace {
 754
 755 struct MatchListener : public ::std::unary_function<
 756         ScChartListenerCollection::RangeListenerItem, bool>
 757 {
 758     MatchListener(const ScChartHiddenRangeListener* pMatch) :
 759         mpMatch(pMatch)
 760     {
 761     }
 762
 763     bool operator() (const ScChartListenerCollection::RangeListenerItem& rItem) const
 764     {
 765         return mpMatch == rItem.mpListener;
 766     }
 767
 768 private:
 769     const ScChartHiddenRangeListener* mpMatch;
 770 };
 771
 772 }
 773 void ScChartListenerCollection::EndListeningHiddenRange( ScChartHiddenRangeListener* pListener )
 774 {
 775     maHiddenListeners.remove_if(MatchListener(pListener));
 776 }
 777
 778 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */