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