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