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