xref: /aoo41x/main/sc/source/ui/docshell/docsh5.cxx (revision 22407013)
1 /**************************************************************
2  *
3  * Licensed to the Apache Software Foundation (ASF) under one
4  * or more contributor license agreements.  See the NOTICE file
5  * distributed with this work for additional information
6  * regarding copyright ownership.  The ASF licenses this file
7  * to you under the Apache License, Version 2.0 (the
8  * "License"); you may not use this file except in compliance
9  * with the License.  You may obtain a copy of the License at
10  *
11  *   http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing,
14  * software distributed under the License is distributed on an
15  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16  * KIND, either express or implied.  See the License for the
17  * specific language governing permissions and limitations
18  * under the License.
19  *
20  *************************************************************/
21 
22 
23 
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_sc.hxx"
26 
27 // System - Includes -----------------------------------------------------
28 
29 
30 
31 
32 #include "scitems.hxx"
33 #include <vcl/svapp.hxx>
34 #include <vcl/msgbox.hxx>
35 #include <vcl/waitobj.hxx>
36 #include <sfx2/app.hxx>
37 #include <sfx2/bindings.hxx>
38 #include <svl/smplhint.hxx>
39 
40 // INCLUDE ---------------------------------------------------------------
41 
42 #include "docsh.hxx"
43 #include "global.hxx"
44 #include "globstr.hrc"
45 #include "undodat.hxx"
46 #include "undotab.hxx"
47 #include "undoblk.hxx"
48 //#include "pivot.hxx"
49 #include "dpobject.hxx"
50 #include "dpshttab.hxx"
51 #include "dbdocfun.hxx"
52 #include "consoli.hxx"
53 #include "dbcolect.hxx"
54 #include "olinetab.hxx"
55 #include "patattr.hxx"
56 #include "attrib.hxx"
57 #include "docpool.hxx"
58 #include "uiitems.hxx"
59 #include "sc.hrc"
60 #include "waitoff.hxx"
61 #include "sizedev.hxx"
62 #include <basic/sbstar.hxx>
63 #include <basic/basmgr.hxx>
64 
65 // defined in docfunc.cxx
66 void VBA_InsertModule( ScDocument& rDoc, SCTAB nTab, String& sModuleName, String& sModuleSource );
67 
68 // ---------------------------------------------------------------------------
69 
70 //
71 //	ehemalige viewfunc/dbfunc Methoden
72 //
73 
ErrorMessage(sal_uInt16 nGlobStrId)74 void ScDocShell::ErrorMessage( sal_uInt16 nGlobStrId )
75 {
76 	//!	StopMarking an der (aktiven) View?
77 
78 	Window* pParent = GetActiveDialogParent();
79 	ScWaitCursorOff aWaitOff( pParent );
80 	sal_Bool bFocus = pParent && pParent->HasFocus();
81 
82 	if(nGlobStrId==STR_PROTECTIONERR)
83 	{
84 		if(IsReadOnly())
85 		{
86 			nGlobStrId=STR_READONLYERR;
87 		}
88 	}
89 
90 	InfoBox aBox( pParent, ScGlobal::GetRscString( nGlobStrId ) );
91 	aBox.Execute();
92 	if (bFocus)
93 		pParent->GrabFocus();
94 }
95 
IsEditable() const96 sal_Bool ScDocShell::IsEditable() const
97 {
98 	// import into read-only document is possible - must be extended if other filters use api
99 	// #i108547# MSOOXML filter uses "IsChangeReadOnlyEnabled" property
100 
101 	return !IsReadOnly() || aDocument.IsImportingXML() || aDocument.IsChangeReadOnlyEnabled();
102 }
103 
DBAreaDeleted(SCTAB nTab,SCCOL nX1,SCROW nY1,SCCOL nX2,SCROW)104 void ScDocShell::DBAreaDeleted( SCTAB nTab, SCCOL nX1, SCROW nY1, SCCOL nX2, SCROW /* nY2 */ )
105 {
106 	ScDocShellModificator aModificator( *this );
107 	aDocument.RemoveFlagsTab( nX1, nY1, nX2, nY1, nTab, SC_MF_AUTO );
108 	PostPaint( nX1, nY1, nTab, nX2, nY1, nTab, PAINT_GRID );
109     // No SetDocumentModified, as the unnamed database range might have to be restored later.
110     // The UNO hint is broadcast directly instead, to keep UNO objects in valid state.
111     aDocument.BroadcastUno( SfxSimpleHint( SFX_HINT_DATACHANGED ) );
112 }
113 
114 
lcl_GetDBNearCursor(const ScDBCollection * pColl,const SCCOL nCol,const SCROW nRow,const SCTAB nTab)115 ScDBData* lcl_GetDBNearCursor(
116     const ScDBCollection* pColl,
117     const SCCOL nCol,
118     const SCROW nRow,
119     const SCTAB nTab )
120 {
121     //!	nach document/dbcolect verschieben
122 
123     if (!pColl)
124         return NULL;
125 
126     ScDBData* pInternalDBData = NULL;
127     ScDBData* pNearData = NULL;
128     sal_uInt16 nCount = pColl->GetCount();
129     SCTAB nAreaTab;
130     SCCOL nStartCol, nEndCol;
131     SCROW nStartRow, nEndRow;
132     for (sal_uInt16 i = 0; i < nCount; i++)
133     {
134         ScDBData* pDB = (*pColl)[i];
135         pDB->GetArea( nAreaTab, nStartCol, nStartRow, nEndCol, nEndRow );
136         if ( nTab == nAreaTab
137              && nCol+1 >= nStartCol
138              && nCol <= nEndCol+1
139              && nRow+1 >= nStartRow
140              && nRow <= nEndRow+1 )
141         {
142             if ( pDB->IsInternalUnnamed()
143                  || pDB->IsInternalForAutoFilter() )
144             {
145                 pInternalDBData = pDB;
146             }
147             else if ( nCol < nStartCol || nCol > nEndCol || nRow < nStartRow || nRow > nEndRow )
148             {
149                 if ( !pNearData )
150                     pNearData = pDB;	// ersten angrenzenden Bereich merken
151             }
152             else
153                 return pDB;				// nicht "unbenannt" und Cursor steht wirklich drin
154         }
155     }
156     if (pNearData)
157         return pNearData;				// angrenzender, wenn nichts direkt getroffen
158     return pInternalDBData;
159 }
160 
GetDBData(const ScRange & rMarked,ScGetDBMode eMode,ScGetDBSelection eSel)161 ScDBData* ScDocShell::GetDBData( const ScRange& rMarked, ScGetDBMode eMode, ScGetDBSelection eSel )
162 {
163     const SCCOL nCol = rMarked.aStart.Col();
164     const SCROW nRow = rMarked.aStart.Row();
165     const SCTAB nTab = rMarked.aStart.Tab();
166 
167     SCCOL nStartCol = nCol;
168     SCROW nStartRow = nRow;
169     SCCOL nEndCol = rMarked.aEnd.Col();
170     SCROW nEndRow = rMarked.aEnd.Row();
171 
172     ScDBData* pFoundDBData = aDocument.GetDBAtArea( nTab, nStartCol, nStartRow, nEndCol, nEndRow );
173     if ( pFoundDBData == NULL )
174     {
175         pFoundDBData = lcl_GetDBNearCursor( aDocument.GetDBCollection(), nCol, nRow, nTab );
176     }
177 
178     const bool bSelected =
179         ( eSel == SC_DBSEL_FORCE_MARK
180           || ( rMarked.aStart != rMarked.aEnd
181                && eSel != SC_DBSEL_ROW_DOWN ) );
182     const bool bOnlyDown = ( !bSelected
183                              && eSel == SC_DBSEL_ROW_DOWN
184                              && rMarked.aStart.Row() == rMarked.aEnd.Row());
185 
186     bool bUseFoundDBData = false;
187     if ( pFoundDBData )
188     {
189         // check, if found database range can be used
190         SCTAB nDummy;
191         SCCOL nOldCol1;
192         SCROW nOldRow1;
193         SCCOL nOldCol2;
194         SCROW nOldRow2;
195         pFoundDBData->GetArea( nDummy, nOldCol1, nOldRow1, nOldCol2, nOldRow2 );
196 
197         const bool bIsUnnamedOne = pFoundDBData->IsInternalUnnamed();
198         const bool bIsInternalForAutoFilter = pFoundDBData->IsInternalForAutoFilter();
199         if ( !bSelected )
200         {
201             bUseFoundDBData = true;
202             if ( ( bIsUnnamedOne || bIsInternalForAutoFilter )
203                  && ( eMode == SC_DB_MAKE || eMode == SC_DB_MAKE_AUTOFILTER ) )
204             {
205                 // If nothing marked or only one row marked, adapt found database range to contiguous area.
206                 nStartCol = nCol;
207                 nStartRow = nRow;
208                 if ( bOnlyDown )
209                 {
210                     nEndCol = rMarked.aEnd.Col();
211                     nEndRow = rMarked.aEnd.Row();
212                 }
213                 else
214                 {
215                     nEndCol = nStartCol;
216                     nEndRow = nStartRow;
217                 }
218                 aDocument.GetDataArea( nTab, nStartCol, nStartRow, nEndCol, nEndRow, sal_False, bOnlyDown );
219                 if ( nOldCol1 != nStartCol || nOldCol2 != nEndCol || nOldRow1 != nStartRow )
220                 {
221                     bUseFoundDBData = false;
222                 }
223                 else if ( nOldRow2 != nEndRow )
224                 {
225                     // adapt found internal database range to new end row
226                     pFoundDBData->SetArea( nTab, nOldCol1,nOldRow1, nOldCol2,nEndRow );
227                 }
228             }
229         }
230         else
231         {
232             if ( nOldCol1 == nStartCol
233                  && nOldRow1 == nStartRow
234                  && nOldCol2 == nEndCol
235                  && nOldRow2 == nEndRow )
236             {
237                 bUseFoundDBData = true;
238             }
239             else
240             {
241                 bUseFoundDBData = false;
242             }
243         }
244 
245         // adapt internal unnamed database range to an auto filter one
246         // otherwise the auto filter is lost when the internal unnamed one is changed/reused/deleted
247         if ( bUseFoundDBData
248              && eMode == SC_DB_MAKE_AUTOFILTER
249              && bIsUnnamedOne )
250         {
251             pFoundDBData->SetName( aDocument.GetDBCollection()->GetNewDefaultDBName() );
252         }
253 
254         // no internal database range for Import
255         if ( bUseFoundDBData
256              && eMode == SC_DB_IMPORT
257              && ( bIsUnnamedOne || bIsInternalForAutoFilter ) )
258         {
259             bUseFoundDBData = false;
260         }
261     }
262 
263     if ( bUseFoundDBData )
264     {
265         return pFoundDBData;
266     }
267 
268     if ( eMode == SC_DB_OLD )
269     {
270         // no existing database range found
271         return NULL;
272     }
273     else // eMode == SC_DB_MAKE||SC_DB_IMPORT||SC_DB_MAKE_AUTOFILTER
274     {
275         if ( !bSelected )
276         {
277             nStartCol = nCol;
278             nStartRow = nRow;
279             if (bOnlyDown)
280             {
281                 nEndCol = rMarked.aEnd.Col();
282                 nEndRow = rMarked.aEnd.Row();
283             }
284             else
285             {
286                 nEndCol = nStartCol;
287                 nEndRow = nStartRow;
288             }
289             aDocument.GetDataArea( nTab, nStartCol, nStartRow, nEndCol, nEndRow, sal_False, bOnlyDown );
290         }
291 
292         const sal_Bool bHasHeader = aDocument.HasColHeader( nStartCol, nStartRow, nEndCol, nEndRow, nTab );
293 
294         ScDBData* pDBData = NULL;
295         sal_uInt16 nUnnamedDBIndex;
296         ScDBCollection* pColl = aDocument.GetDBCollection();
297         if ( eMode == SC_DB_MAKE &&
298              pColl->SearchName( ScGlobal::GetRscString( STR_DB_NONAME ), nUnnamedDBIndex ) )
299         {
300             // adapt existing unnamed database range
301             pDBData = (*pColl)[nUnnamedDBIndex];
302 
303             if ( !pOldAutoDBRange )
304             {
305                 // store the old unnamed database range with its settings for undo
306                 // (store at the first change, get the state before all changes)
307                 pOldAutoDBRange = new ScDBData( *pDBData );
308             }
309 
310             SCCOL nOldX1;
311             SCROW nOldY1;
312             SCCOL nOldX2;
313             SCROW nOldY2;
314             SCTAB nOldTab;
315             pDBData->GetArea( nOldTab, nOldX1, nOldY1, nOldX2, nOldY2 );
316             DBAreaDeleted( nOldTab, nOldX1, nOldY1, nOldX2, nOldY2 );
317 
318             pDBData->SetSortParam( ScSortParam() );
319             pDBData->SetQueryParam( ScQueryParam() );
320             pDBData->SetSubTotalParam( ScSubTotalParam() );
321 
322             pDBData->SetArea( nTab, nStartCol,nStartRow, nEndCol,nEndRow );
323             pDBData->SetByRow( sal_True );
324             pDBData->SetHeader( bHasHeader );
325             pDBData->SetAutoFilter( sal_False );
326         }
327         else
328         {
329             ScDBCollection* pUndoColl = NULL;
330 
331             String aNewName;
332             switch ( eMode )
333             {
334             case SC_DB_IMPORT:
335             {
336                 aDocument.CompileDBFormula( sal_True );
337                 pUndoColl = new ScDBCollection( *pColl );
338 
339                 String aImport = ScGlobal::GetRscString( STR_DBNAME_IMPORT );
340                 long nCount = 0;
341                 sal_uInt16 nDummy;
342                 do
343                 {
344                     ++nCount;
345                     aNewName = aImport;
346                     aNewName += String::CreateFromInt32( nCount );
347                 }
348                 while (pColl->SearchName( aNewName, nDummy ));
349             }
350             break;
351 
352             case SC_DB_MAKE_AUTOFILTER:
353             {
354                 aDocument.CompileDBFormula( sal_True );
355                 pUndoColl = new ScDBCollection( *pColl );
356 
357                 aNewName = pColl->GetNewDefaultDBName();
358             }
359             break;
360 
361             case SC_DB_MAKE:
362             {
363                 aNewName = ScGlobal::GetRscString( STR_DB_NONAME );
364             }
365             break;
366 
367             default:
368                 DBG_ERROR( "<ScDocShell::GetDBData(..)> - unexcepted <eMode>" );
369                 break;
370             }
371 
372             pDBData = new ScDBData(
373                 aNewName, nTab, nStartCol, nStartRow, nEndCol, nEndRow, sal_True, bHasHeader );
374             pColl->Insert( pDBData );
375 
376             if ( pUndoColl )
377             {
378                 aDocument.CompileDBFormula( sal_False );
379 
380                 ScDBCollection* pRedoColl = new ScDBCollection( *pColl );
381                 GetUndoManager()->AddUndoAction( new ScUndoDBData( this, pUndoColl, pRedoColl ) );
382             }
383 
384             // notify Navigator about database range "Import[X]"
385             if ( eMode==SC_DB_IMPORT )
386             {
387                 SFX_APP()->Broadcast( SfxSimpleHint( SC_HINT_DBAREAS_CHANGED ) );
388             }
389         }
390 
391         return pDBData;
392     }
393 
394     return NULL; // never reached
395 }
396 
397 
GetOldAutoDBRange()398 ScDBData* ScDocShell::GetOldAutoDBRange()
399 {
400     ScDBData* pRet = pOldAutoDBRange;
401     pOldAutoDBRange = NULL;
402     return pRet;                    // has to be deleted by caller!
403 }
404 
CancelAutoDBRange()405 void ScDocShell::CancelAutoDBRange()
406 {
407     // called when dialog is cancelled
408     if ( pOldAutoDBRange )
409     {
410         sal_uInt16 nNoNameIndex;
411         ScDBCollection* pColl = aDocument.GetDBCollection();
412         if ( pColl->SearchName( ScGlobal::GetRscString( STR_DB_NONAME ), nNoNameIndex ) )
413         {
414             ScDBData* pNoNameData = (*pColl)[nNoNameIndex];
415 
416             SCCOL nRangeX1;
417             SCROW nRangeY1;
418             SCCOL nRangeX2;
419             SCROW nRangeY2;
420             SCTAB nRangeTab;
421             pNoNameData->GetArea( nRangeTab, nRangeX1, nRangeY1, nRangeX2, nRangeY2 );
422             DBAreaDeleted( nRangeTab, nRangeX1, nRangeY1, nRangeX2, nRangeY2 );
423 
424             *pNoNameData = *pOldAutoDBRange;    // restore old settings
425 
426             if ( pOldAutoDBRange->HasAutoFilter() )
427             {
428                 // restore AutoFilter buttons
429                 pOldAutoDBRange->GetArea( nRangeTab, nRangeX1, nRangeY1, nRangeX2, nRangeY2 );
430                 aDocument.ApplyFlagsTab( nRangeX1, nRangeY1, nRangeX2, nRangeY1, nRangeTab, SC_MF_AUTO );
431                 PostPaint( nRangeX1, nRangeY1, nRangeTab, nRangeX2, nRangeY1, nRangeTab, PAINT_GRID );
432             }
433         }
434 
435         delete pOldAutoDBRange;
436         pOldAutoDBRange = NULL;
437     }
438 }
439 
440 
441 		//	Hoehen anpassen
442 		//!	mit docfunc zusammenfassen
443 
AdjustRowHeight(SCROW nStartRow,SCROW nEndRow,SCTAB nTab)444 sal_Bool ScDocShell::AdjustRowHeight( SCROW nStartRow, SCROW nEndRow, SCTAB nTab )
445 {
446 	ScSizeDeviceProvider aProv(this);
447 	Fraction aZoom(1,1);
448 	sal_Bool bChange = aDocument.SetOptimalHeight( nStartRow,nEndRow, nTab, 0, aProv.GetDevice(),
449 												aProv.GetPPTX(),aProv.GetPPTY(), aZoom,aZoom, sal_False );
450 	if (bChange)
451 		PostPaint( 0,nStartRow,nTab, MAXCOL,MAXROW,nTab, PAINT_GRID|PAINT_LEFT );
452 
453 	return bChange;
454 }
455 
UpdateAllRowHeights(const ScMarkData * pTabMark)456 void ScDocShell::UpdateAllRowHeights( const ScMarkData* pTabMark )
457 {
458 	// update automatic row heights
459 
460 	ScSizeDeviceProvider aProv(this);
461 	Fraction aZoom(1,1);
462     aDocument.UpdateAllRowHeights( aProv.GetDevice(), aProv.GetPPTX(), aProv.GetPPTY(), aZoom, aZoom, pTabMark );
463 }
464 
UpdatePendingRowHeights(SCTAB nUpdateTab,bool bBefore)465 void ScDocShell::UpdatePendingRowHeights( SCTAB nUpdateTab, bool bBefore )
466 {
467     sal_Bool bIsUndoEnabled = aDocument.IsUndoEnabled();
468     aDocument.EnableUndo( sal_False );
469     aDocument.LockStreamValid( true );      // ignore draw page size (but not formula results)
470     if ( bBefore )          // check all sheets up to nUpdateTab
471     {
472         SCTAB nTabCount = aDocument.GetTableCount();
473         if ( nUpdateTab >= nTabCount )
474             nUpdateTab = nTabCount-1;     // nUpdateTab is inclusive
475 
476         ScMarkData aUpdateSheets;
477         SCTAB nTab;
478         for (nTab=0; nTab<=nUpdateTab; ++nTab)
479             if ( aDocument.IsPendingRowHeights( nTab ) )
480                 aUpdateSheets.SelectTable( nTab, sal_True );
481 
482         if (aUpdateSheets.GetSelectCount())
483             UpdateAllRowHeights(&aUpdateSheets);        // update with a single progress bar
484 
485         for (nTab=0; nTab<=nUpdateTab; ++nTab)
486             if ( aUpdateSheets.GetTableSelect( nTab ) )
487             {
488                 aDocument.UpdatePageBreaks( nTab );
489                 aDocument.SetPendingRowHeights( nTab, sal_False );
490             }
491     }
492     else                    // only nUpdateTab
493     {
494         if ( aDocument.IsPendingRowHeights( nUpdateTab ) )
495         {
496             AdjustRowHeight( 0, MAXROW, nUpdateTab );
497             aDocument.UpdatePageBreaks( nUpdateTab );
498             aDocument.SetPendingRowHeights( nUpdateTab, sal_False );
499         }
500     }
501     aDocument.LockStreamValid( false );
502     aDocument.EnableUndo( bIsUndoEnabled );
503 }
504 
RefreshPivotTables(const ScRange & rSource)505 void ScDocShell::RefreshPivotTables( const ScRange& rSource )
506 {
507 	//!	rename to RefreshDataPilotTables?
508 
509 	ScDPCollection* pColl = aDocument.GetDPCollection();
510 	if ( pColl )
511 	{
512 		//	DataPilotUpdate doesn't modify the collection order like PivotUpdate did,
513 		//	so a simple loop can be used.
514 
515 		sal_uInt16 nCount = pColl->GetCount();
516 		for ( sal_uInt16 i=0; i<nCount; i++ )
517 		{
518 			ScDPObject* pOld = (*pColl)[i];
519 			if ( pOld )
520 			{
521 				const ScSheetSourceDesc* pSheetDesc = pOld->GetSheetDesc();
522 				if ( pSheetDesc && pSheetDesc->aSourceRange.Intersects( rSource ) )
523 				{
524 					ScDPObject* pNew = new ScDPObject( *pOld );
525 					ScDBDocFunc aFunc( *this );
526 					aFunc.DataPilotUpdate( pOld, pNew, sal_True, sal_False );
527 					delete pNew;	// DataPilotUpdate copies settings from "new" object
528 				}
529 			}
530 		}
531 	}
532 }
533 
lcl_GetAreaName(ScDocument * pDoc,ScArea * pArea)534 String lcl_GetAreaName( ScDocument* pDoc, ScArea* pArea )
535 {
536     String aName;
537     bool bOk = false;
538     ScDBData* pData = pDoc->GetDBAtArea( pArea->nTab, pArea->nColStart, pArea->nRowStart, pArea->nColEnd, pArea->nRowEnd );
539     if (pData)
540     {
541         pData->GetName( aName );
542         if ( !pData->IsInternalUnnamed() )
543             bOk = true;
544     }
545 
546     if (!bOk)
547     {
548         pDoc->GetName( pArea->nTab, aName );
549     }
550 
551     return aName;
552 }
553 
DoConsolidate(const ScConsolidateParam & rParam,sal_Bool bRecord)554 void ScDocShell::DoConsolidate( const ScConsolidateParam& rParam, sal_Bool bRecord )
555 {
556 	ScConsData aData;
557 
558 	sal_uInt16 nPos;
559 	SCCOL nColSize = 0;
560 	SCROW nRowSize = 0;
561 	sal_Bool bErr = sal_False;
562 	for (nPos=0; nPos<rParam.nDataAreaCount; nPos++)
563 	{
564 		ScArea* pArea = rParam.ppDataAreas[nPos];
565 		nColSize = Max( nColSize, SCCOL( pArea->nColEnd - pArea->nColStart + 1 ) );
566 		nRowSize = Max( nRowSize, SCROW( pArea->nRowEnd - pArea->nRowStart + 1 ) );
567 
568 										// Test, ob Quelldaten verschoben wuerden
569 		if (rParam.bReferenceData)
570 			if (pArea->nTab == rParam.nTab && pArea->nRowEnd >= rParam.nRow)
571 				bErr = sal_True;
572 	}
573 
574 	if (bErr)
575 	{
576 		InfoBox aBox( GetActiveDialogParent(),
577 				ScGlobal::GetRscString( STR_CONSOLIDATE_ERR1 ) );
578 		aBox.Execute();
579 		return;
580 	}
581 
582 	//		ausfuehren
583 
584 	WaitObject aWait( GetActiveDialogParent() );
585 	ScDocShellModificator aModificator( *this );
586 
587 	ScRange aOldDest;
588 	ScDBData* pDestData = aDocument.GetDBAtCursor( rParam.nCol, rParam.nRow, rParam.nTab, sal_True );
589 	if (pDestData)
590 		pDestData->GetArea(aOldDest);
591 
592 	aData.SetSize( nColSize, nRowSize );
593 	aData.SetFlags( rParam.eFunction, rParam.bByCol, rParam.bByRow, rParam.bReferenceData );
594 	if ( rParam.bByCol || rParam.bByRow )
595 		for (nPos=0; nPos<rParam.nDataAreaCount; nPos++)
596 		{
597 			ScArea* pArea = rParam.ppDataAreas[nPos];
598 			aData.AddFields( &aDocument, pArea->nTab, pArea->nColStart, pArea->nRowStart,
599 														pArea->nColEnd, pArea->nRowEnd );
600 		}
601 	aData.DoneFields();
602 	for (nPos=0; nPos<rParam.nDataAreaCount; nPos++)
603 	{
604 		ScArea* pArea = rParam.ppDataAreas[nPos];
605 		aData.AddData( &aDocument, pArea->nTab, pArea->nColStart, pArea->nRowStart,
606 													pArea->nColEnd, pArea->nRowEnd );
607 		aData.AddName( lcl_GetAreaName(&aDocument,pArea) );
608 	}
609 
610 	aData.GetSize( nColSize, nRowSize );
611 	if (bRecord && nColSize > 0 && nRowSize > 0)
612 	{
613 		ScDBData* pUndoData = pDestData ? new ScDBData(*pDestData) : NULL;
614 
615 		SCTAB nDestTab = rParam.nTab;
616 		ScArea aDestArea( rParam.nTab, rParam.nCol, rParam.nRow,
617 							rParam.nCol+nColSize-1, rParam.nRow+nRowSize-1 );
618 		if (rParam.bByCol) ++aDestArea.nColEnd;
619 		if (rParam.bByRow) ++aDestArea.nRowEnd;
620 
621 		if (rParam.bReferenceData)
622 		{
623 			SCTAB nTabCount = aDocument.GetTableCount();
624 			SCROW nInsertCount = aData.GetInsertCount();
625 
626 			// alte Outlines
627 			ScOutlineTable* pTable = aDocument.GetOutlineTable( nDestTab );
628 			ScOutlineTable* pUndoTab = pTable ? new ScOutlineTable( *pTable ) : NULL;
629 
630 			ScDocument* pUndoDoc = new ScDocument( SCDOCMODE_UNDO );
631 			pUndoDoc->InitUndo( &aDocument, 0, nTabCount-1, sal_False, sal_True );
632 
633 			// Zeilenstatus
634 			aDocument.CopyToDocument( 0,0,nDestTab, MAXCOL,MAXROW,nDestTab,
635 									IDF_NONE, sal_False, pUndoDoc );
636 
637 			// alle Formeln
638 			aDocument.CopyToDocument( 0,0,0, MAXCOL,MAXROW,nTabCount-1,
639 										IDF_FORMULA, sal_False, pUndoDoc );
640 
641 			// komplette Ausgangszeilen
642 			aDocument.CopyToDocument( 0,aDestArea.nRowStart,nDestTab,
643 									MAXCOL,aDestArea.nRowEnd,nDestTab,
644 									IDF_ALL, sal_False, pUndoDoc );
645 
646 			// alten Ausgabebereich
647 			if (pDestData)
648 				aDocument.CopyToDocument( aOldDest, IDF_ALL, sal_False, pUndoDoc );
649 
650 			GetUndoManager()->AddUndoAction(
651 					new ScUndoConsolidate( this, aDestArea, rParam, pUndoDoc,
652 											sal_True, nInsertCount, pUndoTab, pUndoData ) );
653 		}
654 		else
655 		{
656 			ScDocument* pUndoDoc = new ScDocument( SCDOCMODE_UNDO );
657 			pUndoDoc->InitUndo( &aDocument, aDestArea.nTab, aDestArea.nTab );
658 
659 			aDocument.CopyToDocument( aDestArea.nColStart, aDestArea.nRowStart, aDestArea.nTab,
660 									aDestArea.nColEnd, aDestArea.nRowEnd, aDestArea.nTab,
661 									IDF_ALL, sal_False, pUndoDoc );
662 
663 			// alten Ausgabebereich
664 			if (pDestData)
665 				aDocument.CopyToDocument( aOldDest, IDF_ALL, sal_False, pUndoDoc );
666 
667 			GetUndoManager()->AddUndoAction(
668 					new ScUndoConsolidate( this, aDestArea, rParam, pUndoDoc,
669 											sal_False, 0, NULL, pUndoData ) );
670 		}
671 	}
672 
673 	if (pDestData)										// Zielbereich loeschen / anpassen
674 	{
675 		aDocument.DeleteAreaTab(aOldDest, IDF_CONTENTS);
676 		pDestData->SetArea( rParam.nTab, rParam.nCol, rParam.nRow,
677 							rParam.nCol + nColSize - 1, rParam.nRow + nRowSize - 1 );
678 		pDestData->SetHeader( rParam.bByRow );
679 	}
680 
681 	aData.OutputToDocument( &aDocument, rParam.nCol, rParam.nRow, rParam.nTab );
682 
683 	SCCOL nPaintStartCol = rParam.nCol;
684 	SCROW nPaintStartRow = rParam.nRow;
685 	SCCOL nPaintEndCol = nPaintStartCol + nColSize - 1;
686 	SCROW nPaintEndRow = nPaintStartRow + nRowSize - 1;
687 	sal_uInt16 nPaintFlags = PAINT_GRID;
688 	if (rParam.bByCol)
689 		++nPaintEndRow;
690 	if (rParam.bByRow)
691 		++nPaintEndCol;
692 	if (rParam.bReferenceData)
693 	{
694 		nPaintStartCol = 0;
695 		nPaintEndCol = MAXCOL;
696 		nPaintEndRow = MAXROW;
697 		nPaintFlags |= PAINT_LEFT | PAINT_SIZE;
698 	}
699 	if (pDestData)
700 	{
701 		if ( aOldDest.aEnd.Col() > nPaintEndCol )
702 			nPaintEndCol = aOldDest.aEnd.Col();
703 		if ( aOldDest.aEnd.Row() > nPaintEndRow )
704 			nPaintEndRow = aOldDest.aEnd.Row();
705 	}
706 	PostPaint( nPaintStartCol, nPaintStartRow, rParam.nTab,
707 				nPaintEndCol, nPaintEndRow, rParam.nTab, nPaintFlags );
708 	aModificator.SetDocumentModified();
709 }
710 
UseScenario(SCTAB nTab,const String & rName,sal_Bool bRecord)711 void ScDocShell::UseScenario( SCTAB nTab, const String& rName, sal_Bool bRecord )
712 {
713 	if (!aDocument.IsScenario(nTab))
714 	{
715 		SCTAB	nTabCount = aDocument.GetTableCount();
716 		SCTAB	nSrcTab = SCTAB_MAX;
717 		SCTAB	nEndTab = nTab;
718 		String aCompare;
719 		while ( nEndTab+1 < nTabCount && aDocument.IsScenario(nEndTab+1) )
720 		{
721 			++nEndTab;
722 			if (nSrcTab > MAXTAB)			// noch auf der Suche nach dem Szenario?
723 			{
724 				aDocument.GetName( nEndTab, aCompare );
725 				if (aCompare == rName)
726 					nSrcTab = nEndTab;		// gefunden
727 			}
728 		}
729 		if (ValidTab(nSrcTab))
730 		{
731 			if ( aDocument.TestCopyScenario( nSrcTab, nTab ) )			// Zellschutz testen
732 			{
733 				ScDocShellModificator aModificator( *this );
734 				ScMarkData aScenMark;
735 				aDocument.MarkScenario( nSrcTab, nTab, aScenMark );
736 				ScRange aMultiRange;
737 				aScenMark.GetMultiMarkArea( aMultiRange );
738 				SCCOL nStartCol = aMultiRange.aStart.Col();
739 				SCROW nStartRow = aMultiRange.aStart.Row();
740 				SCCOL nEndCol = aMultiRange.aEnd.Col();
741 				SCROW nEndRow = aMultiRange.aEnd.Row();
742 
743 				if (bRecord)
744 				{
745 					ScDocument* pUndoDoc = new ScDocument( SCDOCMODE_UNDO );
746 					pUndoDoc->InitUndo( &aDocument, nTab,nEndTab );				// auch alle Szenarien
747 					//	angezeigte Tabelle:
748 					aDocument.CopyToDocument( nStartCol,nStartRow,nTab,
749 									nEndCol,nEndRow,nTab, IDF_ALL,sal_True, pUndoDoc, &aScenMark );
750 					//	Szenarien
751 					for (SCTAB i=nTab+1; i<=nEndTab; i++)
752 					{
753 						pUndoDoc->SetScenario( i, sal_True );
754 						String aComment;
755 						Color  aColor;
756 						sal_uInt16 nScenFlags;
757 						aDocument.GetScenarioData( i, aComment, aColor, nScenFlags );
758 						pUndoDoc->SetScenarioData( i, aComment, aColor, nScenFlags );
759 						sal_Bool bActive = aDocument.IsActiveScenario( i );
760 						pUndoDoc->SetActiveScenario( i, bActive );
761 						//	Bei Zurueckkopier-Szenarios auch Inhalte
762 						if ( nScenFlags & SC_SCENARIO_TWOWAY )
763 							aDocument.CopyToDocument( 0,0,i, MAXCOL,MAXROW,i,
764 														IDF_ALL,sal_False, pUndoDoc );
765 					}
766 
767 					GetUndoManager()->AddUndoAction(
768 						new ScUndoUseScenario( this, aScenMark,
769 										ScArea( nTab,nStartCol,nStartRow,nEndCol,nEndRow ),
770 										pUndoDoc, rName ) );
771 				}
772 
773 				aDocument.CopyScenario( nSrcTab, nTab );
774 				aDocument.SetDirty();
775 
776 				//	alles painten, weil in anderen Bereichen das aktive Szenario
777 				//	geaendert sein kann
778 				//!	nur, wenn sichtbare Rahmen vorhanden?
779 				PostPaint( 0,0,nTab, MAXCOL,MAXROW,nTab, PAINT_GRID );
780 				aModificator.SetDocumentModified();
781 			}
782 			else
783 			{
784 				InfoBox aBox(GetActiveDialogParent(),
785 					ScGlobal::GetRscString( STR_PROTECTIONERR ) );
786 				aBox.Execute();
787 			}
788 		}
789 		else
790 		{
791 			InfoBox aBox(GetActiveDialogParent(),
792 				ScGlobal::GetRscString( STR_SCENARIO_NOTFOUND ) );
793 			aBox.Execute();
794 		}
795 	}
796 	else
797 	{
798 		DBG_ERROR( "UseScenario auf Szenario-Blatt" );
799 	}
800 }
801 
ModifyScenario(SCTAB nTab,const String & rName,const String & rComment,const Color & rColor,sal_uInt16 nFlags)802 void ScDocShell::ModifyScenario( SCTAB nTab, const String& rName, const String& rComment,
803 									const Color& rColor, sal_uInt16 nFlags )
804 {
805 	//	Undo
806 	String aOldName;
807 	aDocument.GetName( nTab, aOldName );
808 	String aOldComment;
809 	Color aOldColor;
810 	sal_uInt16 nOldFlags;
811 	aDocument.GetScenarioData( nTab, aOldComment, aOldColor, nOldFlags );
812 	GetUndoManager()->AddUndoAction(
813 		new ScUndoScenarioFlags( this, nTab,
814 				aOldName, rName, aOldComment, rComment,
815 				aOldColor, rColor, nOldFlags, nFlags ) );
816 
817 	//	ausfuehren
818 	ScDocShellModificator aModificator( *this );
819 	aDocument.RenameTab( nTab, rName );
820 	aDocument.SetScenarioData( nTab, rComment, rColor, nFlags );
821 	PostPaintGridAll();
822 	aModificator.SetDocumentModified();
823 
824 	if ( rName != aOldName )
825 		SFX_APP()->Broadcast( SfxSimpleHint( SC_HINT_TABLES_CHANGED ) );
826 
827 	SfxBindings* pBindings = GetViewBindings();
828 	if (pBindings)
829 		pBindings->Invalidate( SID_SELECT_SCENARIO );
830 }
831 
MakeScenario(SCTAB nTab,const String & rName,const String & rComment,const Color & rColor,sal_uInt16 nFlags,ScMarkData & rMark,sal_Bool bRecord)832 SCTAB ScDocShell::MakeScenario( SCTAB nTab, const String& rName, const String& rComment,
833 									const Color& rColor, sal_uInt16 nFlags,
834 									ScMarkData& rMark, sal_Bool bRecord )
835 {
836 	rMark.MarkToMulti();
837 	if (rMark.IsMultiMarked())
838 	{
839 		SCTAB nNewTab = nTab + 1;
840 		while (aDocument.IsScenario(nNewTab))
841 			++nNewTab;
842 
843 		sal_Bool bCopyAll = ( (nFlags & SC_SCENARIO_COPYALL) != 0 );
844 		const ScMarkData* pCopyMark = NULL;
845 		if (!bCopyAll)
846 			pCopyMark = &rMark;
847 
848 		ScDocShellModificator aModificator( *this );
849 
850         if (bRecord)
851             aDocument.BeginDrawUndo();      // drawing layer must do its own undo actions
852 
853 		if (aDocument.CopyTab( nTab, nNewTab, pCopyMark ))
854 		{
855 			if (bRecord)
856 			{
857 				GetUndoManager()->AddUndoAction(
858                         new ScUndoMakeScenario( this, nTab, nNewTab,
859 												rName, rComment, rColor, nFlags, rMark ));
860 			}
861 
862 			aDocument.RenameTab( nNewTab, rName, sal_False );			// ohne Formel-Update
863 			aDocument.SetScenario( nNewTab, sal_True );
864 			aDocument.SetScenarioData( nNewTab, rComment, rColor, nFlags );
865 
866 			ScMarkData aDestMark = rMark;
867 			aDestMark.SelectOneTable( nNewTab );
868 
869 			//!		auf Filter / Buttons / Merging testen !
870 
871 			ScPatternAttr aProtPattern( aDocument.GetPool() );
872 			aProtPattern.GetItemSet().Put( ScProtectionAttr( sal_True ) );
873 			aDocument.ApplyPatternAreaTab( 0,0, MAXCOL,MAXROW, nNewTab, aProtPattern );
874 
875 			ScPatternAttr aPattern( aDocument.GetPool() );
876 			aPattern.GetItemSet().Put( ScMergeFlagAttr( SC_MF_SCENARIO ) );
877 			aPattern.GetItemSet().Put( ScProtectionAttr( sal_True ) );
878 			aDocument.ApplySelectionPattern( aPattern, aDestMark );
879 
880 			if (!bCopyAll)
881 				aDocument.SetVisible( nNewTab, sal_False );
882 
883 			//	dies ist dann das aktive Szenario
884 			aDocument.CopyScenario( nNewTab, nTab, sal_True );	// sal_True - nicht aus Szenario kopieren
885 
886 			if (nFlags & SC_SCENARIO_SHOWFRAME)
887 				PostPaint( 0,0,nTab, MAXCOL,MAXROW,nTab, PAINT_GRID );	// Rahmen painten
888 			PostPaintExtras();											// Tabellenreiter
889 			aModificator.SetDocumentModified();
890 
891 			SFX_APP()->Broadcast( SfxSimpleHint( SC_HINT_TABLES_CHANGED ) );
892 
893 			return nNewTab;
894 		}
895 	}
896 	return nTab;
897 }
898 
MoveTable(SCTAB nSrcTab,SCTAB nDestTab,sal_Bool bCopy,sal_Bool bRecord)899 sal_Bool ScDocShell::MoveTable( SCTAB nSrcTab, SCTAB nDestTab, sal_Bool bCopy, sal_Bool bRecord )
900 {
901 	ScDocShellModificator aModificator( *this );
902 
903     // #i92477# be consistent with ScDocFunc::InsertTable: any index past the last sheet means "append"
904     // #i101139# nDestTab must be the target position, not APPEND (for CopyTabProtection etc.)
905     if ( nDestTab >= aDocument.GetTableCount() )
906         nDestTab = aDocument.GetTableCount();
907 
908 	if (bCopy)
909 	{
910 		if (bRecord)
911 			aDocument.BeginDrawUndo();			// drawing layer must do its own undo actions
912 
913         String sSrcCodeName;
914         aDocument.GetCodeName( nSrcTab, sSrcCodeName );
915 		if (!aDocument.CopyTab( nSrcTab, nDestTab ))
916 		{
917 			//!	EndDrawUndo?
918 			return sal_False;
919 		}
920 		else
921 		{
922 			SCTAB nAdjSource = nSrcTab;
923 			if ( nDestTab <= nSrcTab )
924 				++nAdjSource;				// new position of source table after CopyTab
925 
926 			if ( aDocument.IsTabProtected( nAdjSource ) )
927                 aDocument.CopyTabProtection(nAdjSource, nDestTab);
928 
929 			if (bRecord)
930 			{
931 				SvShorts aSrcList;
932 				SvShorts aDestList;
933 				aSrcList.push_front(nSrcTab);
934 				aDestList.push_front(nDestTab);
935 				GetUndoManager()->AddUndoAction(
936 						new ScUndoCopyTab( this, aSrcList, aDestList ) );
937 			}
938 
939 			sal_Bool bVbaEnabled = aDocument.IsInVBAMode();
940                         if ( bVbaEnabled )
941                         {
942 			    StarBASIC* pStarBASIC = GetBasic();
943                             String aLibName( RTL_CONSTASCII_USTRINGPARAM( "Standard" ) );
944                             if ( GetBasicManager()->GetName().Len() > 0 )
945                             {
946                                 aLibName = GetBasicManager()->GetName();
947                                 pStarBASIC = GetBasicManager()->GetLib( aLibName );
948                             }
949                             SCTAB nTabToUse = nDestTab;
950                             if ( nDestTab == SC_TAB_APPEND )
951                                 nTabToUse = aDocument.GetMaxTableNumber() - 1;
952                             String sCodeName;
953                             String sSource;
954                             com::sun::star::uno::Reference< com::sun::star::script::XLibraryContainer > xLibContainer = GetBasicContainer();
955                             com::sun::star::uno::Reference< com::sun::star::container::XNameContainer > xLib;
956                             if( xLibContainer.is() )
957                             {
958                                 com::sun::star::uno::Any aLibAny = xLibContainer->getByName( aLibName );
959                                 aLibAny >>= xLib;
960                             }
961                             if( xLib.is() )
962                             {
963                                 rtl::OUString sRTLSource;
964                                 xLib->getByName( sSrcCodeName ) >>= sRTLSource;
965                                 sSource = sRTLSource;
966                             }
967                             VBA_InsertModule( aDocument, nTabToUse, sCodeName, sSource );
968                         }
969                 }
970 		Broadcast( ScTablesHint( SC_TAB_COPIED, nSrcTab, nDestTab ) );
971 	}
972 	else
973 	{
974 		if ( aDocument.GetChangeTrack() )
975 			return sal_False;
976 
977 		if ( nSrcTab<nDestTab && nDestTab!=SC_TAB_APPEND )
978 			nDestTab--;
979 
980 		if ( nSrcTab == nDestTab )
981 		{
982 			//!	allow only for api calls?
983 			return sal_True;	// nothing to do, but valid
984 		}
985 
986 		if (!aDocument.MoveTab( nSrcTab, nDestTab ))
987 			return sal_False;
988 		else if (bRecord)
989 		{
990 			SvShorts aSrcList;
991 			SvShorts aDestList;
992 			aSrcList.push_front(nSrcTab);
993 			aDestList.push_front(nDestTab);
994 			GetUndoManager()->AddUndoAction(
995 					new ScUndoMoveTab( this, aSrcList, aDestList ) );
996 		}
997 
998 		Broadcast( ScTablesHint( SC_TAB_MOVED, nSrcTab, nDestTab ) );
999 	}
1000 
1001 	PostPaintGridAll();
1002 	PostPaintExtras();
1003 	aModificator.SetDocumentModified();
1004 	SFX_APP()->Broadcast( SfxSimpleHint( SC_HINT_TABLES_CHANGED ) );
1005 
1006 	return sal_True;
1007 }
1008 
1009 
IMPL_LINK(ScDocShell,RefreshDBDataHdl,ScRefreshTimer *,pRefreshTimer)1010 IMPL_LINK( ScDocShell, RefreshDBDataHdl, ScRefreshTimer*, pRefreshTimer )
1011 {
1012 	ScDBDocFunc aFunc(*this);
1013 
1014 	sal_Bool bContinue = sal_True;
1015     ScDBData* pDBData = static_cast<ScDBData*>(pRefreshTimer);
1016 	ScImportParam aImportParam;
1017 	pDBData->GetImportParam( aImportParam );
1018 	if (aImportParam.bImport && !pDBData->HasImportSelection())
1019 	{
1020 		ScRange aRange;
1021 		pDBData->GetArea( aRange );
1022         bContinue = aFunc.DoImport( aRange.aStart.Tab(), aImportParam, NULL, sal_True, sal_False ); //! Api-Flag as parameter
1023 		// internal operations (sort, query, subtotal) only if no error
1024 		if (bContinue)
1025 		{
1026 			aFunc.RepeatDB( pDBData->GetName(), sal_True, sal_True );
1027 			RefreshPivotTables(aRange);
1028 		}
1029 	}
1030 
1031 	return bContinue != 0;
1032 }
1033 
1034