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