sc/source/ui/docshell/olinefun.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: olinefun.cxx,v $
  10  * $Revision: 1.8 $
  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
  35
  36 // INCLUDE ---------------------------------------------------------------
  37
  38 #include <vcl/sound.hxx>
  39 #include <sfx2/bindings.hxx>
  40
  41 #include "olinefun.hxx"
  42
  43 #include "docsh.hxx"
  44 #include "olinetab.hxx"
  45 #include "undodat.hxx"
  46 #include "globstr.hrc"
  47 #include "sc.hrc"
  48
  49
  50 //========================================================================
  51
  52 void lcl_InvalidateOutliner( SfxBindings* pBindings )
  53 {
  54     if ( pBindings )
  55     {
  56         pBindings->Invalidate( SID_OUTLINE_SHOW );
  57         pBindings->Invalidate( SID_OUTLINE_HIDE );
  58         pBindings->Invalidate( SID_OUTLINE_REMOVE );
  59
  60         pBindings->Invalidate( SID_STATUS_SUM );                        // wegen ein-/ausblenden
  61         pBindings->Invalidate( SID_ATTR_SIZE );
  62     }
  63 }
  64
  65 //------------------------------------------------------------------------
  66
  67 //!     PaintWidthHeight zur DocShell verschieben?
  68
  69 void lcl_PaintWidthHeight( ScDocShell& rDocShell, SCTAB nTab,
  70                                     BOOL bColumns, SCCOLROW nStart, SCCOLROW nEnd )
  71 {
  72     ScDocument* pDoc = rDocShell.GetDocument();
  73
  74     USHORT nParts = PAINT_GRID;
  75     SCCOL nStartCol = 0;
  76     SCROW nStartRow = 0;
  77     SCCOL nEndCol = MAXCOL;                     // fuer Test auf Merge
  78     SCROW nEndRow = MAXROW;
  79     if ( bColumns )
  80     {
  81         nParts |= PAINT_TOP;
  82         nStartCol = static_cast<SCCOL>(nStart);
  83         nEndCol = static_cast<SCCOL>(nEnd);
  84     }
  85     else
  86     {
  87         nParts |= PAINT_LEFT;
  88         nStartRow = nStart;
  89         nEndRow = nEnd;
  90     }
  91     if (pDoc->HasAttrib( nStartCol,nStartRow,nTab, nEndCol,nEndRow,nTab,
  92                             HASATTR_MERGED | HASATTR_OVERLAPPED ))
  93     {
  94         nStartCol = 0;
  95         nStartRow = 0;
  96     }
  97     rDocShell.PostPaint( nStartCol,nStartRow,nTab, MAXCOL,MAXROW,nTab, nParts );
  98 }
  99
 100 //------------------------------------------------------------------------
 101
 102 BOOL ScOutlineDocFunc::MakeOutline( const ScRange& rRange, BOOL bColumns, BOOL bRecord, BOOL bApi )
 103 {
 104     BOOL bSuccess = FALSE;
 105     SCCOL nStartCol = rRange.aStart.Col();
 106     SCROW nStartRow = rRange.aStart.Row();
 107     SCCOL nEndCol = rRange.aEnd.Col();
 108     SCROW nEndRow = rRange.aEnd.Row();
 109     SCTAB nTab = rRange.aStart.Tab();
 110
 111     ScDocument* pDoc = rDocShell.GetDocument();
 112     ScOutlineTable* pTable = pDoc->GetOutlineTable( nTab, TRUE );
 113     ScOutlineTable* pUndoTab = NULL;
 114
 115     if (bRecord && !pDoc->IsUndoEnabled())
 116         bRecord = FALSE;
 117
 118     if (bRecord)
 119         pUndoTab = new ScOutlineTable( *pTable );
 120
 121     ScOutlineArray* pArray = bColumns ? pTable->GetColArray() : pTable->GetRowArray();
 122
 123     BOOL bRes;
 124     BOOL bSize = FALSE;
 125     if ( bColumns )
 126         bRes = pArray->Insert( nStartCol, nEndCol, bSize );
 127     else
 128         bRes = pArray->Insert( nStartRow, nEndRow, bSize );
 129
 130     if ( bRes )
 131     {
 132         if (bRecord)
 133         {
 134             rDocShell.GetUndoManager()->AddUndoAction(
 135                 new ScUndoMakeOutline( &rDocShell,
 136                                         nStartCol,nStartRow,nTab,nEndCol,nEndRow,nTab,
 137                                         pUndoTab, bColumns, TRUE ) );
 138         }
 139
 140         USHORT nParts = 0;                              // Datenbereich nicht geaendert
 141         if ( bColumns )
 142             nParts |= PAINT_TOP;
 143         else
 144             nParts |= PAINT_LEFT;
 145         if ( bSize )
 146             nParts |= PAINT_SIZE;
 147
 148         rDocShell.PostPaint( 0,0,nTab, MAXCOL,MAXROW,nTab, nParts );
 149         rDocShell.SetDocumentModified();
 150         lcl_InvalidateOutliner( rDocShell.GetViewBindings() );
 151         bSuccess = TRUE;
 152     }
 153     else
 154     {
 155         if (!bApi)
 156             rDocShell.ErrorMessage(STR_MSSG_MAKEOUTLINE_0);     // "Gruppierung nicht moeglich"
 157         delete pUndoTab;
 158     }
 159
 160     return bSuccess;
 161 }
 162
 163 BOOL ScOutlineDocFunc::RemoveOutline( const ScRange& rRange, BOOL bColumns, BOOL bRecord, BOOL bApi )
 164 {
 165     BOOL bDone = FALSE;
 166
 167     SCCOL nStartCol = rRange.aStart.Col();
 168     SCROW nStartRow = rRange.aStart.Row();
 169     SCCOL nEndCol = rRange.aEnd.Col();
 170     SCROW nEndRow = rRange.aEnd.Row();
 171     SCTAB nTab = rRange.aStart.Tab();
 172
 173     ScDocument* pDoc = rDocShell.GetDocument();
 174
 175     if (bRecord && !pDoc->IsUndoEnabled())
 176         bRecord = FALSE;
 177     ScOutlineTable* pTable = pDoc->GetOutlineTable( nTab );
 178     if (pTable)
 179     {
 180         ScOutlineTable* pUndoTab = NULL;
 181         if (bRecord)
 182             pUndoTab = new ScOutlineTable( *pTable );
 183
 184         ScOutlineArray* pArray = bColumns ? pTable->GetColArray() : pTable->GetRowArray();
 185
 186         BOOL bRes;
 187         BOOL bSize = FALSE;
 188         if ( bColumns )
 189             bRes = pArray->Remove( nStartCol, nEndCol, bSize );
 190         else
 191             bRes = pArray->Remove( nStartRow, nEndRow, bSize );
 192
 193         if ( bRes )
 194         {
 195             if (bRecord)
 196             {
 197                 rDocShell.GetUndoManager()->AddUndoAction(
 198                     new ScUndoMakeOutline( &rDocShell,
 199                                             nStartCol,nStartRow,nTab, nEndCol,nEndRow,nTab,
 200                                             pUndoTab, bColumns, FALSE ) );
 201             }
 202
 203             USHORT nParts = 0;                          // Datenbereich nicht geaendert
 204             if ( bColumns )
 205                 nParts |= PAINT_TOP;
 206             else
 207                 nParts |= PAINT_LEFT;
 208             if ( bSize )
 209                 nParts |= PAINT_SIZE;
 210
 211             rDocShell.PostPaint( 0,0,nTab, MAXCOL,MAXROW,nTab, nParts );
 212             rDocShell.SetDocumentModified();
 213             bDone = TRUE;
 214             lcl_InvalidateOutliner( rDocShell.GetViewBindings() );
 215
 216             // es wird nicht wieder eingeblendet -> kein UpdatePageBreaks
 217         }
 218         else
 219             delete pUndoTab;
 220     }
 221
 222     if (!bDone && !bApi)
 223         rDocShell.ErrorMessage(STR_MSSG_REMOVEOUTLINE_0);       // "Aufheben nicht moeglich"
 224
 225     return bDone;
 226 }
 227
 228 BOOL ScOutlineDocFunc::RemoveAllOutlines( SCTAB nTab, BOOL bRecord, BOOL bApi )
 229 {
 230     BOOL bSuccess = FALSE;
 231     ScDocument* pDoc = rDocShell.GetDocument();
 232
 233     if (bRecord && !pDoc->IsUndoEnabled())
 234         bRecord = FALSE;
 235     ScOutlineTable* pTable = pDoc->GetOutlineTable( nTab );
 236     if (pTable)
 237     {
 238         if (bRecord)
 239         {
 240             SCCOLROW nCol1, nCol2, nRow1, nRow2;
 241             pTable->GetColArray()->GetRange( nCol1, nCol2 );
 242             pTable->GetRowArray()->GetRange( nRow1, nRow2 );
 243             SCCOL nStartCol = static_cast<SCCOL>(nCol1);
 244             SCROW nStartRow = nRow1;
 245             SCCOL nEndCol = static_cast<SCCOL>(nCol2);
 246             SCROW nEndRow = nRow2;
 247
 248             ScDocument* pUndoDoc = new ScDocument( SCDOCMODE_UNDO );
 249             pUndoDoc->InitUndo( pDoc, nTab, nTab, TRUE, TRUE );
 250             pDoc->CopyToDocument( nStartCol, 0, nTab, nEndCol, MAXROW, nTab, IDF_NONE, FALSE, pUndoDoc );
 251             pDoc->CopyToDocument( 0, nStartRow, nTab, MAXCOL, nEndRow, nTab, IDF_NONE, FALSE, pUndoDoc );
 252
 253             ScOutlineTable* pUndoTab = new ScOutlineTable( *pTable );
 254
 255             rDocShell.GetUndoManager()->AddUndoAction(
 256                 new ScUndoRemoveAllOutlines( &rDocShell,
 257                                                 nStartCol, nStartRow, nTab,
 258                                                 nEndCol, nEndRow, nTab,
 259                                                 pUndoDoc, pUndoTab ) );
 260         }
 261
 262         SelectLevel( nTab, TRUE,  pTable->GetColArray()->GetDepth(), FALSE, FALSE, bApi );
 263         SelectLevel( nTab, FALSE, pTable->GetRowArray()->GetDepth(), FALSE, FALSE, bApi );
 264         pDoc->SetOutlineTable( nTab, NULL );
 265
 266         pDoc->UpdatePageBreaks( nTab );
 267
 268         rDocShell.PostPaint( 0,0,nTab, MAXCOL,MAXROW,nTab,
 269                                     PAINT_GRID | PAINT_LEFT | PAINT_TOP | PAINT_SIZE );
 270         rDocShell.SetDocumentModified();
 271         lcl_InvalidateOutliner( rDocShell.GetViewBindings() );
 272         bSuccess = TRUE;
 273     }
 274     else if (!bApi)
 275         Sound::Beep();
 276
 277     return bSuccess;
 278 }
 279
 280 //------------------------------------------------------------------------
 281
 282 BOOL ScOutlineDocFunc::AutoOutline( const ScRange& rRange, BOOL bRecord, BOOL bApi )
 283 {
 284     SCCOL nStartCol = rRange.aStart.Col();
 285     SCROW nStartRow = rRange.aStart.Row();
 286     SCCOL nEndCol = rRange.aEnd.Col();
 287     SCROW nEndRow = rRange.aEnd.Row();
 288     SCTAB nTab = rRange.aStart.Tab();
 289
 290     ScDocument* pDoc = rDocShell.GetDocument();
 291
 292     if (bRecord && !pDoc->IsUndoEnabled())
 293         bRecord = FALSE;
 294     ScOutlineTable* pTable = pDoc->GetOutlineTable( nTab );
 295
 296     ScDocument* pUndoDoc = NULL;
 297     ScOutlineTable* pUndoTab = NULL;
 298
 299     if ( pTable )
 300     {
 301         if ( bRecord )
 302         {
 303             pUndoTab = new ScOutlineTable( *pTable );
 304
 305             SCCOLROW nCol1, nCol2, nRow1, nRow2;
 306             pTable->GetColArray()->GetRange( nCol1, nCol2 );
 307             pTable->GetRowArray()->GetRange( nRow1, nRow2 );
 308             SCCOL nOutStartCol = static_cast<SCCOL>(nCol1);;
 309             SCROW nOutStartRow = nRow1;
 310             SCCOL nOutEndCol = static_cast<SCCOL>(nCol2);;
 311             SCROW nOutEndRow = nRow2;
 312
 313             pUndoDoc = new ScDocument( SCDOCMODE_UNDO );
 314             pUndoDoc->InitUndo( pDoc, nTab, nTab, TRUE, TRUE );
 315             pDoc->CopyToDocument( nOutStartCol, 0, nTab, nOutEndCol, MAXROW, nTab, IDF_NONE, FALSE, pUndoDoc );
 316             pDoc->CopyToDocument( 0, nOutStartRow, nTab, MAXCOL, nOutEndRow, nTab, IDF_NONE, FALSE, pUndoDoc );
 317         }
 318
 319         // einblenden
 320         SelectLevel( nTab, TRUE,  pTable->GetColArray()->GetDepth(), FALSE, FALSE, bApi );
 321         SelectLevel( nTab, FALSE, pTable->GetRowArray()->GetDepth(), FALSE, FALSE, bApi );
 322         pDoc->SetOutlineTable( nTab, NULL );
 323     }
 324
 325     pDoc->DoAutoOutline( nStartCol,nStartRow, nEndCol,nEndRow, nTab );
 326
 327     if (bRecord)
 328     {
 329         rDocShell.GetUndoManager()->AddUndoAction(
 330             new ScUndoAutoOutline( &rDocShell,
 331                                     nStartCol, nStartRow, nTab,
 332                                     nEndCol, nEndRow, nTab,
 333                                     pUndoDoc, pUndoTab ) );
 334     }
 335
 336     rDocShell.PostPaint( 0,0,nTab, MAXCOL,MAXROW,nTab, PAINT_LEFT | PAINT_TOP | PAINT_SIZE );
 337     rDocShell.SetDocumentModified();
 338     lcl_InvalidateOutliner( rDocShell.GetViewBindings() );
 339
 340     return TRUE;
 341 }
 342
 343 //------------------------------------------------------------------------
 344
 345 BOOL ScOutlineDocFunc::SelectLevel( SCTAB nTab, BOOL bColumns, USHORT nLevel,
 346                                     BOOL bRecord, BOOL bPaint, BOOL /* bApi */ )
 347 {
 348     ScDocument* pDoc = rDocShell.GetDocument();
 349
 350     if (bRecord && !pDoc->IsUndoEnabled())
 351         bRecord = FALSE;
 352     ScOutlineTable* pTable = pDoc->GetOutlineTable( nTab );                             // ist schon da
 353     if (!pTable)
 354         return FALSE;
 355     ScOutlineArray* pArray = bColumns ? pTable->GetColArray() : pTable->GetRowArray();
 356     if (!pArray)
 357         return FALSE;
 358
 359     SCCOLROW nStart, nEnd;
 360     pArray->GetRange( nStart, nEnd );
 361
 362     if ( bRecord )
 363     {
 364         ScOutlineTable* pUndoTab = new ScOutlineTable( *pTable );
 365         ScDocument* pUndoDoc = new ScDocument( SCDOCMODE_UNDO );
 366         if (bColumns)
 367         {
 368             pUndoDoc->InitUndo( pDoc, nTab, nTab, TRUE, FALSE );
 369             pDoc->CopyToDocument( static_cast<SCCOL>(nStart), 0, nTab,
 370                     static_cast<SCCOL>(nEnd), MAXROW, nTab, IDF_NONE, FALSE,
 371                     pUndoDoc );
 372         }
 373         else
 374         {
 375             pUndoDoc->InitUndo( pDoc, nTab, nTab, FALSE, TRUE );
 376             pDoc->CopyToDocument( 0, nStart, nTab, MAXCOL, nEnd, nTab, IDF_NONE, FALSE, pUndoDoc );
 377         }
 378
 379         rDocShell.GetUndoManager()->AddUndoAction(
 380             new ScUndoOutlineLevel( &rDocShell,
 381                                     nStart, nEnd, nTab,                         //! start und end berechnen
 382                                     pUndoDoc, pUndoTab,
 383                                     bColumns, nLevel ) );
 384     }
 385
 386     ScSubOutlineIterator aIter( pArray );                                       // alle Eintraege
 387     ScOutlineEntry* pEntry;
 388     while ((pEntry=aIter.GetNext()) != NULL)
 389     {
 390         USHORT nThisLevel = aIter.LastLevel();
 391         BOOL bShow = (nThisLevel < nLevel);
 392         if (bShow)                                                                                      // einblenden
 393         {
 394             pEntry->SetHidden( FALSE );
 395             pEntry->SetVisible( TRUE );
 396         }
 397         else if ( nThisLevel == nLevel )                                        // ausblenden
 398         {
 399             pEntry->SetHidden( TRUE );
 400             pEntry->SetVisible( TRUE );
 401         }
 402         else                                                                                            // verdeckt
 403         {
 404             pEntry->SetVisible( FALSE );
 405         }
 406
 407         SCCOLROW nThisStart = pEntry->GetStart();
 408         SCCOLROW nThisEnd   = pEntry->GetEnd();
 409         for (SCCOLROW i=nThisStart; i<=nThisEnd; i++)
 410         {
 411             if ( bColumns )
 412                 pDoc->ShowCol( static_cast<SCCOL>(i), nTab, bShow );
 413             else
 414                                 if ( !bShow || !pDoc->RowFiltered( i,nTab ) )
 415                     pDoc->ShowRow( i, nTab, bShow );
 416         }
 417     }
 418
 419     pDoc->UpdatePageBreaks( nTab );
 420
 421     if (bPaint)
 422         lcl_PaintWidthHeight( rDocShell, nTab, bColumns, nStart, nEnd );
 423
 424     rDocShell.SetDocumentModified();
 425     lcl_InvalidateOutliner( rDocShell.GetViewBindings() );
 426
 427     return TRUE;
 428 }
 429
 430 //------------------------------------------------------------------------
 431
 432 BOOL ScOutlineDocFunc::ShowMarkedOutlines( const ScRange& rRange, BOOL bRecord, BOOL bApi )
 433 {
 434     BOOL bDone = FALSE;
 435
 436     SCCOL nStartCol = rRange.aStart.Col();
 437     SCROW nStartRow = rRange.aStart.Row();
 438     SCCOL nEndCol = rRange.aEnd.Col();
 439     SCROW nEndRow = rRange.aEnd.Row();
 440     SCTAB nTab = rRange.aStart.Tab();
 441
 442     ScDocument* pDoc = rDocShell.GetDocument();
 443
 444     if (bRecord && !pDoc->IsUndoEnabled())
 445         bRecord = FALSE;
 446     ScOutlineTable* pTable = pDoc->GetOutlineTable( nTab );
 447
 448     if (pTable)
 449     {
 450         ScOutlineArray* pArray;
 451         ScOutlineEntry* pEntry;
 452         SCCOLROW nStart;
 453         SCCOLROW nEnd;
 454         SCCOLROW nMin;
 455         SCCOLROW nMax;
 456         SCCOLROW i;
 457
 458         if ( bRecord )
 459         {
 460             ScOutlineTable* pUndoTab = new ScOutlineTable( *pTable );
 461             ScDocument* pUndoDoc = new ScDocument( SCDOCMODE_UNDO );
 462             pUndoDoc->InitUndo( pDoc, nTab, nTab, TRUE, TRUE );
 463             pDoc->CopyToDocument( nStartCol, 0, nTab, nEndCol, MAXROW, nTab, IDF_NONE, FALSE, pUndoDoc );
 464             pDoc->CopyToDocument( 0, nStartRow, nTab, MAXCOL, nEndRow, nTab, IDF_NONE, FALSE, pUndoDoc );
 465
 466             rDocShell.GetUndoManager()->AddUndoAction(
 467                 new ScUndoOutlineBlock( &rDocShell,
 468                                         nStartCol, nStartRow, nTab, nEndCol, nEndRow, nTab,
 469                                         pUndoDoc, pUndoTab, TRUE ) );
 470         }
 471
 472         //      Spalten
 473
 474         nMin=MAXCOL;
 475         nMax=0;
 476         pArray = pTable->GetColArray();
 477         ScSubOutlineIterator aColIter( pArray );
 478         while ((pEntry=aColIter.GetNext()) != NULL)
 479         {
 480             nStart = pEntry->GetStart();
 481             nEnd   = pEntry->GetEnd();
 482             if ( nStart>=nStartCol && nEnd<=nEndCol )
 483             {
 484                 pEntry->SetHidden( FALSE );
 485                 pEntry->SetVisible( TRUE );
 486                 if (nStart<nMin) nMin=nStart;
 487                 if (nEnd>nMax) nMax=nEnd;
 488             }
 489         }
 490         for ( i=nMin; i<=nMax; i++ )
 491             pDoc->ShowCol( static_cast<SCCOL>(i), nTab, TRUE );
 492
 493         //      Zeilen
 494
 495         nMin=MAXROW;
 496         nMax=0;
 497         pArray = pTable->GetRowArray();
 498         ScSubOutlineIterator aRowIter( pArray );
 499         while ((pEntry=aRowIter.GetNext()) != NULL)
 500         {
 501             nStart = pEntry->GetStart();
 502             nEnd   = pEntry->GetEnd();
 503             if ( nStart>=nStartRow && nEnd<=nEndRow )
 504             {
 505                 pEntry->SetHidden( FALSE );
 506                 pEntry->SetVisible( TRUE );
 507                 if (nStart<nMin) nMin=nStart;
 508                 if (nEnd>nMax) nMax=nEnd;
 509             }
 510         }
 511         for ( i=nMin; i<=nMax; i++ )
 512                         if ( !pDoc->RowFiltered( i,nTab ) )                             // weggefilterte nicht einblenden
 513                 pDoc->ShowRow( i, nTab, TRUE );
 514
 515         pDoc->UpdatePageBreaks( nTab );
 516
 517         rDocShell.PostPaint( 0,0,nTab, MAXCOL,MAXROW,nTab, PAINT_GRID | PAINT_LEFT | PAINT_TOP );
 518
 519         rDocShell.SetDocumentModified();
 520         bDone = TRUE;
 521
 522         lcl_InvalidateOutliner( rDocShell.GetViewBindings() );
 523     }
 524
 525     if (!bDone && !bApi)
 526         Sound::Beep();
 527
 528     return bDone;
 529 }
 530
 531 BOOL ScOutlineDocFunc::HideMarkedOutlines( const ScRange& rRange, BOOL bRecord, BOOL bApi )
 532 {
 533     BOOL bDone = FALSE;
 534
 535     SCCOL nStartCol = rRange.aStart.Col();
 536     SCROW nStartRow = rRange.aStart.Row();
 537     SCCOL nEndCol = rRange.aEnd.Col();
 538     SCROW nEndRow = rRange.aEnd.Row();
 539     SCTAB nTab = rRange.aStart.Tab();
 540
 541     ScDocument* pDoc = rDocShell.GetDocument();
 542
 543     if (bRecord && !pDoc->IsUndoEnabled())
 544         bRecord = FALSE;
 545     ScOutlineTable* pTable = pDoc->GetOutlineTable( nTab );
 546
 547     if (pTable)
 548     {
 549         ScOutlineEntry* pEntry;
 550         USHORT nColLevel;
 551         USHORT nRowLevel;
 552         USHORT nCount;
 553         SCCOLROW nStart;
 554         SCCOLROW nEnd;
 555         USHORT i;
 556
 557         SCCOLROW nEffStartCol = nStartCol;
 558         SCCOLROW nEffEndCol   = nEndCol;
 559         ScOutlineArray* pColArray = pTable->GetColArray();
 560         pColArray->FindTouchedLevel( nStartCol, nEndCol, nColLevel );
 561         pColArray->ExtendBlock( nColLevel, nEffStartCol, nEffEndCol );
 562         SCCOLROW nEffStartRow = nStartRow;
 563         SCCOLROW nEffEndRow   = nEndRow;
 564         ScOutlineArray* pRowArray = pTable->GetRowArray();
 565         pRowArray->FindTouchedLevel( nStartRow, nEndRow, nRowLevel );
 566         pRowArray->ExtendBlock( nRowLevel, nEffStartRow, nEffEndRow );
 567
 568         if ( bRecord )
 569         {
 570             ScOutlineTable* pUndoTab = new ScOutlineTable( *pTable );
 571             ScDocument* pUndoDoc = new ScDocument( SCDOCMODE_UNDO );
 572             pUndoDoc->InitUndo( pDoc, nTab, nTab, TRUE, TRUE );
 573             pDoc->CopyToDocument( static_cast<SCCOL>(nEffStartCol), 0, nTab,
 574                     static_cast<SCCOL>(nEffEndCol), MAXROW, nTab, IDF_NONE,
 575                     FALSE, pUndoDoc );
 576             pDoc->CopyToDocument( 0, nEffStartRow, nTab, MAXCOL, nEffEndRow, nTab, IDF_NONE, FALSE, pUndoDoc );
 577
 578             rDocShell.GetUndoManager()->AddUndoAction(
 579                 new ScUndoOutlineBlock( &rDocShell,
 580                                         nStartCol, nStartRow, nTab, nEndCol, nEndRow, nTab,
 581                                         pUndoDoc, pUndoTab, FALSE ) );
 582         }
 583
 584         //      Spalten
 585
 586         nCount = pColArray->GetCount(nColLevel);
 587         for ( i=0; i<nCount; i++ )
 588         {
 589             pEntry = pColArray->GetEntry(nColLevel,i);
 590             nStart = pEntry->GetStart();
 591             nEnd   = pEntry->GetEnd();
 592
 593             if ( static_cast<SCCOLROW>(nStartCol)<=nEnd && static_cast<SCCOLROW>(nEndCol)>=nStart )
 594                 HideOutline( nTab, TRUE, nColLevel, i, FALSE, FALSE, bApi );
 595         }
 596
 597         //      Zeilen
 598
 599         nCount = pRowArray->GetCount(nRowLevel);
 600         for ( i=0; i<nCount; i++ )
 601         {
 602             pEntry = pRowArray->GetEntry(nRowLevel,i);
 603             nStart = pEntry->GetStart();
 604             nEnd   = pEntry->GetEnd();
 605
 606             if ( nStartRow<=nEnd && nEndRow>=nStart )
 607                 HideOutline( nTab, FALSE, nRowLevel, i, FALSE, FALSE, bApi );
 608         }
 609
 610         pDoc->UpdatePageBreaks( nTab );
 611
 612         rDocShell.PostPaint( 0,0,nTab, MAXCOL,MAXROW,nTab, PAINT_GRID | PAINT_LEFT | PAINT_TOP );
 613
 614         rDocShell.SetDocumentModified();
 615         bDone = TRUE;
 616
 617         lcl_InvalidateOutliner( rDocShell.GetViewBindings() );
 618     }
 619
 620     if (!bDone && !bApi)
 621         Sound::Beep();
 622
 623     return bDone;
 624 }
 625
 626 //------------------------------------------------------------------------
 627
 628 BOOL ScOutlineDocFunc::ShowOutline( SCTAB nTab, BOOL bColumns, USHORT nLevel, USHORT nEntry,
 629                                     BOOL bRecord, BOOL bPaint, BOOL /* bApi */ )
 630 {
 631     ScDocument* pDoc = rDocShell.GetDocument();
 632     if (bRecord && !pDoc->IsUndoEnabled())
 633         bRecord = FALSE;
 634
 635     ScOutlineTable* pTable = pDoc->GetOutlineTable( nTab );
 636     ScOutlineArray* pArray = bColumns ? pTable->GetColArray() : pTable->GetRowArray();
 637     ScOutlineEntry* pEntry = pArray->GetEntry( nLevel, nEntry );
 638     SCCOLROW nStart = pEntry->GetStart();
 639     SCCOLROW nEnd   = pEntry->GetEnd();
 640
 641     if ( bRecord )
 642     {
 643         ScDocument* pUndoDoc = new ScDocument( SCDOCMODE_UNDO );
 644         if (bColumns)
 645         {
 646             pUndoDoc->InitUndo( pDoc, nTab, nTab, TRUE, FALSE );
 647             pDoc->CopyToDocument( static_cast<SCCOL>(nStart), 0, nTab,
 648                     static_cast<SCCOL>(nEnd), MAXROW, nTab, IDF_NONE, FALSE,
 649                     pUndoDoc );
 650         }
 651         else
 652         {
 653             pUndoDoc->InitUndo( pDoc, nTab, nTab, FALSE, TRUE );
 654             pDoc->CopyToDocument( 0, nStart, nTab, MAXCOL, nEnd, nTab, IDF_NONE, FALSE, pUndoDoc );
 655         }
 656
 657         rDocShell.GetUndoManager()->AddUndoAction(
 658             new ScUndoDoOutline( &rDocShell,
 659                                     nStart, nEnd, nTab, pUndoDoc,               //! start und end berechnen
 660                                     bColumns, nLevel, nEntry, TRUE ) );
 661     }
 662
 663 //!     HideCursor();
 664
 665     pEntry->SetHidden(FALSE);
 666     SCCOLROW i;
 667     for ( i = nStart; i <= nEnd; i++ )
 668     {
 669         if ( bColumns )
 670             pDoc->ShowCol( static_cast<SCCOL>(i), nTab, TRUE );
 671         else
 672                         if ( !pDoc->RowFiltered( i,nTab ) )                             // weggefilterte nicht einblenden
 673                 pDoc->ShowRow( i, nTab, TRUE );
 674     }
 675
 676     ScSubOutlineIterator aIter( pArray, nLevel, nEntry );
 677     while ((pEntry=aIter.GetNext()) != NULL)
 678     {
 679         if ( pEntry->IsHidden() )
 680         {
 681             SCCOLROW nSubStart = pEntry->GetStart();
 682             SCCOLROW nSubEnd   = pEntry->GetEnd();
 683             for ( i = nSubStart; i <= nSubEnd; i++ )
 684             {
 685                 if ( bColumns )
 686                     pDoc->ShowCol( static_cast<SCCOL>(i), nTab, FALSE );
 687                 else
 688                     pDoc->ShowRow( i, nTab, FALSE );
 689             }
 690         }
 691     }
 692
 693     pArray->SetVisibleBelow( nLevel, nEntry, TRUE, TRUE );
 694
 695     pDoc->InvalidatePageBreaks(nTab);
 696     pDoc->UpdatePageBreaks( nTab );
 697
 698     if (bPaint)
 699         lcl_PaintWidthHeight( rDocShell, nTab, bColumns, nStart, nEnd );
 700
 701 //!     ShowCursor();
 702     rDocShell.SetDocumentModified();
 703
 704 //!     if (bPaint)
 705 //!             UpdateScrollBars();
 706
 707     lcl_InvalidateOutliner( rDocShell.GetViewBindings() );
 708
 709     return TRUE;                //! immer ???
 710 }
 711
 712 BOOL ScOutlineDocFunc::HideOutline( SCTAB nTab, BOOL bColumns, USHORT nLevel, USHORT nEntry,
 713                                     BOOL bRecord, BOOL bPaint, BOOL /* bApi */ )
 714 {
 715     ScDocument* pDoc = rDocShell.GetDocument();
 716     if (bRecord && !pDoc->IsUndoEnabled())
 717         bRecord = FALSE;
 718
 719     ScOutlineTable* pTable = pDoc->GetOutlineTable( nTab );
 720     ScOutlineArray* pArray = bColumns ? pTable->GetColArray() : pTable->GetRowArray();
 721     ScOutlineEntry* pEntry = pArray->GetEntry( nLevel, nEntry );
 722     SCCOLROW nStart = pEntry->GetStart();
 723     SCCOLROW nEnd       = pEntry->GetEnd();
 724
 725     if ( bRecord )
 726     {
 727         ScDocument* pUndoDoc = new ScDocument( SCDOCMODE_UNDO );
 728         if (bColumns)
 729         {
 730             pUndoDoc->InitUndo( pDoc, nTab, nTab, TRUE, FALSE );
 731             pDoc->CopyToDocument( static_cast<SCCOL>(nStart), 0, nTab,
 732                     static_cast<SCCOL>(nEnd), MAXROW, nTab, IDF_NONE, FALSE,
 733                     pUndoDoc );
 734         }
 735         else
 736         {
 737             pUndoDoc->InitUndo( pDoc, nTab, nTab, FALSE, TRUE );
 738             pDoc->CopyToDocument( 0, nStart, nTab, MAXCOL, nEnd, nTab, IDF_NONE, FALSE, pUndoDoc );
 739         }
 740
 741         rDocShell.GetUndoManager()->AddUndoAction(
 742             new ScUndoDoOutline( &rDocShell,
 743                                     nStart, nEnd, nTab, pUndoDoc,
 744                                     bColumns, nLevel, nEntry, FALSE ) );
 745     }
 746
 747 //!     HideCursor();
 748
 749     pEntry->SetHidden(TRUE);
 750     SCCOLROW i;
 751     for ( i = nStart; i <= nEnd; i++ )
 752     {
 753         if ( bColumns )
 754             pDoc->ShowCol( static_cast<SCCOL>(i), nTab, FALSE );
 755         else
 756             pDoc->ShowRow( i, nTab, FALSE );
 757     }
 758
 759     pArray->SetVisibleBelow( nLevel, nEntry, FALSE );
 760
 761     pDoc->InvalidatePageBreaks(nTab);
 762     pDoc->UpdatePageBreaks( nTab );
 763
 764     if (bPaint)
 765         lcl_PaintWidthHeight( rDocShell, nTab, bColumns, nStart, nEnd );
 766
 767 //!     ShowCursor();
 768     rDocShell.SetDocumentModified();
 769
 770 //!     if (bPaint)
 771 //!             UpdateScrollBars();
 772
 773     lcl_InvalidateOutliner( rDocShell.GetViewBindings() );
 774
 775     return TRUE;                //! immer ???
 776 }
 777
 778
 779
 780
 781