sc/source/core/data/bcaslot.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 <sfx2/objsh.hxx>
  21 #include <svl/listener.hxx>
  22 #include <sal/log.hxx>
  23 #include <osl/diagnose.h>
  24
  25 #include <document.hxx>
  26 #include <docsh.hxx>
  27 #include <brdcst.hxx>
  28 #include <bcaslot.hxx>
  29 #include <scerrors.hxx>
  30 #include <refupdat.hxx>
  31 #include <bulkdatahint.hxx>
  32 #include <columnspanset.hxx>
  33 #include <formulacell.hxx>
  34 #include <grouparealistener.hxx>
  35 #include <broadcast.hxx>
  36
  37 ScBroadcastArea::ScBroadcastArea( const ScRange& rRange ) :
  38     pUpdateChainNext(nullptr),
  39     aRange(rRange),
  40     nRefCount(0),
  41     mbInUpdateChain(false),
  42     mbGroupListening(false) {}
  43
  44 ScBroadcastAreaSlot::ScBroadcastAreaSlot( ScDocument* pDocument,
  45         ScBroadcastAreaSlotMachine* pBASMa ) :
  46     aTmpSeekBroadcastArea( ScRange()),
  47     pDoc( pDocument ),
  48     pBASM( pBASMa ),
  49     mbInBroadcastIteration( false),
  50     mbHasErasedArea(false)
  51 {
  52 }
  53
  54 ScBroadcastAreaSlot::~ScBroadcastAreaSlot()
  55 {
  56     for ( ScBroadcastAreas::iterator aIter( aBroadcastAreaTbl.begin());
  57             aIter != aBroadcastAreaTbl.end(); /* none */)
  58     {
  59         // Prevent hash from accessing dangling pointer in case area is
  60         // deleted.
  61         ScBroadcastArea* pArea = (*aIter).mpArea;
  62         // Erase all so no hash will be accessed upon destruction of the
  63         // unordered_map.
  64         aIter = aBroadcastAreaTbl.erase(aIter);
  65         if (!pArea->DecRef())
  66             delete pArea;
  67     }
  68 }
  69
  70 ScDocument::HardRecalcState ScBroadcastAreaSlot::CheckHardRecalcStateCondition() const
  71 {
  72     ScDocument::HardRecalcState eState = pDoc->GetHardRecalcState();
  73     if (eState == ScDocument::HardRecalcState::OFF)
  74     {
  75         if (aBroadcastAreaTbl.size() >= aBroadcastAreaTbl.max_size())
  76         {   // this is more hypothetical now, check existed for old SV_PTRARR_SORT
  77             ScDocShell* pShell = pDoc->GetDocumentShell();
  78             OSL_ENSURE( pShell, "Missing DocShell :-/" );
  79
  80             if ( pShell )
  81                 pShell->SetError(SCWARN_CORE_HARD_RECALC);
  82
  83             pDoc->SetAutoCalc( false );
  84             eState = ScDocument::HardRecalcState::ETERNAL;
  85             pDoc->SetHardRecalcState( eState );
  86         }
  87     }
  88     return eState;
  89 }
  90
  91 bool ScBroadcastAreaSlot::StartListeningArea(
  92     const ScRange& rRange, bool bGroupListening, SvtListener* pListener, ScBroadcastArea*& rpArea )
  93 {
  94     bool bNewArea = false;
  95     OSL_ENSURE(pListener, "StartListeningArea: pListener Null");
  96     assert(!pDoc->IsDelayedFormulaGrouping()); // otherwise the group size might be incorrect
  97     if (CheckHardRecalcStateCondition() == ScDocument::HardRecalcState::ETERNAL)
  98         return false;
  99     if ( !rpArea )
 100     {
 101         // Even if most times the area doesn't exist yet and immediately trying
 102         // to new and insert it would save an attempt to find it, on massive
 103         // operations like identical large [HV]LOOKUP() areas the new/delete
 104         // would add quite some penalty for all but the first formula cell.
 105         ScBroadcastAreas::const_iterator aIter( FindBroadcastArea( rRange, bGroupListening));
 106         if (aIter != aBroadcastAreaTbl.end())
 107             rpArea = (*aIter).mpArea;
 108         else
 109         {
 110             rpArea = new ScBroadcastArea( rRange);
 111             rpArea->SetGroupListening(bGroupListening);
 112             if (aBroadcastAreaTbl.insert( rpArea).second)
 113             {
 114                 rpArea->IncRef();
 115                 bNewArea = true;
 116             }
 117             else
 118             {
 119                 OSL_FAIL("StartListeningArea: area not found and not inserted in slot?!?");
 120                 delete rpArea;
 121                 rpArea = nullptr;
 122             }
 123         }
 124         if (rpArea)
 125             pListener->StartListening( rpArea->GetBroadcaster());
 126     }
 127     else
 128     {
 129         if (aBroadcastAreaTbl.insert( rpArea).second)
 130             rpArea->IncRef();
 131     }
 132     return bNewArea;
 133 }
 134
 135 void ScBroadcastAreaSlot::InsertListeningArea( ScBroadcastArea* pArea )
 136 {
 137     OSL_ENSURE( pArea, "InsertListeningArea: pArea NULL");
 138     if (CheckHardRecalcStateCondition() == ScDocument::HardRecalcState::ETERNAL)
 139         return;
 140     if (aBroadcastAreaTbl.insert( pArea).second)
 141         pArea->IncRef();
 142 }
 143
 144 // If rpArea != NULL then no listeners are stopped, only the area is removed
 145 // and the reference count decremented.
 146 void ScBroadcastAreaSlot::EndListeningArea(
 147     const ScRange& rRange, bool bGroupListening, SvtListener* pListener, ScBroadcastArea*& rpArea )
 148 {
 149     OSL_ENSURE(pListener, "EndListeningArea: pListener Null");
 150     if ( !rpArea )
 151     {
 152         ScBroadcastAreas::iterator aIter( FindBroadcastArea( rRange, bGroupListening));
 153         if (aIter == aBroadcastAreaTbl.end() || isMarkedErased( aIter))
 154             return;
 155         rpArea = (*aIter).mpArea;
 156         pListener->EndListening( rpArea->GetBroadcaster() );
 157         if ( !rpArea->GetBroadcaster().HasListeners() )
 158         {   // if nobody is listening we can dispose it
 159             if (rpArea->GetRef() == 1)
 160                 rpArea = nullptr;      // will be deleted by erase
 161             EraseArea( aIter);
 162         }
 163     }
 164     else
 165     {
 166         if (rpArea && !rpArea->GetBroadcaster().HasListeners())
 167         {
 168             ScBroadcastAreas::iterator aIter( FindBroadcastArea( rRange, bGroupListening));
 169             if (aIter == aBroadcastAreaTbl.end() || isMarkedErased( aIter))
 170                 return;
 171             OSL_ENSURE( (*aIter).mpArea == rpArea, "EndListeningArea: area pointer mismatch");
 172             if (rpArea->GetRef() == 1)
 173                 rpArea = nullptr;      // will be deleted by erase
 174             EraseArea( aIter);
 175         }
 176     }
 177 }
 178
 179 ScBroadcastAreas::iterator ScBroadcastAreaSlot::FindBroadcastArea(
 180         const ScRange& rRange, bool bGroupListening )
 181 {
 182     aTmpSeekBroadcastArea.UpdateRange( rRange);
 183     aTmpSeekBroadcastArea.SetGroupListening(bGroupListening);
 184     return aBroadcastAreaTbl.find( &aTmpSeekBroadcastArea);
 185 }
 186
 187 namespace {
 188
 189 void broadcastRangeByCell( SvtBroadcaster& rBC, const ScRange& rRange, SfxHintId nHint )
 190 {
 191     ScHint aHint(nHint, ScAddress());
 192     for (SCTAB nTab = rRange.aStart.Tab(); nTab <= rRange.aEnd.Tab(); ++nTab)
 193     {
 194         aHint.SetAddressTab(nTab);
 195         for (SCCOL nCol = rRange.aStart.Col(); nCol <= rRange.aEnd.Col(); ++nCol)
 196         {
 197             aHint.SetAddressCol(nCol);
 198             for (SCROW nRow = rRange.aStart.Row(); nRow <= rRange.aEnd.Row(); ++nRow)
 199             {
 200                 aHint.SetAddressRow(nRow);
 201                 rBC.Broadcast(aHint);
 202             }
 203         }
 204     }
 205 }
 206
 207 }
 208
 209 bool ScBroadcastAreaSlot::AreaBroadcast( const ScRange& rRange, SfxHintId nHint )
 210 {
 211     if (aBroadcastAreaTbl.empty())
 212         return false;
 213
 214     bool bInBroadcast = mbInBroadcastIteration;
 215     mbInBroadcastIteration = true;
 216     bool bIsBroadcasted = false;
 217
 218     mbHasErasedArea = false;
 219
 220     for (ScBroadcastAreas::const_iterator aIter( aBroadcastAreaTbl.begin()),
 221             aIterEnd( aBroadcastAreaTbl.end()); aIter != aIterEnd; ++aIter )
 222     {
 223         if (mbHasErasedArea && isMarkedErased( aIter))
 224             continue;
 225
 226         ScBroadcastArea* pArea = (*aIter).mpArea;
 227         const ScRange& rAreaRange = pArea->GetRange();
 228
 229         // Take the intersection of the area range and the broadcast range.
 230         ScRange aIntersection = rAreaRange.Intersection(rRange);
 231         if (!aIntersection.IsValid())
 232             continue;
 233
 234         if (pArea->IsGroupListening())
 235         {
 236             if (pBASM->IsInBulkBroadcast())
 237             {
 238                 pBASM->InsertBulkGroupArea(pArea, aIntersection);
 239             }
 240             else
 241             {
 242                 broadcastRangeByCell(pArea->GetBroadcaster(), aIntersection, nHint);
 243                 bIsBroadcasted = true;
 244             }
 245         }
 246         else if (!pBASM->IsInBulkBroadcast() || pBASM->InsertBulkArea( pArea))
 247         {
 248             broadcastRangeByCell(pArea->GetBroadcaster(), aIntersection, nHint);
 249             bIsBroadcasted = true;
 250         }
 251     }
 252
 253     mbInBroadcastIteration = bInBroadcast;
 254
 255     // A Notify() during broadcast may call EndListeningArea() and thus dispose
 256     // an area if it was the last listener, which would invalidate an iterator
 257     // pointing to it, hence the real erase is done afterwards.
 258     FinallyEraseAreas();
 259
 260     return bIsBroadcasted;
 261 }
 262
 263 bool ScBroadcastAreaSlot::AreaBroadcast( const ScHint& rHint)
 264 {
 265     if (aBroadcastAreaTbl.empty())
 266         return false;
 267
 268     bool bInBroadcast = mbInBroadcastIteration;
 269     mbInBroadcastIteration = true;
 270     bool bIsBroadcasted = false;
 271
 272     mbHasErasedArea = false;
 273
 274     const ScRange& rRange = rHint.GetRange();
 275     for (ScBroadcastAreas::const_iterator aIter( aBroadcastAreaTbl.begin()),
 276             aIterEnd( aBroadcastAreaTbl.end()); aIter != aIterEnd; ++aIter )
 277     {
 278         if (mbHasErasedArea && isMarkedErased( aIter))
 279             continue;
 280
 281         ScBroadcastArea* pArea = (*aIter).mpArea;
 282         const ScRange& rAreaRange = pArea->GetRange();
 283         if (rAreaRange.Intersects( rRange))
 284         {
 285             if (pArea->IsGroupListening())
 286             {
 287                 if (pBASM->IsInBulkBroadcast())
 288                 {
 289                     pBASM->InsertBulkGroupArea(pArea, rRange);
 290                 }
 291                 else
 292                 {
 293                     pArea->GetBroadcaster().Broadcast( rHint);
 294                     bIsBroadcasted = true;
 295                 }
 296             }
 297             else if (!pBASM->IsInBulkBroadcast() || pBASM->InsertBulkArea( pArea))
 298             {
 299                 pArea->GetBroadcaster().Broadcast( rHint);
 300                 bIsBroadcasted = true;
 301             }
 302         }
 303     }
 304
 305     mbInBroadcastIteration = bInBroadcast;
 306
 307     // A Notify() during broadcast may call EndListeningArea() and thus dispose
 308     // an area if it was the last listener, which would invalidate an iterator
 309     // pointing to it, hence the real erase is done afterwards.
 310     FinallyEraseAreas();
 311
 312     return bIsBroadcasted;
 313 }
 314
 315 void ScBroadcastAreaSlot::DelBroadcastAreasInRange( const ScRange& rRange )
 316 {
 317     if (aBroadcastAreaTbl.empty())
 318         return;
 319     for (ScBroadcastAreas::iterator aIter( aBroadcastAreaTbl.begin());
 320             aIter != aBroadcastAreaTbl.end(); /* increment in body */ )
 321     {
 322         const ScRange& rAreaRange = (*aIter).mpArea->GetRange();
 323         if (rRange.Contains( rAreaRange))
 324         {
 325             ScBroadcastArea* pArea = (*aIter).mpArea;
 326             aIter = aBroadcastAreaTbl.erase(aIter);  // erase before modifying
 327             if (!pArea->DecRef())
 328             {
 329                 if (pBASM->IsInBulkBroadcast())
 330                     pBASM->RemoveBulkArea( pArea);
 331                 delete pArea;
 332             }
 333         }
 334         else
 335             ++aIter;
 336     }
 337 }
 338
 339 void ScBroadcastAreaSlot::UpdateRemove( UpdateRefMode eUpdateRefMode,
 340         const ScRange& rRange, SCCOL nDx, SCROW nDy, SCTAB nDz )
 341 {
 342     if (aBroadcastAreaTbl.empty())
 343         return;
 344
 345     SCCOL nCol1, nCol2, theCol1, theCol2;
 346     SCROW nRow1, nRow2, theRow1, theRow2;
 347     SCTAB nTab1, nTab2, theTab1, theTab2;
 348     rRange.GetVars( nCol1, nRow1, nTab1, nCol2, nRow2, nTab2);
 349     for ( ScBroadcastAreas::iterator aIter( aBroadcastAreaTbl.begin());
 350             aIter != aBroadcastAreaTbl.end(); /* increment in body */ )
 351     {
 352         ScBroadcastArea* pArea = (*aIter).mpArea;
 353         if ( pArea->IsInUpdateChain() )
 354         {
 355             aIter = aBroadcastAreaTbl.erase(aIter);
 356             pArea->DecRef();
 357         }
 358         else
 359         {
 360             pArea->GetRange().GetVars( theCol1, theRow1, theTab1, theCol2, theRow2, theTab2);
 361             if ( ScRefUpdate::Update( pDoc, eUpdateRefMode,
 362                     nCol1,nRow1,nTab1, nCol2,nRow2,nTab2, nDx,nDy,nDz,
 363                     theCol1,theRow1,theTab1, theCol2,theRow2,theTab2 ))
 364             {
 365                 aIter = aBroadcastAreaTbl.erase(aIter);
 366                 pArea->DecRef();
 367                 if (pBASM->IsInBulkBroadcast())
 368                     pBASM->RemoveBulkArea( pArea);
 369                 pArea->SetInUpdateChain( true );
 370                 ScBroadcastArea* pUC = pBASM->GetEOUpdateChain();
 371                 if ( pUC )
 372                     pUC->SetUpdateChainNext( pArea );
 373                 else    // no tail => no head
 374                     pBASM->SetUpdateChain( pArea );
 375                 pBASM->SetEOUpdateChain( pArea );
 376             }
 377             else
 378                 ++aIter;
 379         }
 380     }
 381 }
 382
 383 void ScBroadcastAreaSlot::UpdateRemoveArea( ScBroadcastArea* pArea )
 384 {
 385     ScBroadcastAreas::iterator aIter( aBroadcastAreaTbl.find( pArea));
 386     if (aIter == aBroadcastAreaTbl.end())
 387         return;
 388     if ((*aIter).mpArea != pArea)
 389         OSL_FAIL( "UpdateRemoveArea: area pointer mismatch");
 390     else
 391     {
 392         aBroadcastAreaTbl.erase( aIter);
 393         pArea->DecRef();
 394     }
 395 }
 396
 397 void ScBroadcastAreaSlot::UpdateInsert( ScBroadcastArea* pArea )
 398 {
 399     ::std::pair< ScBroadcastAreas::iterator, bool > aPair =
 400         aBroadcastAreaTbl.insert( pArea);
 401     if (aPair.second)
 402         pArea->IncRef();
 403     else
 404     {
 405         // Identical area already exists, add listeners.
 406         ScBroadcastArea* pTarget = (*(aPair.first)).mpArea;
 407         if (pArea != pTarget)
 408         {
 409             SvtBroadcaster& rTarget = pTarget->GetBroadcaster();
 410             SvtBroadcaster::ListenersType& rListeners = pArea->GetBroadcaster().GetAllListeners();
 411             for (auto& pListener : rListeners)
 412             {
 413                 SvtListener& rListener = *pListener;
 414                 rListener.StartListening(rTarget);
 415             }
 416         }
 417     }
 418 }
 419
 420 void ScBroadcastAreaSlot::EraseArea( ScBroadcastAreas::iterator& rIter )
 421 {
 422     if (mbInBroadcastIteration)
 423     {
 424         (*rIter).mbErasure = true;      // mark for erasure
 425         mbHasErasedArea = true; // at least one area is marked for erasure.
 426         pBASM->PushAreaToBeErased( this, rIter);
 427     }
 428     else
 429     {
 430         ScBroadcastArea* pArea = (*rIter).mpArea;
 431         aBroadcastAreaTbl.erase( rIter);
 432         if (!pArea->DecRef())
 433         {
 434             if (pBASM->IsInBulkBroadcast())
 435                 pBASM->RemoveBulkGroupArea(pArea);
 436             delete pArea;
 437         }
 438     }
 439 }
 440
 441 void ScBroadcastAreaSlot::GetAllListeners(
 442     const ScRange& rRange, std::vector<sc::AreaListener>& rListeners,
 443     sc::AreaOverlapType eType, sc::ListenerGroupType eGroup )
 444 {
 445     for (ScBroadcastAreas::const_iterator aIter( aBroadcastAreaTbl.begin()),
 446             aIterEnd( aBroadcastAreaTbl.end()); aIter != aIterEnd; ++aIter )
 447     {
 448         if (isMarkedErased( aIter))
 449             continue;
 450
 451         ScBroadcastArea* pArea = (*aIter).mpArea;
 452         const ScRange& rAreaRange = pArea->GetRange();
 453         switch (eGroup)
 454         {
 455             case sc::ListenerGroupType::Group:
 456                 if (!pArea->IsGroupListening())
 457                     continue;
 458             break;
 459             case sc::ListenerGroupType::Both:
 460             default:
 461                 ;
 462         }
 463
 464         switch (eType)
 465         {
 466             case sc::AreaOverlapType::Inside:
 467                 if (!rRange.Contains(rAreaRange))
 468                     // The range needs to be fully inside specified range.
 469                     continue;
 470                 break;
 471             case sc::AreaOverlapType::InsideOrOverlap:
 472                 if (!rRange.Intersects(rAreaRange))
 473                     // The range needs to be partially overlapping or fully inside.
 474                     continue;
 475                 break;
 476             case sc::AreaOverlapType::OneRowInside:
 477                 if (rAreaRange.aStart.Row() != rAreaRange.aEnd.Row() || !rRange.Contains(rAreaRange))
 478                     // The range needs to be one single row and fully inside
 479                     // specified range.
 480                     continue;
 481                 break;
 482             case sc::AreaOverlapType::OneColumnInside:
 483                 if (rAreaRange.aStart.Col() != rAreaRange.aEnd.Col() || !rRange.Contains(rAreaRange))
 484                     // The range needs to be one single column and fully inside
 485                     // specified range.
 486                     continue;
 487                 break;
 488         }
 489
 490         SvtBroadcaster::ListenersType& rLst = pArea->GetBroadcaster().GetAllListeners();
 491         for (const auto& pListener : rLst)
 492         {
 493             sc::AreaListener aEntry;
 494             aEntry.maArea = rAreaRange;
 495             aEntry.mbGroupListening = pArea->IsGroupListening();
 496             aEntry.mpListener = pListener;
 497             rListeners.push_back(aEntry);
 498         }
 499     }
 500 }
 501
 502 void ScBroadcastAreaSlot::CollectBroadcasterState(sc::BroadcasterState& rState) const
 503 {
 504     for (const ScBroadcastAreaEntry& rEntry : aBroadcastAreaTbl)
 505     {
 506         const ScRange& rRange = rEntry.mpArea->GetRange();
 507         auto aRes = rState.aAreaListenerStore.try_emplace(rRange);
 508         auto& rLisStore = aRes.first->second;
 509
 510         for (const SvtListener* pLis : rEntry.mpArea->GetBroadcaster().GetAllListeners())
 511         {
 512             if (auto pFC = dynamic_cast<const ScFormulaCell*>(pLis); pFC)
 513             {
 514                 rLisStore.emplace_back(pFC);
 515                 continue;
 516             }
 517
 518             if (auto pFGL = dynamic_cast<const sc::FormulaGroupAreaListener*>(pLis); pFGL)
 519             {
 520                 rLisStore.emplace_back(pFGL);
 521                 continue;
 522             }
 523
 524             rLisStore.emplace_back(pLis);
 525         }
 526     }
 527 }
 528
 529 void ScBroadcastAreaSlot::FinallyEraseAreas()
 530 {
 531     pBASM->FinallyEraseAreas( this);
 532 }
 533
 534 // --- ScBroadcastAreaSlotMachine -------------------------------------
 535
 536 ScBroadcastAreaSlotMachine::TableSlots::TableSlots(SCSIZE nBcaSlots)
 537     : mnBcaSlots(nBcaSlots)
 538 {
 539     ppSlots.reset( new ScBroadcastAreaSlot* [ nBcaSlots ] );
 540     memset( ppSlots.get(), 0 , sizeof( ScBroadcastAreaSlot* ) * nBcaSlots );
 541 }
 542
 543 ScBroadcastAreaSlotMachine::TableSlots::TableSlots(TableSlots&& rOther) noexcept
 544     : mnBcaSlots(rOther.mnBcaSlots)
 545     , ppSlots( std::move(rOther.ppSlots) )
 546 {
 547 }
 548
 549 ScBroadcastAreaSlotMachine::TableSlots::~TableSlots()
 550 {
 551     if (ppSlots)
 552         for ( ScBroadcastAreaSlot** pp = ppSlots.get() + mnBcaSlots; --pp >= ppSlots.get(); /* nothing */ )
 553             delete *pp;
 554 }
 555
 556 ScBroadcastAreaSlotMachine::ScBroadcastAreaSlotMachine(
 557         ScDocument* pDocument ) :
 558     pDoc( pDocument ),
 559     pUpdateChain( nullptr ),
 560     pEOUpdateChain( nullptr ),
 561     nInBulkBroadcast( 0 )
 562 {
 563     // initSlotDistribution ---------
 564     // Logarithmic or any other distribution.
 565     // Upper and leftmost sheet part usually is more populated and referenced and gets fine
 566     // grained resolution, larger data in larger hunks.
 567     // Just like with cells, slots are organized in columns. Slot 0 is for first nSliceRow x nSliceCol
 568     // cells, slot 1 is for next nSliceRow x nSliceCel cells below, etc. After a while the size of row
 569     // slice doubles (making more cells share the same slot), this distribution data is stored
 570     // in ScSlotData including ranges of cells. This is repeated for another column of nSliceCol cells,
 571     // again with the column slice doubling after some time.
 572     // Functions ComputeSlotOffset(), ComputeArePoints() and ComputeNextSlot() do the necessary
 573     // calculations.
 574     SCSIZE nSlots = 0;
 575     // This should be SCCOL, but that's only 16bit and would overflow when doubling 16k columns.
 576     sal_Int32 nCol1 = 0;
 577     sal_Int32 nCol2 = 1024;
 578     SCSIZE nSliceCol = 16;
 579     while (nCol2 <= pDoc->GetMaxColCount())
 580     {
 581         SCROW nRow1 = 0;
 582         SCROW nRow2 = 32*1024;
 583         SCSIZE nSliceRow = 128;
 584         SCSIZE nSlotsCol = 0;
 585         SCSIZE nSlotsStartCol = nSlots;
 586         // Must be sorted by row1,row2!
 587         while (nRow2 <= pDoc->GetMaxRowCount())
 588         {
 589             maSlotDistribution.emplace_back(nRow1, nRow2, nSliceRow, nSlotsCol, nCol1, nCol2, nSliceCol, nSlotsStartCol);
 590             nSlotsCol += (nRow2 - nRow1) / nSliceRow;
 591             nRow1 = nRow2;
 592             nRow2 *= 2;
 593             nSliceRow *= 2;
 594         }
 595         // Store the number of slots in a column in mnBcaSlotsCol, so that finding a slot
 596         // to the right can be computed quickly in ComputeNextSlot().
 597         if(nCol1 == 0)
 598             mnBcaSlotsCol = nSlotsCol;
 599         assert(nSlotsCol == mnBcaSlotsCol);
 600         nSlots += (nCol2 - nCol1) / nSliceCol * nSlotsCol;
 601         nCol1 = nCol2;
 602         nCol2 *= 2;
 603         nSliceCol *= 2;
 604     }
 605     mnBcaSlots = nSlots;
 606 #ifdef DBG_UTIL
 607     DoChecks();
 608 #endif
 609 }
 610
 611 ScBroadcastAreaSlotMachine::~ScBroadcastAreaSlotMachine()
 612 {
 613     aTableSlotsMap.clear();
 614     pBCAlways.reset();
 615     // Areas to-be-erased still present is a serious error in handling, but at
 616     // this stage there's nothing we can do anymore.
 617     SAL_WARN_IF( !maAreasToBeErased.empty(), "sc.core", "ScBroadcastAreaSlotMachine::dtor: maAreasToBeErased not empty");
 618 }
 619
 620 inline SCSIZE ScBroadcastAreaSlotMachine::ComputeSlotOffset(
 621         const ScAddress& rAddress ) const
 622 {
 623     SCROW nRow = rAddress.Row();
 624     SCCOL nCol = rAddress.Col();
 625     if ( !pDoc->ValidRow(nRow) || !pDoc->ValidCol(nCol) )
 626     {
 627         OSL_FAIL( "Row/Col invalid, using first slot!" );
 628         return 0;
 629     }
 630     for (const ScSlotData& rSD : maSlotDistribution)
 631     {
 632         if (nRow < rSD.nStopRow && nCol < rSD.nStopCol)
 633         {
 634             assert(nRow >= rSD.nStartRow);
 635             assert(nCol >= rSD.nStartCol);
 636             SCSIZE slot = rSD.nCumulatedRow
 637                 + static_cast<SCSIZE>(nRow - rSD.nStartRow) / rSD.nSliceRow
 638                 + rSD.nCumulatedCol
 639                 + static_cast<SCSIZE>(nCol - rSD.nStartCol) / rSD.nSliceCol * mnBcaSlotsCol;
 640             assert(slot < mnBcaSlots);
 641             return slot;
 642         }
 643     }
 644     OSL_FAIL( "No slot found, using last!" );
 645     return mnBcaSlots - 1;
 646 }
 647
 648 void ScBroadcastAreaSlotMachine::ComputeAreaPoints( const ScRange& rRange,
 649         SCSIZE& rStart, SCSIZE& rEnd, SCSIZE& rRowBreak ) const
 650 {
 651     rStart = ComputeSlotOffset( rRange.aStart );
 652     rEnd = ComputeSlotOffset( rRange.aEnd );
 653     // count of row slots per column minus one
 654     rRowBreak = ComputeSlotOffset(
 655         ScAddress( rRange.aStart.Col(), rRange.aEnd.Row(), 0 ) ) - rStart;
 656 }
 657
 658 static void ComputeNextSlot( SCSIZE & nOff, SCSIZE & nBreak, ScBroadcastAreaSlot** & pp,
 659         SCSIZE & nStart, ScBroadcastAreaSlot** const & ppSlots, SCSIZE nRowBreak, SCSIZE nBcaSlotsCol )
 660 {
 661     if ( nOff < nBreak )
 662     {
 663         ++nOff;
 664         ++pp;
 665     }
 666     else
 667     {
 668         nStart += nBcaSlotsCol;
 669         nOff = nStart;
 670         pp = ppSlots + nOff;
 671         nBreak = nOff + nRowBreak;
 672     }
 673 }
 674
 675 #ifdef DBG_UTIL
 676 static void compare(SCSIZE value1, SCSIZE value2, int line)
 677 {
 678     if(value1!=value2)
 679         SAL_WARN("sc", "V1:" << value1 << " V2:" << value2 << " (" << line << ")");
 680     assert(value1 == value2);
 681 }
 682
 683 // Basic checks that the calculations work correctly.
 684 void ScBroadcastAreaSlotMachine::DoChecks()
 685 {
 686     // Copy&paste from the ctor.
 687     constexpr SCSIZE nSliceRow = 128;
 688     constexpr SCSIZE nSliceCol = 16;
 689     // First and second column are in the same slice and so get the same slot.
 690     compare( ComputeSlotOffset( ScAddress( 0, 0, 0 )), ComputeSlotOffset( ScAddress( 1, 0, 0 )), __LINE__);
 691     // Each nSliceRow rows are offset by one slot (at the start of the logarithmic distribution).
 692     compare( ComputeSlotOffset( ScAddress( 0, 0, 0 )),
 693              ComputeSlotOffset( ScAddress( 0, nSliceRow, 0 )) - 1, __LINE__ );
 694     compare( ComputeSlotOffset( ScAddress( nSliceCol - 1, 0, 0 )),
 695              ComputeSlotOffset( ScAddress( nSliceCol, 0, 0 )) - mnBcaSlotsCol, __LINE__ );
 696     // Check that last cell is the last slot.
 697     compare( ComputeSlotOffset( ScAddress( pDoc->GetMaxColCount() - 1, pDoc->GetMaxRowCount() - 1, 0 )),
 698              mnBcaSlots - 1, __LINE__ );
 699     // Check that adjacent rows in the same column but in different distribution areas differ by one slot.
 700     for( size_t i = 0; i < maSlotDistribution.size() - 1; ++i )
 701     {
 702         const ScSlotData& s1 = maSlotDistribution[ i ];
 703         const ScSlotData& s2 = maSlotDistribution[ i + 1 ];
 704         if( s1.nStartCol == s2.nStartCol )
 705         {
 706             assert( s1.nStopRow == s2.nStartRow );
 707             compare( ComputeSlotOffset( ScAddress( s1.nStartCol, s1.nStopRow - 1, 0 )),
 708                      ComputeSlotOffset( ScAddress( s1.nStartCol, s1.nStopRow, 0 )) - 1, __LINE__ );
 709         }
 710     }
 711     // Check that adjacent columns in the same row but in different distribution areas differ by mnBcaSlotsCol.
 712     for( size_t i = 0; i < maSlotDistribution.size() - 1; ++i )
 713     {
 714         const ScSlotData& s1 = maSlotDistribution[ i ];
 715         for( size_t j = i + 1; j < maSlotDistribution.size(); ++j )
 716         {
 717             const ScSlotData& s2 = maSlotDistribution[ i + 1 ];
 718             if( s1.nStartRow == s2.nStartRow && s1.nStopCol == s2.nStartCol )
 719             {
 720                 assert( s1.nStopRow == s2.nStartRow );
 721                 compare( ComputeSlotOffset( ScAddress( s1.nStopCol - 1, s1.nStartRow, 0 )),
 722                          ComputeSlotOffset( ScAddress( s1.nStopCol, s1.nStartRow, 0 )) - mnBcaSlotsCol, __LINE__ );
 723             }
 724         }
 725     }
 726     // Iterate all slots.
 727     ScRange range( ScAddress( 0, 0, 0 ), ScAddress( pDoc->MaxCol(), pDoc->MaxRow(), 0 ));
 728     SCSIZE nStart, nEnd, nRowBreak;
 729     ComputeAreaPoints( range, nStart, nEnd, nRowBreak );
 730     assert( nStart == 0 );
 731     assert( nEnd == mnBcaSlots - 1 );
 732     SCSIZE nOff = nStart;
 733     SCSIZE nBreak = nOff + nRowBreak;
 734     std::unique_ptr<ScBroadcastAreaSlot*[]> slots( new ScBroadcastAreaSlot*[ mnBcaSlots ] ); // dummy, not accessed
 735     ScBroadcastAreaSlot** ppSlots = slots.get();
 736     ScBroadcastAreaSlot** pp = ppSlots;
 737     while ( nOff <= nEnd )
 738     {
 739         SCSIZE previous = nOff;
 740         ComputeNextSlot( nOff, nBreak, pp, nStart, ppSlots, nRowBreak, mnBcaSlotsCol);
 741         compare( nOff, previous + 1, __LINE__ );
 742     }
 743     // Iterate slots in the last row (each will differ by mnBcaSlotsCol).
 744     range = ScRange( ScAddress( 0, pDoc->MaxRow(), 0 ),
 745                      ScAddress( pDoc->MaxCol(), pDoc->MaxRow() - 1, 0 ));
 746     ComputeAreaPoints( range, nStart, nEnd, nRowBreak );
 747     assert( nStart == mnBcaSlotsCol - 1 );
 748     assert( nEnd == mnBcaSlots - 1 );
 749     nOff = nStart;
 750     nBreak = nOff + nRowBreak;
 751     ppSlots = slots.get();
 752     pp = ppSlots;
 753     while ( nOff <= nEnd )
 754     {
 755         SCSIZE previous = nOff;
 756         ComputeNextSlot( nOff, nBreak, pp, nStart, ppSlots, nRowBreak, mnBcaSlotsCol);
 757         compare( nOff, previous + mnBcaSlotsCol, __LINE__ );
 758     }
 759 }
 760 #endif
 761
 762 void ScBroadcastAreaSlotMachine::StartListeningArea(
 763     const ScRange& rRange, bool bGroupListening, SvtListener* pListener )
 764 {
 765     if ( rRange == BCA_LISTEN_ALWAYS  )
 766     {
 767         if ( !pBCAlways )
 768             pBCAlways.reset( new SvtBroadcaster );
 769         pListener->StartListening( *pBCAlways );
 770     }
 771     else
 772     {
 773         // A new area needs to be inserted to the corresponding slots, for 3D
 774         // ranges for all sheets, do not slice into per sheet areas or the
 775         // !bDone will break too early (i.e. after the first sheet) if
 776         // subsequent listeners are to be added.
 777         ScBroadcastArea* pArea = nullptr;
 778         bool bDone = false;
 779         for (SCTAB nTab = rRange.aStart.Tab();
 780                 !bDone && nTab <= rRange.aEnd.Tab(); ++nTab)
 781         {
 782             TableSlotsMap::iterator iTab( aTableSlotsMap.find( nTab));
 783             if (iTab == aTableSlotsMap.end())
 784                 iTab = aTableSlotsMap.emplace( std::piecewise_construct,
 785                         std::forward_as_tuple(nTab), std::forward_as_tuple(mnBcaSlots) ).first;
 786             ScBroadcastAreaSlot** ppSlots = (*iTab).second.getSlots();
 787             SCSIZE nStart, nEnd, nRowBreak;
 788             ComputeAreaPoints( rRange, nStart, nEnd, nRowBreak );
 789             SCSIZE nOff = nStart;
 790             SCSIZE nBreak = nOff + nRowBreak;
 791             ScBroadcastAreaSlot** pp = ppSlots + nOff;
 792             while ( !bDone && nOff <= nEnd )
 793             {
 794                 if ( !*pp )
 795                     *pp = new ScBroadcastAreaSlot( pDoc, this );
 796                 if (!pArea)
 797                 {
 798                     // If the call to StartListeningArea didn't create the
 799                     // ScBroadcastArea, listeners were added to an already
 800                     // existing identical area that doesn't need to be inserted
 801                     // to slots again.
 802                     if (!(*pp)->StartListeningArea( rRange, bGroupListening, pListener, pArea))
 803                         bDone = true;
 804                 }
 805                 else
 806                     (*pp)->InsertListeningArea( pArea);
 807                 ComputeNextSlot( nOff, nBreak, pp, nStart, ppSlots, nRowBreak, mnBcaSlotsCol);
 808             }
 809         }
 810     }
 811 }
 812
 813 void ScBroadcastAreaSlotMachine::EndListeningArea(
 814     const ScRange& rRange, bool bGroupListening, SvtListener* pListener )
 815 {
 816     if ( rRange == BCA_LISTEN_ALWAYS  )
 817     {
 818         if ( pBCAlways )
 819         {
 820             pListener->EndListening( *pBCAlways);
 821             if (!pBCAlways->HasListeners())
 822             {
 823                 pBCAlways.reset();
 824             }
 825         }
 826     }
 827     else
 828     {
 829         SCTAB nEndTab = rRange.aEnd.Tab();
 830         for (TableSlotsMap::iterator iTab( aTableSlotsMap.lower_bound( rRange.aStart.Tab()));
 831                 iTab != aTableSlotsMap.end() && (*iTab).first <= nEndTab; ++iTab)
 832         {
 833             ScBroadcastAreaSlot** ppSlots = (*iTab).second.getSlots();
 834             SCSIZE nStart, nEnd, nRowBreak;
 835             ComputeAreaPoints( rRange, nStart, nEnd, nRowBreak );
 836             SCSIZE nOff = nStart;
 837             SCSIZE nBreak = nOff + nRowBreak;
 838             ScBroadcastAreaSlot** pp = ppSlots + nOff;
 839             ScBroadcastArea* pArea = nullptr;
 840             if (nOff == 0 && nEnd == mnBcaSlots-1)
 841             {
 842                 // Slightly optimized for 0,0,MAXCOL,MAXROW calls as they
 843                 // happen for insertion and deletion of sheets.
 844                 ScBroadcastAreaSlot** const pStop = ppSlots + nEnd;
 845                 do
 846                 {
 847                     if ( *pp )
 848                         (*pp)->EndListeningArea( rRange, bGroupListening, pListener, pArea);
 849                 } while (++pp < pStop);
 850             }
 851             else
 852             {
 853                 while ( nOff <= nEnd )
 854                 {
 855                     if ( *pp )
 856                         (*pp)->EndListeningArea( rRange, bGroupListening, pListener, pArea);
 857                     ComputeNextSlot( nOff, nBreak, pp, nStart, ppSlots, nRowBreak, mnBcaSlotsCol);
 858                 }
 859             }
 860         }
 861     }
 862 }
 863
 864 bool ScBroadcastAreaSlotMachine::AreaBroadcast( const ScRange& rRange, SfxHintId nHint )
 865 {
 866     bool bBroadcasted = false;
 867     SCTAB nEndTab = rRange.aEnd.Tab();
 868     for (TableSlotsMap::iterator iTab( aTableSlotsMap.lower_bound( rRange.aStart.Tab()));
 869             iTab != aTableSlotsMap.end() && (*iTab).first <= nEndTab; ++iTab)
 870     {
 871         ScBroadcastAreaSlot** ppSlots = (*iTab).second.getSlots();
 872         SCSIZE nStart, nEnd, nRowBreak;
 873         ComputeAreaPoints( rRange, nStart, nEnd, nRowBreak );
 874         SCSIZE nOff = nStart;
 875         SCSIZE nBreak = nOff + nRowBreak;
 876         ScBroadcastAreaSlot** pp = ppSlots + nOff;
 877         while ( nOff <= nEnd )
 878         {
 879             if ( *pp )
 880                 bBroadcasted |= (*pp)->AreaBroadcast( rRange, nHint );
 881             ComputeNextSlot( nOff, nBreak, pp, nStart, ppSlots, nRowBreak, mnBcaSlotsCol);
 882         }
 883     }
 884     return bBroadcasted;
 885 }
 886
 887 bool ScBroadcastAreaSlotMachine::AreaBroadcast( const ScHint& rHint ) const
 888 {
 889     const ScAddress& rAddress = rHint.GetStartAddress();
 890     if ( rAddress == BCA_BRDCST_ALWAYS )
 891     {
 892         if ( pBCAlways )
 893         {
 894             pBCAlways->Broadcast( rHint );
 895             return true;
 896         }
 897         else
 898             return false;
 899     }
 900     else
 901     {
 902         TableSlotsMap::const_iterator iTab( aTableSlotsMap.find( rAddress.Tab()));
 903         if (iTab == aTableSlotsMap.end())
 904             return false;
 905         // Process all slots for the given row range.
 906         ScRange broadcastRange( rAddress,
 907             ScAddress( rAddress.Col(), rAddress.Row() + rHint.GetRowCount() - 1, rAddress.Tab()));
 908         bool bBroadcasted = false;
 909         ScBroadcastAreaSlot** ppSlots = (*iTab).second.getSlots();
 910         SCSIZE nStart, nEnd, nRowBreak;
 911         ComputeAreaPoints( broadcastRange, nStart, nEnd, nRowBreak );
 912         SCSIZE nOff = nStart;
 913         SCSIZE nBreak = nOff + nRowBreak;
 914         ScBroadcastAreaSlot** pp = ppSlots + nOff;
 915         while ( nOff <= nEnd )
 916         {
 917             if ( *pp )
 918                 bBroadcasted |= (*pp)->AreaBroadcast( rHint );
 919             ComputeNextSlot( nOff, nBreak, pp, nStart, ppSlots, nRowBreak, mnBcaSlotsCol);
 920         }
 921         return bBroadcasted;
 922     }
 923 }
 924
 925 void ScBroadcastAreaSlotMachine::DelBroadcastAreasInRange(
 926         const ScRange& rRange )
 927 {
 928     SCTAB nEndTab = rRange.aEnd.Tab();
 929     for (TableSlotsMap::iterator iTab( aTableSlotsMap.lower_bound( rRange.aStart.Tab()));
 930             iTab != aTableSlotsMap.end() && (*iTab).first <= nEndTab; ++iTab)
 931     {
 932         ScBroadcastAreaSlot** ppSlots = (*iTab).second.getSlots();
 933         SCSIZE nStart, nEnd, nRowBreak;
 934         ComputeAreaPoints( rRange, nStart, nEnd, nRowBreak );
 935         SCSIZE nOff = nStart;
 936         SCSIZE nBreak = nOff + nRowBreak;
 937         ScBroadcastAreaSlot** pp = ppSlots + nOff;
 938         if (nOff == 0 && nEnd == mnBcaSlots-1)
 939         {
 940             // Slightly optimized for 0,0,MAXCOL,MAXROW calls as they
 941             // happen for insertion and deletion of sheets.
 942             ScBroadcastAreaSlot** const pStop = ppSlots + nEnd;
 943             do
 944             {
 945                 if ( *pp )
 946                     (*pp)->DelBroadcastAreasInRange( rRange );
 947             } while (++pp < pStop);
 948         }
 949         else
 950         {
 951             while ( nOff <= nEnd )
 952             {
 953                 if ( *pp )
 954                     (*pp)->DelBroadcastAreasInRange( rRange );
 955                 ComputeNextSlot( nOff, nBreak, pp, nStart, ppSlots, nRowBreak, mnBcaSlotsCol);
 956             }
 957         }
 958     }
 959 }
 960
 961 // for all affected: remove, chain, update range, insert, and maybe delete
 962 void ScBroadcastAreaSlotMachine::UpdateBroadcastAreas(
 963         UpdateRefMode eUpdateRefMode,
 964         const ScRange& rRange, SCCOL nDx, SCROW nDy, SCTAB nDz )
 965 {
 966     // remove affected and put in chain
 967     SCTAB nEndTab = rRange.aEnd.Tab();
 968     for (TableSlotsMap::iterator iTab( aTableSlotsMap.lower_bound( rRange.aStart.Tab()));
 969             iTab != aTableSlotsMap.end() && (*iTab).first <= nEndTab; ++iTab)
 970     {
 971         ScBroadcastAreaSlot** ppSlots = (*iTab).second.getSlots();
 972         SCSIZE nStart, nEnd, nRowBreak;
 973         ComputeAreaPoints( rRange, nStart, nEnd, nRowBreak );
 974         SCSIZE nOff = nStart;
 975         SCSIZE nBreak = nOff + nRowBreak;
 976         ScBroadcastAreaSlot** pp = ppSlots + nOff;
 977         if (nOff == 0 && nEnd == mnBcaSlots-1)
 978         {
 979             // Slightly optimized for 0,0,MAXCOL,MAXROW calls as they
 980             // happen for insertion and deletion of sheets.
 981             ScBroadcastAreaSlot** const pStop = ppSlots + nEnd;
 982             do
 983             {
 984                 if ( *pp )
 985                     (*pp)->UpdateRemove( eUpdateRefMode, rRange, nDx, nDy, nDz );
 986             } while (++pp < pStop);
 987         }
 988         else
 989         {
 990             while ( nOff <= nEnd )
 991             {
 992                 if ( *pp )
 993                     (*pp)->UpdateRemove( eUpdateRefMode, rRange, nDx, nDy, nDz );
 994                 ComputeNextSlot( nOff, nBreak, pp, nStart, ppSlots, nRowBreak, mnBcaSlotsCol);
 995             }
 996         }
 997     }
 998
 999     // Updating an area's range will modify the hash key, remove areas from all
1000     // affected slots. Will be reinserted later with the updated range.
1001     ScBroadcastArea* pChain = pUpdateChain;
1002     while (pChain)
1003     {
1004         ScBroadcastArea* pArea = pChain;
1005         pChain = pArea->GetUpdateChainNext();
1006         ScRange aRange( pArea->GetRange());
1007         // remove from slots
1008         for (SCTAB nTab = aRange.aStart.Tab(); nTab <= aRange.aEnd.Tab() && pArea->GetRef(); ++nTab)
1009         {
1010             TableSlotsMap::iterator iTab( aTableSlotsMap.find( nTab));
1011             if (iTab == aTableSlotsMap.end())
1012             {
1013                 OSL_FAIL( "UpdateBroadcastAreas: Where's the TableSlot?!?");
1014                 continue;   // for
1015             }
1016             ScBroadcastAreaSlot** ppSlots = (*iTab).second.getSlots();
1017             SCSIZE nStart, nEnd, nRowBreak;
1018             ComputeAreaPoints( aRange, nStart, nEnd, nRowBreak );
1019             SCSIZE nOff = nStart;
1020             SCSIZE nBreak = nOff + nRowBreak;
1021             ScBroadcastAreaSlot** pp = ppSlots + nOff;
1022             while ( nOff <= nEnd && pArea->GetRef() )
1023             {
1024                 if (*pp)
1025                     (*pp)->UpdateRemoveArea( pArea);
1026                 ComputeNextSlot( nOff, nBreak, pp, nStart, ppSlots, nRowBreak, mnBcaSlotsCol);
1027             }
1028         }
1029
1030     }
1031
1032     // shift sheets
1033     if (nDz)
1034     {
1035         if (nDz < 0)
1036         {
1037             TableSlotsMap::iterator iDel( aTableSlotsMap.lower_bound( rRange.aStart.Tab()));
1038             TableSlotsMap::iterator iTab( aTableSlotsMap.lower_bound( rRange.aStart.Tab() - nDz));
1039             // Remove sheets, if any, iDel or/and iTab may as well point to end().
1040             while (iDel != iTab)
1041             {
1042                 iDel = aTableSlotsMap.erase(iDel);
1043             }
1044             // shift remaining down
1045             while (iTab != aTableSlotsMap.end())
1046             {
1047                 SCTAB nTab = (*iTab).first + nDz;
1048                 aTableSlotsMap.emplace(nTab, std::move((*iTab).second));
1049                 iTab = aTableSlotsMap.erase(iTab);
1050             }
1051         }
1052         else
1053         {
1054             TableSlotsMap::iterator iStop( aTableSlotsMap.lower_bound( rRange.aStart.Tab()));
1055             if (iStop != aTableSlotsMap.end())
1056             {
1057                 bool bStopIsBegin = (iStop == aTableSlotsMap.begin());
1058                 if (!bStopIsBegin)
1059                     --iStop;
1060                 TableSlotsMap::iterator iTab( aTableSlotsMap.end());
1061                 --iTab;
1062                 while (iTab != iStop)
1063                 {
1064                     SCTAB nTab = (*iTab).first + nDz;
1065                     aTableSlotsMap.emplace(nTab, std::move((*iTab).second));
1066                     aTableSlotsMap.erase( iTab--);
1067                 }
1068                 // Shift the very first, iTab==iStop in this case.
1069                 if (bStopIsBegin)
1070                 {
1071                     SCTAB nTab = (*iTab).first + nDz;
1072                     aTableSlotsMap.emplace(nTab, std::move((*iTab).second));
1073                     aTableSlotsMap.erase( iStop);
1074                 }
1075             }
1076         }
1077     }
1078
1079     // work off chain
1080     SCCOL nCol1, nCol2, theCol1, theCol2;
1081     SCROW nRow1, nRow2, theRow1, theRow2;
1082     SCTAB nTab1, nTab2, theTab1, theTab2;
1083     rRange.GetVars( nCol1, nRow1, nTab1, nCol2, nRow2, nTab2);
1084     while ( pUpdateChain )
1085     {
1086         ScBroadcastArea* pArea = pUpdateChain;
1087         ScRange aRange( pArea->GetRange());
1088         pUpdateChain = pArea->GetUpdateChainNext();
1089
1090         // update range
1091         aRange.GetVars( theCol1, theRow1, theTab1, theCol2, theRow2, theTab2);
1092         if ( ScRefUpdate::Update( pDoc, eUpdateRefMode,
1093                 nCol1,nRow1,nTab1, nCol2,nRow2,nTab2, nDx,nDy,nDz,
1094                 theCol1,theRow1,theTab1, theCol2,theRow2,theTab2 ))
1095         {
1096             aRange = ScRange( theCol1,theRow1,theTab1, theCol2,theRow2,theTab2 );
1097             pArea->UpdateRange( aRange );
1098             // For DDE and ScLookupCache
1099             pArea->GetBroadcaster().Broadcast( ScAreaChangedHint( aRange ) );
1100         }
1101
1102         // insert to slots
1103         for (SCTAB nTab = aRange.aStart.Tab(); nTab <= aRange.aEnd.Tab(); ++nTab)
1104         {
1105             TableSlotsMap::iterator iTab( aTableSlotsMap.find( nTab));
1106             if (iTab == aTableSlotsMap.end())
1107                 iTab = aTableSlotsMap.emplace( std::piecewise_construct,
1108                         std::forward_as_tuple(nTab), std::forward_as_tuple(mnBcaSlots) ).first;
1109             ScBroadcastAreaSlot** ppSlots = (*iTab).second.getSlots();
1110             SCSIZE nStart, nEnd, nRowBreak;
1111             ComputeAreaPoints( aRange, nStart, nEnd, nRowBreak );
1112             SCSIZE nOff = nStart;
1113             SCSIZE nBreak = nOff + nRowBreak;
1114             ScBroadcastAreaSlot** pp = ppSlots + nOff;
1115             while ( nOff <= nEnd )
1116             {
1117                 if (!*pp)
1118                     *pp = new ScBroadcastAreaSlot( pDoc, this );
1119                 (*pp)->UpdateInsert( pArea );
1120                 ComputeNextSlot( nOff, nBreak, pp, nStart, ppSlots, nRowBreak, mnBcaSlotsCol);
1121             }
1122         }
1123
1124         // unchain
1125         pArea->SetUpdateChainNext( nullptr );
1126         pArea->SetInUpdateChain( false );
1127
1128         // Delete if not inserted to any slot. RemoveBulkArea(pArea) was
1129         // already executed in UpdateRemove().
1130         if (!pArea->GetRef())
1131             delete pArea;
1132     }
1133     pEOUpdateChain = nullptr;
1134 }
1135
1136 void ScBroadcastAreaSlotMachine::EnterBulkBroadcast()
1137 {
1138     ++nInBulkBroadcast;
1139 }
1140
1141 void ScBroadcastAreaSlotMachine::LeaveBulkBroadcast( SfxHintId nHintId )
1142 {
1143     if (nInBulkBroadcast <= 0)
1144         return;
1145
1146     if (--nInBulkBroadcast == 0)
1147     {
1148         ScBroadcastAreasBulk().swap( aBulkBroadcastAreas);
1149         bool bBroadcasted = BulkBroadcastGroupAreas( nHintId );
1150         // Trigger the "final" tracking.
1151         if (pDoc->IsTrackFormulasPending())
1152             pDoc->FinalTrackFormulas( nHintId );
1153         else if (bBroadcasted)
1154             pDoc->TrackFormulas( nHintId );
1155     }
1156 }
1157
1158 bool ScBroadcastAreaSlotMachine::InsertBulkArea( const ScBroadcastArea* pArea )
1159 {
1160     return aBulkBroadcastAreas.insert( pArea ).second;
1161 }
1162
1163 void ScBroadcastAreaSlotMachine::InsertBulkGroupArea( ScBroadcastArea* pArea, const ScRange& rRange )
1164 {
1165     BulkGroupAreasType::iterator it = m_BulkGroupAreas.lower_bound(pArea);
1166     if (it == m_BulkGroupAreas.end() || m_BulkGroupAreas.key_comp()(pArea, it->first))
1167     {
1168         // Insert a new one.
1169         it = m_BulkGroupAreas.insert(it, std::make_pair(pArea, sc::ColumnSpanSet()));
1170     }
1171
1172     sc::ColumnSpanSet& rSet = it->second;
1173     rSet.set(*pDoc, rRange, true);
1174 }
1175
1176 bool ScBroadcastAreaSlotMachine::BulkBroadcastGroupAreas( SfxHintId nHintId )
1177 {
1178     if (m_BulkGroupAreas.empty())
1179         return false;
1180
1181     sc::BulkDataHint aHint( *pDoc, nHintId);
1182
1183     bool bBroadcasted = false;
1184     for (const auto& [pArea, rSpans] : m_BulkGroupAreas)
1185     {
1186         assert(pArea);
1187         SvtBroadcaster& rBC = pArea->GetBroadcaster();
1188         if (!rBC.HasListeners())
1189         {
1190             /* FIXME: find the cause where the last listener is removed and
1191              * this area is still listed here. */
1192             SAL_WARN("sc.core","ScBroadcastAreaSlotMachine::BulkBroadcastGroupAreas - pArea has no listeners and should had been removed already");
1193         }
1194         else
1195         {
1196             aHint.setSpans(&rSpans);
1197             rBC.Broadcast(aHint);
1198             bBroadcasted = true;
1199         }
1200     }
1201
1202     m_BulkGroupAreas.clear();
1203
1204     return bBroadcasted;
1205 }
1206
1207 size_t ScBroadcastAreaSlotMachine::RemoveBulkArea( const ScBroadcastArea* pArea )
1208 {
1209     return aBulkBroadcastAreas.erase( pArea );
1210 }
1211
1212 void ScBroadcastAreaSlotMachine::RemoveBulkGroupArea( ScBroadcastArea* pArea )
1213 {
1214     m_BulkGroupAreas.erase(pArea);
1215 }
1216
1217 void ScBroadcastAreaSlotMachine::PushAreaToBeErased( ScBroadcastAreaSlot* pSlot,
1218         ScBroadcastAreas::iterator& rIter )
1219 {
1220     maAreasToBeErased.emplace_back( pSlot, rIter);
1221 }
1222
1223 void ScBroadcastAreaSlotMachine::FinallyEraseAreas( ScBroadcastAreaSlot* pSlot )
1224 {
1225     SAL_WARN_IF( pSlot->IsInBroadcastIteration(), "sc.core",
1226             "ScBroadcastAreaSlotMachine::FinallyEraseAreas: during iteration? NO!");
1227     if (pSlot->IsInBroadcastIteration())
1228         return;
1229
1230     // maAreasToBeErased is a simple vector so erasing an element may
1231     // invalidate iterators and would be inefficient anyway. Instead, copy
1232     // elements to be preserved (usually none!) to temporary vector and swap.
1233     AreasToBeErased aCopy;
1234     for (auto& rArea : maAreasToBeErased)
1235     {
1236         if (rArea.first == pSlot)
1237             pSlot->EraseArea( rArea.second);
1238         else
1239             aCopy.push_back( rArea);
1240     }
1241     maAreasToBeErased.swap( aCopy);
1242 }
1243
1244 std::vector<sc::AreaListener> ScBroadcastAreaSlotMachine::GetAllListeners(
1245     const ScRange& rRange, sc::AreaOverlapType eType, sc::ListenerGroupType eGroup )
1246 {
1247     std::vector<sc::AreaListener> aRet;
1248
1249     SCTAB nEndTab = rRange.aEnd.Tab();
1250     for (TableSlotsMap::const_iterator iTab( aTableSlotsMap.lower_bound( rRange.aStart.Tab()));
1251             iTab != aTableSlotsMap.end() && (*iTab).first <= nEndTab; ++iTab)
1252     {
1253         ScBroadcastAreaSlot** ppSlots = (*iTab).second.getSlots();
1254         SCSIZE nStart, nEnd, nRowBreak;
1255         ComputeAreaPoints( rRange, nStart, nEnd, nRowBreak );
1256         SCSIZE nOff = nStart;
1257         SCSIZE nBreak = nOff + nRowBreak;
1258         ScBroadcastAreaSlot** pp = ppSlots + nOff;
1259         while ( nOff <= nEnd )
1260         {
1261             ScBroadcastAreaSlot* p = *pp;
1262             if (p)
1263                 p->GetAllListeners(rRange, aRet, eType, eGroup);
1264             ComputeNextSlot( nOff, nBreak, pp, nStart, ppSlots, nRowBreak, mnBcaSlotsCol);
1265         }
1266     }
1267
1268     return aRet;
1269 }
1270
1271 void ScBroadcastAreaSlotMachine::CollectBroadcasterState(sc::BroadcasterState& rState) const
1272 {
1273     for (const auto& [rTab, rTabSlots] : aTableSlotsMap)
1274     {
1275         (void)rTab;
1276
1277         ScBroadcastAreaSlot** pp = rTabSlots.getSlots();
1278         for (SCSIZE i = 0; i < mnBcaSlots; ++i)
1279         {
1280             const ScBroadcastAreaSlot* pSlot = pp[i];
1281             if (pSlot)
1282                 pSlot->CollectBroadcasterState(rState);
1283         }
1284     }
1285 }
1286
1287 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */