sc/source/ui/docshell/olinefun.cxx

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