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