sc/source/core/data/olinetab.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 <limits.h>
  21
  22 #include "olinetab.hxx"
  23 #include "global.hxx"
  24 #include "rechead.hxx"
  25 #include "address.hxx"
  26 #include "table.hxx"
  27
  28 #include <osl/diagnose.h>
  29
  30 ScOutlineEntry::ScOutlineEntry( SCCOLROW nNewStart, SCCOLROW nNewSize, bool bNewHidden ) :
  31     nStart  ( nNewStart ),
  32     nSize   ( nNewSize ),
  33     bHidden ( bNewHidden ),
  34     bVisible( true )
  35 {
  36 }
  37
  38 ScOutlineEntry::ScOutlineEntry( const ScOutlineEntry& rEntry ) :
  39     nStart  ( rEntry.nStart ),
  40     nSize   ( rEntry.nSize ),
  41     bHidden ( rEntry.bHidden ),
  42     bVisible( rEntry.bVisible )
  43 {
  44 }
  45
  46 SCCOLROW ScOutlineEntry::GetEnd() const
  47 {
  48     return nStart+nSize-1;
  49 }
  50
  51 void ScOutlineEntry::Move( SCsCOLROW nDelta )
  52 {
  53     SCCOLROW nNewPos = nStart + nDelta;
  54     if (nNewPos<0)
  55     {
  56         OSL_FAIL("OutlineEntry < 0");
  57         nNewPos = 0;
  58     }
  59     nStart = nNewPos;
  60 }
  61
  62 void ScOutlineEntry::SetSize( SCSIZE nNewSize )
  63 {
  64     if (nNewSize>0)
  65         nSize = nNewSize;
  66     else
  67     {
  68         OSL_FAIL("ScOutlineEntry Size == 0");
  69     }
  70 }
  71
  72 void ScOutlineEntry::SetPosSize( SCCOLROW nNewPos, SCSIZE nNewSize )
  73 {
  74     nStart = nNewPos;
  75     SetSize( nNewSize );
  76 }
  77
  78 void ScOutlineEntry::SetHidden( bool bNewHidden )
  79 {
  80     bHidden = bNewHidden;
  81 }
  82
  83 void ScOutlineEntry::SetVisible( bool bNewVisible )
  84 {
  85     bVisible = bNewVisible;
  86 }
  87
  88 ScOutlineCollection::ScOutlineCollection() {}
  89
  90 size_t ScOutlineCollection::size() const
  91 {
  92     return maEntries.size();
  93 }
  94
  95 void ScOutlineCollection::clear()
  96 {
  97     maEntries.clear();
  98 }
  99
 100 void ScOutlineCollection::insert(ScOutlineEntry* pEntry)
 101 {
 102     SCCOLROW nStart = pEntry->GetStart();
 103     maEntries.insert(nStart, pEntry);
 104 }
 105
 106 ScOutlineCollection::iterator ScOutlineCollection::begin()
 107 {
 108     return maEntries.begin();
 109 }
 110
 111 ScOutlineCollection::iterator ScOutlineCollection::end()
 112 {
 113     return maEntries.end();
 114 }
 115
 116 ScOutlineCollection::const_iterator ScOutlineCollection::begin() const
 117 {
 118     return maEntries.begin();
 119 }
 120
 121 ScOutlineCollection::const_iterator ScOutlineCollection::end() const
 122 {
 123     return maEntries.end();
 124 }
 125
 126 void ScOutlineCollection::erase(iterator pos)
 127 {
 128     maEntries.erase(pos);
 129 }
 130
 131 bool ScOutlineCollection::empty() const
 132 {
 133     return maEntries.empty();
 134 }
 135
 136 ScOutlineCollection::iterator ScOutlineCollection::FindStart(SCCOLROW nMinStart)
 137 {
 138     return maEntries.lower_bound(nMinStart);
 139 }
 140
 141 ScOutlineArray::ScOutlineArray() :
 142     nDepth(0) {}
 143
 144 ScOutlineArray::ScOutlineArray( const ScOutlineArray& rArray ) :
 145     nDepth( rArray.nDepth )
 146 {
 147     for (size_t nLevel = 0; nLevel < nDepth; ++nLevel)
 148     {
 149         const ScOutlineCollection& rColl = rArray.aCollections[nLevel];
 150         ScOutlineCollection::const_iterator it = rColl.begin(), itEnd = rColl.end();
 151         for (; it != itEnd; ++it)
 152         {
 153             const ScOutlineEntry* pEntry = it->second;
 154             aCollections[nLevel].insert(new ScOutlineEntry(*pEntry));
 155         }
 156     }
 157 }
 158
 159 void ScOutlineArray::FindEntry(
 160     SCCOLROW nSearchPos, size_t& rFindLevel, size_t& rFindIndex,
 161     size_t nMaxLevel )
 162 {
 163     rFindLevel = rFindIndex = 0;
 164
 165     if (nMaxLevel > nDepth)
 166         nMaxLevel = nDepth;
 167
 168     for (size_t nLevel = 0; nLevel < nMaxLevel; ++nLevel) //TODO: Search backwards?
 169     {
 170         ScOutlineCollection* pCollect = &aCollections[nLevel];
 171         ScOutlineCollection::iterator it = pCollect->begin(), itEnd = pCollect->end();
 172         for (; it != itEnd; ++it)
 173         {
 174             ScOutlineEntry* pEntry = it->second;
 175             if (pEntry->GetStart() <= nSearchPos && pEntry->GetEnd() >= nSearchPos)
 176             {
 177                 rFindLevel = nLevel + 1; // Next Level (for insertion)
 178                 rFindIndex = std::distance(pCollect->begin(), it);
 179             }
 180         }
 181     }
 182 }
 183
 184 bool ScOutlineArray::Insert(
 185     SCCOLROW nStartCol, SCCOLROW nEndCol, bool& rSizeChanged, bool bHidden, bool bVisible )
 186 {
 187     rSizeChanged = false;
 188
 189     size_t nStartLevel, nEndLevel, nStartIndex, nEndIndex;
 190     bool bFound = false;
 191
 192     bool bCont;
 193     sal_uInt16 nFindMax;
 194     FindEntry( nStartCol, nStartLevel, nStartIndex ); // nLevel = new Level (old+1)
 195     FindEntry( nEndCol, nEndLevel, nEndIndex );
 196     nFindMax = std::max(nStartLevel,nEndLevel);
 197     do
 198     {
 199         bCont = false;
 200
 201         if (nStartLevel == nEndLevel && nStartIndex == nEndIndex && nStartLevel < SC_OL_MAXDEPTH)
 202             bFound = true;
 203
 204         if (!bFound)
 205         {
 206             if (nFindMax>0)
 207             {
 208                 --nFindMax;
 209                 if (nStartLevel)
 210                 {
 211                     ScOutlineCollection::const_iterator it = aCollections[nStartLevel-1].begin();
 212                     std::advance(it, nStartIndex);
 213                     if (it->second->GetStart() == nStartCol)
 214                         FindEntry(nStartCol, nStartLevel, nStartIndex, nFindMax);
 215                 }
 216
 217                 if (nEndLevel)
 218                 {
 219                     ScOutlineCollection::const_iterator it = aCollections[nEndLevel-1].begin();
 220                     std::advance(it, nEndIndex);
 221                     if (it->second->GetEnd() == nEndCol)
 222                         FindEntry(nEndCol, nEndLevel, nEndIndex, nFindMax);
 223                 }
 224                 bCont = true;
 225             }
 226         }
 227     }
 228     while ( !bFound && bCont );
 229
 230     if (!bFound)
 231         return false;
 232
 233     size_t nLevel = nStartLevel;
 234
 235     // Move the ones underneath
 236     bool bNeedSize = false;
 237     if (nDepth > 0)
 238     {
 239         for (size_t nMoveLevel = nDepth-1; nMoveLevel >= nLevel; --nMoveLevel)
 240         {
 241             ScOutlineCollection& rColl = aCollections[nMoveLevel];
 242             ScOutlineCollection::iterator it = rColl.begin(), itEnd = rColl.end();
 243             while (it != itEnd)
 244             {
 245                 ScOutlineEntry* pEntry = it->second;
 246                 SCCOLROW nEntryStart = pEntry->GetStart();
 247                 if (nEntryStart >= nStartCol && nEntryStart <= nEndCol)
 248                 {
 249                     if (nMoveLevel >= SC_OL_MAXDEPTH - 1)
 250                     {
 251                         rSizeChanged = false; // No more room
 252                         return false;
 253                     }
 254                     aCollections[nMoveLevel+1].insert(new ScOutlineEntry(*pEntry));
 255                     size_t nPos = std::distance(rColl.begin(), it);
 256                     rColl.erase(it);
 257                     it = rColl.begin();
 258                     std::advance(it, nPos);
 259                     itEnd = rColl.end();
 260                     if (nMoveLevel == nDepth - 1)
 261                         bNeedSize = true;
 262                 }
 263                 else
 264                     ++it;
 265             }
 266             if (nMoveLevel == 0)
 267                 break;
 268         }
 269     }
 270
 271     if (bNeedSize)
 272     {
 273         ++nDepth;
 274         rSizeChanged = true;
 275     }
 276
 277     if (nDepth <= nLevel)
 278     {
 279         nDepth = nLevel+1;
 280         rSizeChanged = true;
 281     }
 282
 283     ScOutlineEntry* pNewEntry = new ScOutlineEntry( nStartCol, nEndCol+1-nStartCol, bHidden );
 284     pNewEntry->SetVisible( bVisible );
 285     aCollections[nLevel].insert(pNewEntry);
 286
 287     return true;
 288 }
 289
 290 bool ScOutlineArray::FindTouchedLevel(
 291     SCCOLROW nBlockStart, SCCOLROW nBlockEnd, size_t& rFindLevel) const
 292 {
 293     bool bFound = false;
 294     rFindLevel = 0;
 295
 296     for (size_t nLevel = 0; nLevel < nDepth; ++nLevel)
 297     {
 298         const ScOutlineCollection* pCollect = &aCollections[nLevel];
 299         ScOutlineCollection::const_iterator it = pCollect->begin(), itEnd = pCollect->end();
 300         for (; it != itEnd; ++it)
 301         {
 302             const ScOutlineEntry* pEntry = it->second;
 303             SCCOLROW nStart = pEntry->GetStart();
 304             SCCOLROW nEnd   = pEntry->GetEnd();
 305
 306             if ( ( nBlockStart>=nStart && nBlockStart<=nEnd ) ||
 307                  ( nBlockEnd  >=nStart && nBlockEnd  <=nEnd ) )
 308             {
 309                 rFindLevel = nLevel; // Actual Level
 310                 bFound = true;
 311             }
 312         }
 313     }
 314
 315     return bFound;
 316 }
 317
 318 void ScOutlineArray::RemoveSub(SCCOLROW nStartPos, SCCOLROW nEndPos, size_t nLevel)
 319 {
 320     if ( nLevel >= nDepth )
 321         return;
 322
 323     ScOutlineCollection& rColl = aCollections[nLevel];
 324
 325     ScOutlineCollection::iterator it = rColl.begin(), itEnd = rColl.end();
 326     while (it != itEnd)
 327     {
 328         ScOutlineEntry* pEntry = it->second;
 329         SCCOLROW nStart = pEntry->GetStart();
 330         SCCOLROW nEnd   = pEntry->GetEnd();
 331         if (nStart >= nStartPos && nEnd <= nEndPos)
 332         {
 333             // Overlaps
 334             RemoveSub( nStart, nEnd, nLevel+1 );
 335
 336             // Re-calc iterator positions after the tree gets invalidated
 337             size_t nPos = std::distance(rColl.begin(), it);
 338             rColl.erase(it);
 339             it = rColl.begin();
 340             std::advance(it, nPos);
 341             itEnd = rColl.end();
 342         }
 343         else
 344             ++it;
 345     }
 346
 347     it = rColl.begin();
 348     itEnd = rColl.end();
 349
 350     while (it != itEnd)
 351     {
 352         ScOutlineEntry* pEntry = it->second;
 353         SCCOLROW nStart = pEntry->GetStart();
 354         SCCOLROW nEnd   = pEntry->GetEnd();
 355
 356         if (nStart >= nStartPos && nEnd <= nEndPos)
 357         {
 358             RemoveSub( nStart, nEnd, nLevel+1 );
 359
 360             // Re-calc iterator positions after the tree gets invalidated
 361             size_t nPos = std::distance(rColl.begin(), it);
 362             rColl.erase(it);
 363             it = rColl.begin();
 364             std::advance(it, nPos);
 365             itEnd = rColl.end();
 366         }
 367         else
 368             ++it;
 369     }
 370 }
 371
 372 void ScOutlineArray::PromoteSub(SCCOLROW nStartPos, SCCOLROW nEndPos, size_t nStartLevel)
 373 {
 374     if (nStartLevel==0)
 375     {
 376         OSL_FAIL("PromoteSub with Level 0");
 377         return;
 378     }
 379
 380     for (size_t nLevel = nStartLevel; nLevel < nDepth; ++nLevel)
 381     {
 382         ScOutlineCollection& rColl = aCollections[nLevel];
 383         ScOutlineCollection::iterator it = rColl.begin(), itEnd = rColl.end();
 384         while (it != itEnd)
 385         {
 386             ScOutlineEntry* pEntry = it->second;
 387             SCCOLROW nStart = pEntry->GetStart();
 388             SCCOLROW nEnd   = pEntry->GetEnd();
 389             if (nStart >= nStartPos && nEnd <= nEndPos)
 390             {
 391                 aCollections[nLevel-1].insert(new ScOutlineEntry(*pEntry));
 392
 393                 // Re-calc iterator positions after the tree gets invalidated
 394                 size_t nPos = std::distance(rColl.begin(), it);
 395                 rColl.erase(it);
 396                 it = rColl.begin();
 397                 std::advance(it, nPos);
 398                 itEnd = rColl.end();
 399             }
 400             else
 401                 ++it;
 402         }
 403
 404         it = rColl.begin();
 405         itEnd = rColl.end();
 406
 407         while (it != itEnd)
 408         {
 409             ScOutlineEntry* pEntry = it->second;
 410             SCCOLROW nStart = pEntry->GetStart();
 411             SCCOLROW nEnd   = pEntry->GetEnd();
 412             if (nStart >= nStartPos && nEnd <= nEndPos)
 413             {
 414                 aCollections[nLevel-1].insert(new ScOutlineEntry(*pEntry));
 415
 416                 // Re-calc iterator positions after the tree gets invalidated
 417                 size_t nPos = std::distance(rColl.begin(), it);
 418                 rColl.erase(it);
 419                 it = rColl.begin();
 420                 std::advance(it, nPos);
 421                 itEnd = rColl.end();
 422             }
 423             else
 424                 ++it;
 425         }
 426     }
 427 }
 428
 429 /**
 430  * Adapt nDepth for empty Levels
 431  */
 432 bool ScOutlineArray::DecDepth()
 433 {
 434     bool bChanged = false;
 435     bool bCont;
 436     do
 437     {
 438         bCont = false;
 439         if (nDepth)
 440         {
 441             if (aCollections[nDepth-1].empty())
 442             {
 443                 --nDepth;
 444                 bChanged = true;
 445                 bCont = true;
 446             }
 447         }
 448     }
 449     while (bCont);
 450
 451     return bChanged;
 452 }
 453
 454 bool ScOutlineArray::Remove( SCCOLROW nBlockStart, SCCOLROW nBlockEnd, bool& rSizeChanged )
 455 {
 456     size_t nLevel;
 457     FindTouchedLevel( nBlockStart, nBlockEnd, nLevel );
 458
 459     ScOutlineCollection* pCollect = &aCollections[nLevel];
 460     ScOutlineCollection::iterator it = pCollect->begin(), itEnd = pCollect->end();
 461     bool bAny = false;
 462     while (it != itEnd)
 463     {
 464         ScOutlineEntry* pEntry = it->second;
 465         SCCOLROW nStart = pEntry->GetStart();
 466         SCCOLROW nEnd   = pEntry->GetEnd();
 467         if (nBlockStart <= nEnd && nBlockEnd >= nStart)
 468         {
 469             // Overlaps
 470             pCollect->erase(it);
 471             PromoteSub( nStart, nEnd, nLevel+1 );
 472             itEnd = pCollect->end();
 473             it = pCollect->FindStart( nEnd+1 );
 474             bAny = true;
 475         }
 476         else
 477             ++it;
 478     }
 479
 480     if (bAny) // Adapt Depth
 481         if (DecDepth())
 482             rSizeChanged = true;
 483
 484     return bAny;
 485 }
 486
 487 ScOutlineEntry* ScOutlineArray::GetEntry(size_t nLevel, size_t nIndex)
 488 {
 489     if (nLevel >= nDepth)
 490         return NULL;
 491
 492     ScOutlineCollection& rColl = aCollections[nLevel];
 493     if (nIndex >= rColl.size())
 494         return NULL;
 495
 496     ScOutlineCollection::iterator it = rColl.begin();
 497     std::advance(it, nIndex);
 498     return it->second;
 499 }
 500
 501 const ScOutlineEntry* ScOutlineArray::GetEntry(size_t nLevel, size_t nIndex) const
 502 {
 503     if (nLevel >= nDepth)
 504         return NULL;
 505
 506     const ScOutlineCollection& rColl = aCollections[nLevel];
 507     if (nIndex >= rColl.size())
 508         return NULL;
 509
 510     ScOutlineCollection::const_iterator it = rColl.begin();
 511     std::advance(it, nIndex);
 512     return it->second;
 513 }
 514
 515 size_t ScOutlineArray::GetCount(size_t nLevel) const
 516 {
 517     if (nLevel >= nDepth)
 518         return 0;
 519
 520     return aCollections[nLevel].size();
 521 }
 522
 523 const ScOutlineEntry* ScOutlineArray::GetEntryByPos(size_t nLevel, SCCOLROW nPos) const
 524 {
 525     if (nLevel >= nDepth)
 526         return NULL;
 527
 528     const ScOutlineCollection& rColl = aCollections[nLevel];
 529     ScOutlineCollection::const_iterator it = rColl.begin(), itEnd = rColl.end();
 530     for (; it != itEnd; ++it)
 531     {
 532         const ScOutlineEntry* pEntry = it->second;
 533         if (pEntry->GetStart() <= nPos && nPos <= pEntry->GetEnd())
 534             return pEntry;
 535     }
 536
 537     return NULL;
 538 }
 539
 540 bool ScOutlineArray::GetEntryIndex(size_t nLevel, SCCOLROW nPos, size_t& rnIndex) const
 541 {
 542     if (nLevel >= nDepth)
 543         return false;
 544
 545     // Found entry contains passed position
 546     const ScOutlineCollection& rColl = aCollections[nLevel];
 547     ScOutlineCollection::const_iterator it = rColl.begin(), itEnd = rColl.end();
 548     for (; it != itEnd; ++it)
 549     {
 550         const ScOutlineEntry* p = it->second;
 551         if (p->GetStart() <= nPos && nPos <= p->GetEnd())
 552         {
 553             rnIndex = std::distance(rColl.begin(), it);
 554             return true;
 555         }
 556     }
 557     return false;
 558 }
 559
 560 bool ScOutlineArray::GetEntryIndexInRange(
 561     size_t nLevel, SCCOLROW nBlockStart, SCCOLROW nBlockEnd, size_t& rnIndex) const
 562 {
 563     if (nLevel >= nDepth)
 564         return false;
 565
 566     // Found entry will be completely inside of passed range
 567     const ScOutlineCollection& rColl = aCollections[nLevel];
 568     ScOutlineCollection::const_iterator it = rColl.begin(), itEnd = rColl.end();
 569     for (; it != itEnd; ++it)
 570     {
 571         const ScOutlineEntry* p = it->second;
 572         if (nBlockStart <= p->GetStart() && p->GetEnd() <= nBlockEnd)
 573         {
 574             rnIndex = std::distance(rColl.begin(), it);
 575             return true;
 576         }
 577     }
 578     return false;
 579 }
 580
 581 void ScOutlineArray::SetVisibleBelow(
 582     size_t nLevel, size_t nEntry, bool bValue, bool bSkipHidden)
 583 {
 584     const ScOutlineEntry* pEntry = GetEntry( nLevel, nEntry );
 585     if (!pEntry)
 586         return;
 587
 588     SCCOLROW nStart = pEntry->GetStart();
 589     SCCOLROW nEnd   = pEntry->GetEnd();
 590
 591     for (size_t nSubLevel = nLevel+1; nSubLevel < nDepth; ++nSubLevel)
 592     {
 593         ScOutlineCollection& rColl = aCollections[nSubLevel];
 594         ScOutlineCollection::iterator it = rColl.begin(), itEnd = rColl.end();
 595         for (; it != itEnd; ++it)
 596         {
 597             ScOutlineEntry* p = it->second;
 598             if (p->GetStart() >= nStart && p->GetEnd() <= nEnd)
 599             {
 600                 p->SetVisible(bValue);
 601                 if (bSkipHidden && !p->IsHidden())
 602                 {
 603                     size_t nPos = std::distance(rColl.begin(), it);
 604                     SetVisibleBelow(nSubLevel, nPos, bValue, true);
 605                 }
 606             }
 607         }
 608
 609         if (bSkipHidden)
 610             nSubLevel = nDepth; // Bail out
 611     }
 612 }
 613
 614 void ScOutlineArray::GetRange(SCCOLROW& rStart, SCCOLROW& rEnd) const
 615 {
 616     const ScOutlineCollection& rColl = aCollections[0];
 617     if (!rColl.empty())
 618     {
 619         ScOutlineCollection::const_iterator it = rColl.begin();
 620         rStart = it->second->GetStart();
 621         std::advance(it, rColl.size()-1);
 622         rEnd = it->second->GetEnd();
 623     }
 624     else
 625         rStart = rEnd = 0;
 626 }
 627
 628 void ScOutlineArray::ExtendBlock(size_t nLevel, SCCOLROW& rBlkStart, SCCOLROW& rBlkEnd)
 629 {
 630     if (nLevel >= nDepth)
 631         return;
 632
 633     const ScOutlineCollection& rColl = aCollections[nLevel];
 634     ScOutlineCollection::const_iterator it = rColl.begin(), itEnd = rColl.end();
 635     for (; it != itEnd; ++it)
 636     {
 637         const ScOutlineEntry* pEntry = it->second;
 638         SCCOLROW nStart = pEntry->GetStart();
 639         SCCOLROW nEnd   = pEntry->GetEnd();
 640
 641         if (rBlkStart <= nEnd && rBlkEnd >= nStart)
 642         {
 643             if (nStart < rBlkStart)
 644                 rBlkStart = nStart;
 645             if (nEnd > rBlkEnd)
 646                 rBlkEnd = nEnd;
 647         }
 648     }
 649 }
 650
 651 bool ScOutlineArray::TestInsertSpace(SCSIZE nSize, SCCOLROW nMaxVal) const
 652 {
 653     const ScOutlineCollection& rColl = aCollections[0];
 654     if (rColl.empty())
 655         return true;
 656
 657     ScOutlineCollection::const_iterator it = rColl.begin();
 658     std::advance(it, rColl.size()-1);
 659     SCCOLROW nEnd = it->second->GetEnd();
 660     return sal::static_int_cast<SCCOLROW>(nEnd+nSize) <= nMaxVal;
 661 }
 662
 663 void ScOutlineArray::InsertSpace(SCCOLROW nStartPos, SCSIZE nSize)
 664 {
 665     ScSubOutlineIterator aIter( this );
 666     ScOutlineEntry* pEntry;
 667     while ((pEntry = aIter.GetNext()) != NULL)
 668     {
 669         if ( pEntry->GetStart() >= nStartPos )
 670             pEntry->Move(static_cast<SCsCOLROW>(nSize));
 671         else
 672         {
 673             SCCOLROW nEnd = pEntry->GetEnd();
 674             // Always expand if inserted within the group
 675             // When inserting at the end, only if the group is not hidden
 676             if ( nEnd >= nStartPos || ( nEnd+1 >= nStartPos && !pEntry->IsHidden() ) )
 677             {
 678                 SCSIZE nEntrySize = pEntry->GetSize();
 679                 nEntrySize += nSize;
 680                 pEntry->SetSize( nEntrySize );
 681             }
 682         }
 683     }
 684 }
 685
 686 bool ScOutlineArray::DeleteSpace(SCCOLROW nStartPos, SCSIZE nSize)
 687 {
 688     SCCOLROW nEndPos = nStartPos + nSize - 1;
 689     bool bNeedSave = false; // Do we need the original one for Undo?
 690     bool bChanged = false; // For Level test
 691
 692     ScSubOutlineIterator aIter( this );
 693     ScOutlineEntry* pEntry;
 694     while((pEntry=aIter.GetNext())!=NULL)
 695     {
 696         SCCOLROW nEntryStart = pEntry->GetStart();
 697         SCCOLROW nEntryEnd   = pEntry->GetEnd();
 698         SCSIZE nEntrySize    = pEntry->GetSize();
 699
 700         if ( nEntryEnd >= nStartPos )
 701         {
 702             if ( nEntryStart > nEndPos ) // Right
 703                 pEntry->Move(-(static_cast<SCsCOLROW>(nSize)));
 704             else if ( nEntryStart < nStartPos && nEntryEnd >= nEndPos ) // Outside
 705                 pEntry->SetSize( nEntrySize-nSize );
 706             else
 707             {
 708                 bNeedSave = true;
 709                 if ( nEntryStart >= nStartPos && nEntryEnd <= nEndPos ) // Inside
 710                 {
 711                     aIter.DeleteLast();
 712                     bChanged = true;
 713                 }
 714                 else if ( nEntryStart >= nStartPos ) // Top right
 715                     pEntry->SetPosSize( nStartPos, static_cast<SCSIZE>(nEntryEnd-nEndPos) );
 716                 else // Top left
 717                     pEntry->SetSize( static_cast<SCSIZE>(nStartPos-nEntryStart) );
 718             }
 719         }
 720     }
 721
 722     if (bChanged)
 723         DecDepth();
 724
 725     return bNeedSave;
 726 }
 727
 728 bool ScOutlineArray::ManualAction(
 729     SCCOLROW nStartPos, SCCOLROW nEndPos, bool bShow, const ScTable& rTable, bool bCol)
 730 {
 731     bool bModified = false;
 732     ScSubOutlineIterator aIter( this );
 733     ScOutlineEntry* pEntry;
 734     while((pEntry=aIter.GetNext())!=NULL)
 735     {
 736         SCCOLROW nEntryStart = pEntry->GetStart();
 737         SCCOLROW nEntryEnd   = pEntry->GetEnd();
 738
 739         if (nEntryEnd>=nStartPos && nEntryStart<=nEndPos)
 740         {
 741             if ( pEntry->IsHidden() == bShow )
 742             {
 743                 // #i12341# hide if all columns/rows are hidden, show if at least one
 744                 // is visible
 745                 SCCOLROW nEnd = rTable.LastHiddenColRow(nEntryStart, bCol);
 746                 bool bAllHidden = (nEntryEnd <= nEnd && nEnd <
 747                         ::std::numeric_limits<SCCOLROW>::max());
 748
 749                 bool bToggle = ( bShow != bAllHidden );
 750                 if ( bToggle )
 751                 {
 752                     pEntry->SetHidden( !bShow );
 753                     SetVisibleBelow( aIter.LastLevel(), aIter.LastEntry(), bShow, bShow );
 754                     bModified = true;
 755                 }
 756             }
 757         }
 758     }
 759     return bModified;
 760 }
 761
 762 void ScOutlineArray::RemoveAll()
 763 {
 764     for (size_t nLevel = 0; nLevel < nDepth; ++nLevel)
 765         aCollections[nLevel].clear();
 766
 767     nDepth = 0;
 768 }
 769
 770 ScOutlineTable::ScOutlineTable()
 771 {
 772 }
 773
 774 ScOutlineTable::ScOutlineTable( const ScOutlineTable& rOutline ) :
 775     aColOutline( rOutline.aColOutline ),
 776     aRowOutline( rOutline.aRowOutline )
 777 {
 778 }
 779
 780 bool ScOutlineTable::TestInsertCol( SCSIZE nSize )
 781 {
 782     return aColOutline.TestInsertSpace( nSize, MAXCOL );
 783 }
 784
 785 void ScOutlineTable::InsertCol( SCCOL nStartCol, SCSIZE nSize )
 786 {
 787     aColOutline.InsertSpace( nStartCol, nSize );
 788 }
 789
 790 bool ScOutlineTable::DeleteCol( SCCOL nStartCol, SCSIZE nSize )
 791 {
 792     return aColOutline.DeleteSpace( nStartCol, nSize );
 793 }
 794
 795 bool ScOutlineTable::TestInsertRow( SCSIZE nSize )
 796 {
 797     return aRowOutline.TestInsertSpace( nSize, MAXROW );
 798 }
 799
 800 void ScOutlineTable::InsertRow( SCROW nStartRow, SCSIZE nSize )
 801 {
 802     aRowOutline.InsertSpace( nStartRow, nSize );
 803 }
 804
 805 bool ScOutlineTable::DeleteRow( SCROW nStartRow, SCSIZE nSize )
 806 {
 807     return aRowOutline.DeleteSpace( nStartRow, nSize );
 808 }
 809
 810 ScSubOutlineIterator::ScSubOutlineIterator( ScOutlineArray* pOutlineArray ) :
 811         pArray( pOutlineArray ),
 812         nStart( 0 ),
 813         nEnd( SCCOLROW_MAX ), // Iterate over all of them
 814         nSubLevel( 0 ),
 815         nSubEntry( 0 )
 816 {
 817     nDepth = pArray->nDepth;
 818 }
 819
 820 ScSubOutlineIterator::ScSubOutlineIterator(
 821     ScOutlineArray* pOutlineArray, size_t nLevel, size_t nEntry ) :
 822         pArray( pOutlineArray )
 823 {
 824     const ScOutlineCollection& rColl = pArray->aCollections[nLevel];
 825     ScOutlineCollection::const_iterator it = rColl.begin();
 826     std::advance(it, nEntry);
 827     const ScOutlineEntry* pEntry = it->second;
 828     nStart = pEntry->GetStart();
 829     nEnd   = pEntry->GetEnd();
 830     nSubLevel = nLevel + 1;
 831     nSubEntry = 0;
 832     nDepth = pArray->nDepth;
 833 }
 834
 835 ScOutlineEntry* ScSubOutlineIterator::GetNext()
 836 {
 837     ScOutlineEntry* pEntry = NULL;
 838     bool bFound = false;
 839     do
 840     {
 841         if (nSubLevel >= nDepth)
 842             return NULL;
 843
 844         ScOutlineCollection& rColl = pArray->aCollections[nSubLevel];
 845         if (nSubEntry < rColl.size())
 846         {
 847             ScOutlineCollection::iterator it = rColl.begin();
 848             std::advance(it, nSubEntry);
 849             pEntry = it->second;
 850
 851             if (pEntry->GetStart() >= nStart && pEntry->GetEnd() <= nEnd)
 852                 bFound = true;
 853
 854             ++nSubEntry;
 855         }
 856         else
 857         {
 858             // Go to the next sub-level
 859             nSubEntry = 0;
 860             ++nSubLevel;
 861         }
 862     }
 863     while (!bFound);
 864     return pEntry; // nSubLevel valid, if pEntry != 0
 865 }
 866
 867 size_t ScSubOutlineIterator::LastEntry() const
 868 {
 869     if (nSubEntry == 0)
 870     {
 871         OSL_FAIL("ScSubOutlineIterator::LastEntry before GetNext");
 872         return 0;
 873     }
 874     return nSubEntry-1;
 875 }
 876
 877 void ScSubOutlineIterator::DeleteLast()
 878 {
 879     if (nSubLevel >= nDepth)
 880     {
 881         OSL_FAIL("ScSubOutlineIterator::DeleteLast after End");
 882         return;
 883     }
 884     if (nSubEntry == 0)
 885     {
 886         OSL_FAIL("ScSubOutlineIterator::DeleteLast before GetNext");
 887         return;
 888     }
 889
 890     --nSubEntry;
 891     ScOutlineCollection& rColl = pArray->aCollections[nSubLevel];
 892     OSL_ASSERT(nSubEntry < rColl.size());
 893     ScOutlineCollection::iterator it = rColl.begin();
 894     std::advance(it, nSubEntry);
 895     rColl.erase(it);
 896 }
 897
 898 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */