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 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 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 398 ScDBData* ScDocShell::GetOldAutoDBRange() 399 { 400 ScDBData* pRet = pOldAutoDBRange; 401 pOldAutoDBRange = NULL; 402 return pRet; // has to be deleted by caller! 403 } 404 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 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 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 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 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 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 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 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 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 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 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 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