sc/source/core/data/olinetab.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: olinetab.cxx,v $
  10  * $Revision: 1.10.32.3 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_sc.hxx"
  33
  34 // System - Includes -----------------------------------------------------
  35
  36
  37
  38 #include <tools/debug.hxx>
  39 #include <limits.h>
  40
  41 // INCLUDE ---------------------------------------------------------------
  42
  43 #include "olinetab.hxx"
  44 #include "global.hxx"
  45 #include "rechead.hxx"
  46 #include "address.hxx"
  47 #include "table.hxx"
  48
  49 //------------------------------------------------------------------------
  50
  51 ScOutlineEntry::ScOutlineEntry( SCCOLROW nNewStart, SCCOLROW nNewSize, BOOL bNewHidden ) :
  52     nStart      ( nNewStart ),
  53     nSize       ( nNewSize ),
  54     bHidden     ( bNewHidden ),
  55     bVisible( TRUE )
  56 {
  57 }
  58
  59 ScOutlineEntry::ScOutlineEntry( const ScOutlineEntry& rEntry ) :
  60     ScDataObject(),
  61     nStart      ( rEntry.nStart ),
  62     nSize       ( rEntry.nSize ),
  63     bHidden     ( rEntry.bHidden ),
  64     bVisible( rEntry.bVisible )
  65 {
  66 }
  67
  68 ScDataObject* ScOutlineEntry::Clone() const
  69 {
  70     return new ScOutlineEntry( *this );
  71 }
  72
  73 void ScOutlineEntry::Move( SCsCOLROW nDelta )
  74 {
  75     SCCOLROW nNewPos = nStart + nDelta;
  76     if (nNewPos<0)
  77     {
  78         DBG_ERROR("OutlineEntry < 0");
  79         nNewPos = 0;
  80     }
  81     nStart = nNewPos;
  82 }
  83
  84 void ScOutlineEntry::SetSize( SCSIZE nNewSize )
  85 {
  86     if (nNewSize>0)
  87         nSize = nNewSize;
  88     else
  89     {
  90         DBG_ERROR("ScOutlineEntry Size == 0");
  91     }
  92 }
  93
  94 void ScOutlineEntry::SetPosSize( SCCOLROW nNewPos, SCSIZE nNewSize )
  95 {
  96     nStart = nNewPos;
  97     SetSize( nNewSize );
  98 }
  99
 100 void ScOutlineEntry::SetHidden( BOOL bNewHidden )
 101 {
 102     bHidden = bNewHidden;
 103 }
 104
 105 void ScOutlineEntry::SetVisible( BOOL bNewVisible )
 106 {
 107     bVisible = bNewVisible;
 108 }
 109
 110 //------------------------------------------------------------------------
 111
 112 ScOutlineCollection::ScOutlineCollection() :
 113     ScSortedCollection( 4,4,FALSE )
 114 {
 115 }
 116
 117 inline short IntCompare( SCCOLROW nX, SCCOLROW nY )
 118 {
 119     if ( nX==nY ) return 0;
 120     else if ( nX<nY ) return -1;
 121     else return 1;
 122 }
 123
 124 short ScOutlineCollection::Compare(ScDataObject* pKey1, ScDataObject* pKey2) const
 125 {
 126     return IntCompare( ((ScOutlineEntry*)pKey1)->GetStart(),
 127                         ((ScOutlineEntry*)pKey2)->GetStart() );
 128 }
 129
 130 USHORT ScOutlineCollection::FindStart( SCCOLROW nMinStart )
 131 {
 132     //!                                 binaer suchen ?
 133
 134     USHORT nPos = 0;
 135     USHORT nLocalCount = GetCount();
 136     while ( (nPos<nLocalCount) ? (((ScOutlineEntry*)At(nPos))->GetStart() < nMinStart) : FALSE )
 137         ++nPos;
 138
 139     return nPos;
 140 }
 141
 142 //------------------------------------------------------------------------
 143
 144 ScOutlineArray::ScOutlineArray() :
 145     nDepth( 0 )
 146 {
 147 }
 148
 149 ScOutlineArray::ScOutlineArray( const ScOutlineArray& rArray ) :
 150     nDepth( rArray.nDepth )
 151 {
 152     for (USHORT nLevel=0; nLevel<nDepth; nLevel++)
 153     {
 154         USHORT nCount = rArray.aCollections[nLevel].GetCount();
 155         for (USHORT nEntry=0; nEntry<nCount; nEntry++)
 156         {
 157             ScOutlineEntry* pEntry = (ScOutlineEntry*) rArray.aCollections[nLevel].At(nEntry);
 158             aCollections[nLevel].Insert( new ScOutlineEntry( *pEntry ) );
 159         }
 160     }
 161 }
 162
 163 void ScOutlineArray::FindEntry( SCCOLROW nSearchPos, USHORT& rFindLevel, USHORT& rFindIndex,
 164                                 USHORT nMaxLevel )
 165 {
 166     rFindLevel = rFindIndex = 0;
 167
 168     if (nMaxLevel > nDepth)
 169         nMaxLevel = nDepth;
 170
 171     for (USHORT nLevel=0; nLevel<nMaxLevel; nLevel++)                           //! rueckwaerts suchen ?
 172     {
 173         ScOutlineCollection* pCollect = &aCollections[nLevel];
 174         USHORT nCount = pCollect->GetCount();
 175         for (USHORT i=0; i<nCount; i++)
 176         {
 177             ScOutlineEntry* pEntry = (ScOutlineEntry*) pCollect->At(i);
 178             if ( pEntry->GetStart() <= nSearchPos && pEntry->GetEnd() >= nSearchPos )
 179             {
 180                 rFindLevel = nLevel + 1;                        // naechster Level (zum Einfuegen)
 181                 rFindIndex = i;
 182             }
 183         }
 184     }
 185 }
 186
 187 BOOL ScOutlineArray::Insert( SCCOLROW nStartCol, SCCOLROW nEndCol, BOOL& rSizeChanged,
 188                                 BOOL bHidden, BOOL bVisible )
 189 {
 190     rSizeChanged = FALSE;
 191
 192     USHORT nStartLevel;
 193     USHORT nStartIndex;
 194     USHORT nEndLevel;
 195     USHORT nEndIndex;
 196     BOOL bFound = FALSE;
 197
 198     BOOL bCont;
 199     USHORT nFindMax;
 200     FindEntry( nStartCol, nStartLevel, nStartIndex );           // nLevel = neuer Level (alter+1) !!!
 201     FindEntry( nEndCol, nEndLevel, nEndIndex );
 202     nFindMax = Max(nStartLevel,nEndLevel);
 203     do
 204     {
 205         bCont = FALSE;
 206
 207         if ( nStartLevel == nEndLevel && nStartIndex == nEndIndex && nStartLevel < SC_OL_MAXDEPTH )
 208             bFound = TRUE;
 209
 210         if (!bFound)
 211         {
 212             if (nFindMax>0)
 213             {
 214                 --nFindMax;
 215                 if (nStartLevel)
 216                     if ( ((ScOutlineEntry*)aCollections[nStartLevel-1].At(nStartIndex))->
 217                                 GetStart() == nStartCol )
 218                         FindEntry( nStartCol, nStartLevel, nStartIndex, nFindMax );
 219                 if (nEndLevel)
 220                     if ( ((ScOutlineEntry*)aCollections[nEndLevel-1].At(nEndIndex))->
 221                                 GetEnd() == nEndCol )
 222                         FindEntry( nEndCol, nEndLevel, nEndIndex, nFindMax );
 223                 bCont = TRUE;
 224             }
 225         }
 226     }
 227     while ( !bFound && bCont );
 228
 229     if (!bFound)
 230         return FALSE;
 231
 232     USHORT nLevel = nStartLevel;
 233
 234     //  untere verschieben
 235
 236     BOOL bNeedSize = FALSE;
 237     for ( short nMoveLevel = nDepth-1; nMoveLevel >= (short) nLevel; nMoveLevel-- )
 238     {
 239         USHORT nCount = aCollections[nMoveLevel].GetCount();
 240         BOOL bMoved = FALSE;
 241         for ( USHORT i=0; i<nCount; i += bMoved ? 0 : 1 )
 242         {
 243             ScOutlineEntry* pEntry = (ScOutlineEntry*) aCollections[nMoveLevel].At(i);
 244             SCCOLROW nEntryStart = pEntry->GetStart();
 245             if ( nEntryStart >= nStartCol && nEntryStart <= nEndCol )
 246             {
 247                 if (nMoveLevel >= SC_OL_MAXDEPTH - 1)
 248                 {
 249                     rSizeChanged = FALSE;                               // kein Platz
 250                     return FALSE;
 251                 }
 252                 aCollections[nMoveLevel+1].Insert( new ScOutlineEntry( *pEntry ) );
 253                 aCollections[nMoveLevel].AtFree( i );
 254                 nCount = aCollections[nMoveLevel].GetCount();
 255                 bMoved = TRUE;
 256                 if (nMoveLevel == (short) nDepth - 1)
 257                     bNeedSize = TRUE;
 258             }
 259             else
 260                 bMoved = FALSE;
 261         }
 262     }
 263
 264     if (bNeedSize)
 265     {
 266         ++nDepth;
 267         rSizeChanged = TRUE;
 268     }
 269
 270     if (nDepth <= nLevel)
 271     {
 272         nDepth = nLevel+1;
 273         rSizeChanged = TRUE;
 274     }
 275
 276 /*                      nicht zusammenfassen!
 277
 278     //  zusammenfassen
 279
 280     USHORT nCount = aCollections[nLevel].GetCount();
 281     USHORT nIndex;
 282     bFound = FALSE;
 283     for ( nIndex=0; nIndex<nCount && !bFound; nIndex++ )
 284     {
 285         if ( ((ScOutlineEntry*) aCollections[nLevel].At(nIndex))->GetEnd() + 1 == nStartCol )
 286         {
 287             nStartCol = ((ScOutlineEntry*) aCollections[nLevel].At(nIndex))->GetStart();
 288             aCollections[nLevel].AtFree(nIndex);
 289             nCount = aCollections[nLevel].GetCount();           // Daten geaendert
 290             bFound = TRUE;
 291         }
 292     }
 293
 294     bFound = FALSE;
 295     for ( nIndex=0; nIndex<nCount && !bFound; nIndex++ )
 296     {
 297         if ( ((ScOutlineEntry*) aCollections[nLevel].At(nIndex))->GetStart() == nEndCol + 1 )
 298         {
 299             nEndCol = ((ScOutlineEntry*) aCollections[nLevel].At(nIndex))->GetEnd();
 300             aCollections[nLevel].AtFree(nIndex);
 301             bFound = TRUE;
 302         }
 303     }
 304 */
 305     ScOutlineEntry* pNewEntry = new ScOutlineEntry( nStartCol, nEndCol+1-nStartCol, bHidden );
 306     pNewEntry->SetVisible( bVisible );
 307     aCollections[nLevel].Insert( pNewEntry );
 308
 309     return TRUE;
 310 }
 311
 312 BOOL ScOutlineArray::FindTouchedLevel( SCCOLROW nBlockStart, SCCOLROW nBlockEnd, USHORT& rFindLevel ) const
 313 {
 314     BOOL bFound = FALSE;
 315     rFindLevel = 0;
 316
 317     for (USHORT nLevel=0; nLevel<nDepth; nLevel++)
 318     {
 319         const ScOutlineCollection* pCollect = &aCollections[nLevel];
 320         USHORT nCount = pCollect->GetCount();
 321         for (USHORT i=0; i<nCount; i++)
 322         {
 323             ScOutlineEntry* pEntry = (ScOutlineEntry*) pCollect->At(i);
 324             SCCOLROW nStart = pEntry->GetStart();
 325             SCCOLROW nEnd   = pEntry->GetEnd();
 326
 327             if ( ( nBlockStart>=nStart && nBlockStart<=nEnd ) ||
 328                  ( nBlockEnd  >=nStart && nBlockEnd  <=nEnd ) )
 329             {
 330                 rFindLevel = nLevel;                    // wirklicher Level
 331                 bFound = TRUE;
 332             }
 333         }
 334     }
 335
 336     return bFound;
 337 }
 338
 339 void ScOutlineArray::RemoveSub( SCCOLROW nStartPos, SCCOLROW nEndPos, USHORT nLevel )
 340 {
 341     if ( nLevel >= nDepth )
 342         return;
 343     ScOutlineCollection* pCollect = &aCollections[nLevel];
 344     USHORT nCount = pCollect->GetCount();
 345     BOOL bFound = FALSE;
 346     for ( USHORT i=0; i<nCount; i += ( bFound ? 0 : 1 ) )
 347     {
 348         bFound = FALSE;
 349         ScOutlineEntry* pEntry = (ScOutlineEntry*) pCollect->At(i);
 350         SCCOLROW nStart = pEntry->GetStart();
 351         SCCOLROW nEnd   = pEntry->GetEnd();
 352
 353         if ( nStart>=nStartPos && nEnd<=nEndPos )
 354         {
 355             RemoveSub( nStart, nEnd, nLevel+1 );
 356             pCollect->AtFree(i);
 357             nCount = pCollect->GetCount();
 358             bFound = TRUE;
 359         }
 360     }
 361 }
 362
 363 void ScOutlineArray::PromoteSub( SCCOLROW nStartPos, SCCOLROW nEndPos, USHORT nStartLevel )
 364 {
 365     if (nStartLevel==0)
 366     {
 367         DBG_ERROR("PromoteSub mit Level 0");
 368         return;
 369     }
 370
 371     for (USHORT nLevel = nStartLevel; nLevel < nDepth; nLevel++)
 372     {
 373         ScOutlineCollection* pCollect = &aCollections[nLevel];
 374         USHORT nCount = pCollect->GetCount();
 375         BOOL bFound = FALSE;
 376         for ( USHORT i=0; i<nCount; i += ( bFound ? 0 : 1 ) )
 377         {
 378             bFound = FALSE;
 379             ScOutlineEntry* pEntry = (ScOutlineEntry*) pCollect->At(i);
 380             SCCOLROW nStart = pEntry->GetStart();
 381             SCCOLROW nEnd   = pEntry->GetEnd();
 382
 383             if ( nStart>=nStartPos && nEnd<=nEndPos )
 384             {
 385                 aCollections[nLevel-1].Insert( new ScOutlineEntry( *pEntry ) );
 386                 pCollect->AtFree(i);
 387                 nCount = pCollect->GetCount();
 388                 bFound = TRUE;
 389             }
 390         }
 391     }
 392 }
 393
 394 BOOL ScOutlineArray::DecDepth()                                                 // nDepth auf leere Levels anpassen
 395 {
 396     BOOL bChanged = FALSE;
 397     BOOL bCont;
 398     do
 399     {
 400         bCont = FALSE;
 401         if (nDepth)
 402             if (aCollections[nDepth-1].GetCount() == 0)
 403             {
 404                 --nDepth;
 405                 bChanged = TRUE;
 406                 bCont = TRUE;
 407             }
 408     }
 409     while (bCont);
 410     return bChanged;
 411 }
 412
 413 BOOL ScOutlineArray::Remove( SCCOLROW nBlockStart, SCCOLROW nBlockEnd, BOOL& rSizeChanged )
 414 {
 415     USHORT nLevel;
 416     FindTouchedLevel( nBlockStart, nBlockEnd, nLevel );
 417
 418     ScOutlineCollection* pCollect = &aCollections[nLevel];
 419     USHORT nCount = pCollect->GetCount();
 420     BOOL bFound = FALSE;
 421     BOOL bAny = FALSE;
 422     for ( USHORT i=0; i<nCount; i += ( bFound ? 0 : 1 ) )
 423     {
 424         bFound = FALSE;
 425         ScOutlineEntry* pEntry = (ScOutlineEntry*) pCollect->At(i);
 426         SCCOLROW nStart = pEntry->GetStart();
 427         SCCOLROW nEnd   = pEntry->GetEnd();
 428
 429         if ( nBlockStart<=nEnd && nBlockEnd>=nStart )
 430         {
 431 //                      RemoveSub( nStart, nEnd, nLevel+1 );
 432             pCollect->AtFree(i);
 433             PromoteSub( nStart, nEnd, nLevel+1 );
 434             nCount = pCollect->GetCount();
 435             i = pCollect->FindStart( nEnd+1 );
 436             bFound = TRUE;
 437             bAny = TRUE;
 438         }
 439     }
 440
 441     if (bAny)                                                                   // Depth anpassen
 442         if (DecDepth())
 443             rSizeChanged = TRUE;
 444
 445     return bAny;
 446 }
 447
 448 ScOutlineEntry* ScOutlineArray::GetEntry( USHORT nLevel, USHORT nIndex ) const
 449 {
 450     return (ScOutlineEntry*)((nLevel < nDepth) ? aCollections[nLevel].At(nIndex) : NULL);
 451 }
 452
 453 USHORT ScOutlineArray::GetCount( USHORT nLevel ) const
 454 {
 455     return (nLevel < nDepth) ? aCollections[nLevel].GetCount() : 0;
 456 }
 457
 458 ScOutlineEntry* ScOutlineArray::GetEntryByPos( USHORT nLevel, SCCOLROW nPos ) const
 459 {
 460     USHORT                      nCount  = GetCount( nLevel );
 461     ScOutlineEntry*     pEntry;
 462
 463     for (USHORT nIndex = 0; nIndex < nCount; nIndex++)
 464     {
 465         pEntry = GetEntry( nLevel, nIndex );
 466         if ((pEntry->GetStart() <= nPos) && (nPos <= pEntry->GetEnd()))
 467             return pEntry;
 468     }
 469     return NULL;
 470 }
 471
 472 BOOL ScOutlineArray::GetEntryIndex( USHORT nLevel, SCCOLROW nPos, USHORT& rnIndex ) const
 473 {
 474     // found entry contains passed position
 475     USHORT nCount  = GetCount( nLevel );
 476     for ( rnIndex = 0; rnIndex < nCount; ++rnIndex )
 477     {
 478         const ScOutlineEntry* pEntry = GetEntry( nLevel, rnIndex );
 479         if ( (pEntry->GetStart() <= nPos) && (nPos <= pEntry->GetEnd()) )
 480             return TRUE;
 481     }
 482     return FALSE;
 483 }
 484
 485 BOOL ScOutlineArray::GetEntryIndexInRange(
 486         USHORT nLevel, SCCOLROW nBlockStart, SCCOLROW nBlockEnd, USHORT& rnIndex ) const
 487 {
 488     // found entry will be completely inside of passed range
 489     USHORT nCount  = GetCount( nLevel );
 490     for ( rnIndex = 0; rnIndex < nCount; ++rnIndex )
 491     {
 492         const ScOutlineEntry* pEntry = GetEntry( nLevel, rnIndex );
 493         if ( (nBlockStart <= pEntry->GetStart()) && (pEntry->GetEnd() <= nBlockEnd) )
 494             return TRUE;
 495     }
 496     return FALSE;
 497 }
 498
 499 void ScOutlineArray::SetVisibleBelow( USHORT nLevel, USHORT nEntry, BOOL bValue, BOOL bSkipHidden )
 500 {
 501     ScOutlineEntry* pEntry = GetEntry( nLevel, nEntry );
 502     if( pEntry )
 503     {
 504         SCCOLROW nStart = pEntry->GetStart();
 505         SCCOLROW nEnd   = pEntry->GetEnd();
 506
 507         for (USHORT nSubLevel=nLevel+1; nSubLevel<nDepth; nSubLevel++)
 508         {
 509             USHORT i = 0;
 510             pEntry = (ScOutlineEntry*) aCollections[nSubLevel].At(i);
 511             while (pEntry)
 512             {
 513                 if (pEntry->GetStart() >= nStart && pEntry->GetEnd() <= nEnd)
 514                 {
 515                     pEntry->SetVisible(bValue);
 516
 517                     if (bSkipHidden)
 518                         if (!pEntry->IsHidden())
 519                             SetVisibleBelow( nSubLevel, i, bValue, TRUE );
 520                 }
 521
 522                 ++i;
 523                 pEntry = (ScOutlineEntry*) aCollections[nSubLevel].At(i);
 524             }
 525
 526             if (bSkipHidden)
 527                 nSubLevel = nDepth;             // Abbruch
 528         }
 529     }
 530 }
 531
 532 void ScOutlineArray::GetRange( SCCOLROW& rStart, SCCOLROW& rEnd ) const
 533 {
 534     USHORT nCount = aCollections[0].GetCount();
 535     if (nCount)
 536     {
 537         rStart = ((ScOutlineEntry*) aCollections[0].At(0))->GetStart();
 538         rEnd   = ((ScOutlineEntry*) aCollections[0].At(nCount-1))->GetEnd();
 539     }
 540     else
 541         rStart = rEnd = 0;
 542 }
 543
 544 void ScOutlineArray::ExtendBlock( USHORT nLevel, SCCOLROW& rBlkStart, SCCOLROW& rBlkEnd )
 545 {
 546     USHORT      nCount;
 547     SCCOLROW    nStart;
 548     SCCOLROW    nEnd;
 549     USHORT      i;
 550     ScOutlineEntry* pEntry;
 551
 552     nCount = GetCount(nLevel);
 553     for ( i=0; i<nCount; i++ )
 554     {
 555         pEntry = (ScOutlineEntry*) aCollections[nLevel].At(i);
 556         nStart = pEntry->GetStart();
 557         nEnd   = pEntry->GetEnd();
 558
 559         if ( rBlkStart<=nEnd && rBlkEnd>=nStart )
 560         {
 561             if (nStart<rBlkStart) rBlkStart = nStart;
 562             if (nEnd>rBlkEnd) rBlkEnd = nEnd;
 563         }
 564     }
 565 }
 566
 567 BOOL ScOutlineArray::TestInsertSpace( SCSIZE nSize, SCCOLROW nMaxVal ) const
 568 {
 569     USHORT nCount = aCollections[0].GetCount();
 570     if (nCount)
 571     {
 572         SCCOLROW nEnd = ((ScOutlineEntry*) aCollections[0].At(nCount-1))->GetEnd();
 573         return ( sal::static_int_cast<SCCOLROW>(nEnd+nSize) <= nMaxVal );
 574     }
 575
 576     return TRUE;
 577 }
 578
 579 void ScOutlineArray::InsertSpace( SCCOLROW nStartPos, SCSIZE nSize )
 580 {
 581     ScSubOutlineIterator aIter( this );
 582     ScOutlineEntry* pEntry;
 583     while((pEntry=aIter.GetNext())!=NULL)
 584     {
 585         if ( pEntry->GetStart() >= nStartPos )
 586             pEntry->Move(static_cast<SCsCOLROW>(nSize));
 587         else
 588         {
 589             SCCOLROW nEnd = pEntry->GetEnd();
 590             //  immer erweitern, wenn innerhalb der Gruppe eingefuegt
 591             //  beim Einfuegen am Ende nur, wenn die Gruppe nicht ausgeblendet ist
 592             if ( nEnd >= nStartPos || ( nEnd+1 >= nStartPos && !pEntry->IsHidden() ) )
 593             {
 594                 SCSIZE nEntrySize = pEntry->GetSize();
 595                 nEntrySize += nSize;
 596                 pEntry->SetSize( nEntrySize );
 597             }
 598         }
 599     }
 600 }
 601
 602 BOOL ScOutlineArray::DeleteSpace( SCCOLROW nStartPos, SCSIZE nSize )
 603 {
 604     SCCOLROW nEndPos = nStartPos + nSize - 1;
 605     BOOL bNeedSave = FALSE;                                                     // Original fuer Undo benoetigt?
 606     BOOL bChanged = FALSE;                                                      // fuer Test auf Level
 607
 608     ScSubOutlineIterator aIter( this );
 609     ScOutlineEntry* pEntry;
 610     while((pEntry=aIter.GetNext())!=NULL)
 611     {
 612         SCCOLROW nEntryStart = pEntry->GetStart();
 613         SCCOLROW nEntryEnd   = pEntry->GetEnd();
 614         SCSIZE nEntrySize    = pEntry->GetSize();
 615
 616         if ( nEntryEnd >= nStartPos )
 617         {
 618             if ( nEntryStart > nEndPos )                                                                                // rechts
 619                 pEntry->Move(-(static_cast<SCsCOLROW>(nSize)));
 620             else if ( nEntryStart < nStartPos && nEntryEnd >= nEndPos )                 // aussen
 621                 pEntry->SetSize( nEntrySize-nSize );
 622             else
 623             {
 624                 bNeedSave = TRUE;
 625                 if ( nEntryStart >= nStartPos && nEntryEnd <= nEndPos )                         // innen
 626                 {
 627                     aIter.DeleteLast();
 628                     bChanged = TRUE;
 629                 }
 630                 else if ( nEntryStart >= nStartPos )                                                            // rechts ueber
 631                     pEntry->SetPosSize( nStartPos, static_cast<SCSIZE>(nEntryEnd-nEndPos) );
 632                 else                                                                                                                            // links ueber
 633                     pEntry->SetSize( static_cast<SCSIZE>(nStartPos-nEntryStart) );
 634             }
 635         }
 636     }
 637
 638     if (bChanged)
 639         DecDepth();
 640
 641     return bNeedSave;
 642 }
 643
 644 bool ScOutlineArray::ManualAction( SCCOLROW nStartPos, SCCOLROW nEndPos, bool bShow, ScTable& rTable, bool bCol )
 645 {
 646     BOOL bModified = FALSE;
 647     ScSubOutlineIterator aIter( this );
 648     ScOutlineEntry* pEntry;
 649     while((pEntry=aIter.GetNext())!=NULL)
 650     {
 651         SCCOLROW nEntryStart = pEntry->GetStart();
 652         SCCOLROW nEntryEnd   = pEntry->GetEnd();
 653
 654         if (nEntryEnd>=nStartPos && nEntryStart<=nEndPos)
 655         {
 656             if ( pEntry->IsHidden() == bShow )
 657             {
 658                 //      #i12341# hide if all columns/rows are hidden, show if at least one
 659                 //      is visible
 660                 SCCOLROW nEnd = rTable.LastHiddenColRow(nEntryStart, bCol);
 661                 BOOL bAllHidden = (nEntryEnd <= nEnd && nEnd <
 662                         ::std::numeric_limits<SCCOLROW>::max());
 663
 664                 BOOL bToggle = ( bShow != bAllHidden );
 665                 if ( bToggle )
 666                 {
 667                     pEntry->SetHidden( !bShow );
 668                     SetVisibleBelow( aIter.LastLevel(), aIter.LastEntry(), bShow, bShow );
 669                     bModified = TRUE;
 670                 }
 671             }
 672         }
 673     }
 674     return bModified;
 675 }
 676
 677 void ScOutlineArray::RemoveAll()
 678 {
 679     for (USHORT nLevel=0; nLevel<nDepth; nLevel++)
 680         aCollections[nLevel].FreeAll();
 681
 682     nDepth = 0;
 683 }
 684
 685 //------------------------------------------------------------------------
 686
 687 ScOutlineTable::ScOutlineTable()
 688 {
 689 }
 690
 691 ScOutlineTable::ScOutlineTable( const ScOutlineTable& rOutline ) :
 692     aColOutline( rOutline.aColOutline ),
 693     aRowOutline( rOutline.aRowOutline )
 694 {
 695 }
 696
 697 BOOL ScOutlineTable::TestInsertCol( SCSIZE nSize )
 698 {
 699     return aColOutline.TestInsertSpace( nSize, MAXCOL );
 700 }
 701
 702 void ScOutlineTable::InsertCol( SCCOL nStartCol, SCSIZE nSize )
 703 {
 704     aColOutline.InsertSpace( nStartCol, nSize );
 705 }
 706
 707 BOOL ScOutlineTable::DeleteCol( SCCOL nStartCol, SCSIZE nSize )
 708 {
 709     return aColOutline.DeleteSpace( nStartCol, nSize );
 710 }
 711
 712 BOOL ScOutlineTable::TestInsertRow( SCSIZE nSize )
 713 {
 714     return aRowOutline.TestInsertSpace( nSize, MAXROW );
 715 }
 716
 717 void ScOutlineTable::InsertRow( SCROW nStartRow, SCSIZE nSize )
 718 {
 719     aRowOutline.InsertSpace( nStartRow, nSize );
 720 }
 721
 722 BOOL ScOutlineTable::DeleteRow( SCROW nStartRow, SCSIZE nSize )
 723 {
 724     return aRowOutline.DeleteSpace( nStartRow, nSize );
 725 }
 726
 727 //------------------------------------------------------------------------
 728
 729 ScSubOutlineIterator::ScSubOutlineIterator( ScOutlineArray* pOutlineArray ) :
 730         pArray( pOutlineArray ),
 731         nStart( 0 ),
 732         nEnd( SCCOLROW_MAX ),                                                   // alle durchgehen
 733         nSubLevel( 0 ),
 734         nSubEntry( 0 )
 735 {
 736     nDepth = pArray->nDepth;
 737 }
 738
 739 ScSubOutlineIterator::ScSubOutlineIterator( ScOutlineArray* pOutlineArray,
 740                                             USHORT nLevel, USHORT nEntry ) :
 741         pArray( pOutlineArray )
 742 {
 743     ScOutlineEntry* pEntry = (ScOutlineEntry*) pArray->aCollections[nLevel].At(nEntry);
 744     nStart = pEntry->GetStart();
 745     nEnd   = pEntry->GetEnd();
 746     nSubLevel = nLevel + 1;
 747     nSubEntry = 0;
 748     nDepth = pArray->nDepth;
 749 }
 750
 751 ScOutlineEntry* ScSubOutlineIterator::GetNext()
 752 {
 753     ScOutlineEntry* pEntry;
 754     BOOL bFound = FALSE;
 755     do
 756     {
 757         if (nSubLevel >= nDepth)
 758             return NULL;
 759
 760         pEntry = (ScOutlineEntry*) pArray->aCollections[nSubLevel].At(nSubEntry);
 761         if (!pEntry)
 762         {
 763             nSubEntry = 0;
 764             ++nSubLevel;
 765         }
 766         else
 767         {
 768             if ( pEntry->GetStart() >= nStart && pEntry->GetEnd() <= nEnd )
 769                 bFound = TRUE;
 770             ++nSubEntry;
 771         }
 772     }
 773     while (!bFound);
 774     return pEntry;                                      // nSubLevel gueltig, wenn pEntry != 0
 775 }
 776
 777 USHORT ScSubOutlineIterator::LastLevel() const
 778 {
 779     return nSubLevel;
 780 }
 781
 782 USHORT ScSubOutlineIterator::LastEntry() const
 783 {
 784     if (nSubEntry == 0)
 785     {
 786         DBG_ERROR("ScSubOutlineIterator::LastEntry vor GetNext");
 787         return 0;
 788     }
 789     return nSubEntry-1;
 790 }
 791
 792 void ScSubOutlineIterator::DeleteLast()
 793 {
 794     if (nSubLevel >= nDepth)
 795     {
 796         DBG_ERROR("ScSubOutlineIterator::DeleteLast nach Ende");
 797         return;
 798     }
 799     if (nSubEntry == 0)
 800     {
 801         DBG_ERROR("ScSubOutlineIterator::DeleteLast vor GetNext");
 802         return;
 803     }
 804
 805     --nSubEntry;
 806     pArray->aCollections[nSubLevel].AtFree(nSubEntry);
 807 }
 808
 809