sc/source/core/data/documen8.cxx

   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: documen8.cxx,v $
  10  * $Revision: 1.52.32.3 $
  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
  35 #define _ZFORLIST_DECLARE_TABLE
  36 #include "scitems.hxx"
  37 #include <svx/eeitem.hxx>
  38
  39 #include <tools/string.hxx>
  40 #include <svx/editobj.hxx>
  41 #include <svx/editstat.hxx>
  42 #include <svx/frmdiritem.hxx>
  43 #include <svx/langitem.hxx>
  44 #include <svx/linkmgr.hxx>
  45 #include <svx/scripttypeitem.hxx>
  46 #include <svx/unolingu.hxx>
  47 #include <sfx2/bindings.hxx>
  48 #include <sfx2/objsh.hxx>
  49 #include <sfx2/printer.hxx>
  50 #include <sfx2/viewfrm.hxx>
  51 #include <sfx2/viewsh.hxx>
  52 #include <svtools/flagitem.hxx>
  53 #include <svtools/intitem.hxx>
  54 #define _SVSTDARR_USHORTS
  55 #include <svtools/svstdarr.hxx>
  56 #include <svtools/zforlist.hxx>
  57 #include <svtools/zformat.hxx>
  58 #include <svtools/misccfg.hxx>
  59 #include <sfx2/app.hxx>
  60 #include <unotools/transliterationwrapper.hxx>
  61 #include <svtools/securityoptions.hxx>
  62
  63 #include <vcl/virdev.hxx>
  64 #include <vcl/msgbox.hxx>
  65
  66 #include "inputopt.hxx"
  67 #include "global.hxx"
  68 #include "table.hxx"
  69 #include "column.hxx"
  70 #include "cell.hxx"
  71 #include "poolhelp.hxx"
  72 #include "docpool.hxx"
  73 #include "stlpool.hxx"
  74 #include "stlsheet.hxx"
  75 #include "docoptio.hxx"
  76 #include "viewopti.hxx"
  77 #include "scextopt.hxx"
  78 #include "rechead.hxx"
  79 #include "ddelink.hxx"
  80 #include "scmatrix.hxx"
  81 #include "arealink.hxx"
  82 #include "dociter.hxx"
  83 #include "patattr.hxx"
  84 #include "hints.hxx"
  85 #include "editutil.hxx"
  86 #include "progress.hxx"
  87 #include "document.hxx"
  88 #include "chartlis.hxx"
  89 #include "chartlock.hxx"
  90 #include "refupdat.hxx"
  91 #include "validat.hxx"          // fuer HasMacroCalls
  92 #include "markdata.hxx"
  93 #include "scmod.hxx"
  94 #include "printopt.hxx"
  95 #include "externalrefmgr.hxx"
  96 #include "globstr.hrc"
  97 #include "sc.hrc"
  98 #include "charthelper.hxx"
  99 #include "macromgr.hxx"
 100 #include "dpobject.hxx"
 101
 102 #define GET_SCALEVALUE(set,id)  ((const SfxUInt16Item&)(set.Get( id ))).GetValue()
 103
 104 //      states for online spelling in the visible range (0 is set initially)
 105 #define VSPL_START      0
 106 #define VSPL_DONE       1
 107
 108
 109 // STATIC DATA -----------------------------------------------------------
 110
 111 //------------------------------------------------------------------------
 112
 113 void ScDocument::ImplCreateOptions()
 114 {
 115         pDocOptions  = new ScDocOptions();
 116         pViewOptions = new ScViewOptions();
 117 }
 118
 119 //------------------------------------------------------------------------
 120
 121 void ScDocument::ImplDeleteOptions()
 122 {
 123         delete pDocOptions;
 124         delete pViewOptions;
 125         delete pExtDocOptions;
 126 }
 127
 128 //------------------------------------------------------------------------
 129
 130 SfxPrinter* ScDocument::GetPrinter(BOOL bCreateIfNotExist)
 131 {
 132         if ( !pPrinter && bCreateIfNotExist )
 133         {
 134         SfxItemSet* pSet =
 135                         new SfxItemSet( *xPoolHelper->GetDocPool(),
 136                             SID_PRINTER_NOTFOUND_WARN,  SID_PRINTER_NOTFOUND_WARN,
 137                             SID_PRINTER_CHANGESTODOC,   SID_PRINTER_CHANGESTODOC,
 138                             SID_PRINT_SELECTEDSHEET,    SID_PRINT_SELECTEDSHEET,
 139                             SID_SCPRINTOPTIONS,         SID_SCPRINTOPTIONS,
 140                                                         NULL );
 141
 142         SfxMiscCfg* pOffCfg = SFX_APP()->GetMiscConfig();
 143                 if ( pOffCfg )
 144                 {
 145                         USHORT nFlags = 0;
 146             if ( pOffCfg->IsPaperOrientationWarning() )
 147                                 nFlags |= SFX_PRINTER_CHG_ORIENTATION;
 148                         if ( pOffCfg->IsPaperSizeWarning() )
 149                                 nFlags |= SFX_PRINTER_CHG_SIZE;
 150                         pSet->Put( SfxFlagItem( SID_PRINTER_CHANGESTODOC, nFlags ) );
 151                         pSet->Put( SfxBoolItem( SID_PRINTER_NOTFOUND_WARN, pOffCfg->IsNotFoundWarning() ) );
 152                 }
 153
 154                 pPrinter = new SfxPrinter( pSet );
 155                 pPrinter->SetMapMode( MAP_100TH_MM );
 156                 UpdateDrawPrinter();
 157                 pPrinter->SetDigitLanguage( SC_MOD()->GetOptDigitLanguage() );
 158         }
 159
 160         return pPrinter;
 161 }
 162
 163 //------------------------------------------------------------------------
 164
 165 void ScDocument::SetPrinter( SfxPrinter* pNewPrinter )
 166 {
 167         if ( pNewPrinter == pPrinter )
 168         {
 169                 //      #i6706# SetPrinter is called with the same printer again if
 170                 //      the JobSetup has changed. In that case just call UpdateDrawPrinter
 171                 //      (SetRefDevice for drawing layer) because of changed text sizes.
 172                 UpdateDrawPrinter();
 173         }
 174         else
 175         {
 176                 SfxPrinter* pOld = pPrinter;
 177                 pPrinter = pNewPrinter;
 178                 UpdateDrawPrinter();
 179                 pPrinter->SetDigitLanguage( SC_MOD()->GetOptDigitLanguage() );
 180                 delete pOld;
 181         }
 182         InvalidateTextWidth(NULL, NULL, FALSE);     // in both cases
 183 }
 184
 185 //------------------------------------------------------------------------
 186
 187 void ScDocument::SetPrintOptions()
 188 {
 189         if ( !pPrinter ) GetPrinter(); // setzt pPrinter
 190         DBG_ASSERT( pPrinter, "Error in printer creation :-/" );
 191
 192         if ( pPrinter )
 193         {
 194         SfxMiscCfg* pOffCfg = SFX_APP()->GetMiscConfig();
 195                 if ( pOffCfg )
 196                 {
 197                         SfxItemSet aOptSet( pPrinter->GetOptions() );
 198
 199                         USHORT nFlags = 0;
 200             if ( pOffCfg->IsPaperOrientationWarning() )
 201                                 nFlags |= SFX_PRINTER_CHG_ORIENTATION;
 202                         if ( pOffCfg->IsPaperSizeWarning() )
 203                                 nFlags |= SFX_PRINTER_CHG_SIZE;
 204                         aOptSet.Put( SfxFlagItem( SID_PRINTER_CHANGESTODOC, nFlags ) );
 205                         aOptSet.Put( SfxBoolItem( SID_PRINTER_NOTFOUND_WARN, pOffCfg->IsNotFoundWarning() ) );
 206
 207                         pPrinter->SetOptions( aOptSet );
 208                 }
 209         }
 210 }
 211
 212 //------------------------------------------------------------------------
 213
 214 VirtualDevice* ScDocument::GetVirtualDevice_100th_mm()
 215 {
 216         if (!pVirtualDevice_100th_mm)
 217         {
 218 //              pVirtualDevice_100th_mm = new VirtualDevice;
 219 //              pVirtualDevice_100th_mm->SetMapMode( MAP_100TH_MM );
 220
 221                 pVirtualDevice_100th_mm = new VirtualDevice( 1 );
 222                 pVirtualDevice_100th_mm->SetReferenceDevice(VirtualDevice::REFDEV_MODE_MSO1);
 223                 MapMode aMapMode( pVirtualDevice_100th_mm->GetMapMode() );
 224                 aMapMode.SetMapUnit( MAP_100TH_MM );
 225                 pVirtualDevice_100th_mm->SetMapMode( aMapMode );
 226         }
 227         return pVirtualDevice_100th_mm;
 228 }
 229
 230 OutputDevice* ScDocument::GetRefDevice()
 231 {
 232         // Create printer like ref device, see Writer...
 233         OutputDevice* pRefDevice = NULL;
 234     if ( SC_MOD()->GetInputOptions().GetTextWysiwyg() )
 235                 pRefDevice = GetPrinter();
 236         else
 237                 pRefDevice = GetVirtualDevice_100th_mm();
 238         return pRefDevice;
 239 }
 240
 241 //------------------------------------------------------------------------
 242
 243 void ScDocument::ModifyStyleSheet( SfxStyleSheetBase& rStyleSheet,
 244                                                                    const SfxItemSet&  rChanges )
 245 {
 246         SfxItemSet& rSet = rStyleSheet.GetItemSet();
 247
 248         switch ( rStyleSheet.GetFamily() )
 249         {
 250                 case SFX_STYLE_FAMILY_PAGE:
 251                         {
 252                                 const USHORT nOldScale            = GET_SCALEVALUE(rSet,ATTR_PAGE_SCALE);
 253                                 const USHORT nOldScaleToPages = GET_SCALEVALUE(rSet,ATTR_PAGE_SCALETOPAGES);
 254                                 rSet.Put( rChanges );
 255                                 const USHORT nNewScale            = GET_SCALEVALUE(rSet,ATTR_PAGE_SCALE);
 256                                 const USHORT nNewScaleToPages = GET_SCALEVALUE(rSet,ATTR_PAGE_SCALETOPAGES);
 257
 258                                 if ( (nOldScale != nNewScale) || (nOldScaleToPages != nNewScaleToPages) )
 259                                         InvalidateTextWidth( rStyleSheet.GetName() );
 260
 261                 if( SvtLanguageOptions().IsCTLFontEnabled() )
 262                 {
 263                     const SfxPoolItem *pItem = NULL;
 264                     if( rChanges.GetItemState(ATTR_WRITINGDIR, TRUE, &pItem ) == SFX_ITEM_SET )
 265                         ScChartHelper::DoUpdateAllCharts( this );
 266                 }
 267                         }
 268                         break;
 269
 270                 case SFX_STYLE_FAMILY_PARA:
 271                         {
 272                                 BOOL bNumFormatChanged;
 273                                 if ( ScGlobal::CheckWidthInvalidate( bNumFormatChanged,
 274                                                 rSet, rChanges ) )
 275                                         InvalidateTextWidth( NULL, NULL, bNumFormatChanged );
 276                                 ULONG nOldFormat =
 277                                         ((const SfxUInt32Item*)&rSet.Get(
 278                                         ATTR_VALUE_FORMAT ))->GetValue();
 279                                 ULONG nNewFormat =
 280                                         ((const SfxUInt32Item*)&rChanges.Get(
 281                                         ATTR_VALUE_FORMAT ))->GetValue();
 282                                 LanguageType eNewLang, eOldLang;
 283                                 eNewLang = eOldLang = LANGUAGE_DONTKNOW;
 284                                 if ( nNewFormat != nOldFormat )
 285                                 {
 286                                         SvNumberFormatter* pFormatter = GetFormatTable();
 287                                         eOldLang = pFormatter->GetEntry( nOldFormat )->GetLanguage();
 288                                         eNewLang = pFormatter->GetEntry( nNewFormat )->GetLanguage();
 289                                 }
 290
 291                                 // Bedeutung der Items in rChanges:
 292                                 //      Item gesetzt    - Aenderung uebernehmen
 293                                 //      Dontcare                - Default setzen
 294                                 //      Default                 - keine Aenderung
 295                                 // ("keine Aenderung" geht nicht mit PutExtended, darum Schleife)
 296                                 for (USHORT nWhich = ATTR_PATTERN_START; nWhich <= ATTR_PATTERN_END; nWhich++)
 297                                 {
 298                                         const SfxPoolItem* pItem;
 299                                         SfxItemState eState = rChanges.GetItemState( nWhich, FALSE, &pItem );
 300                                         if ( eState == SFX_ITEM_SET )
 301                                                 rSet.Put( *pItem );
 302                                         else if ( eState == SFX_ITEM_DONTCARE )
 303                                                 rSet.ClearItem( nWhich );
 304                                         // bei Default nichts
 305                                 }
 306
 307                                 if ( eNewLang != eOldLang )
 308                                         rSet.Put(
 309                                                 SvxLanguageItem( eNewLang, ATTR_LANGUAGE_FORMAT ) );
 310                         }
 311                         break;
 312         default:
 313         {
 314             // added to avoid warnings
 315         }
 316         }
 317 }
 318
 319 //------------------------------------------------------------------------
 320
 321 void ScDocument::CopyStdStylesFrom( ScDocument* pSrcDoc )
 322 {
 323     // #b5017505# number format exchange list has to be handled here, too
 324     NumFmtMergeHandler aNumFmtMergeHdl(this, pSrcDoc);
 325         xPoolHelper->GetStylePool()->CopyStdStylesFrom( pSrcDoc->xPoolHelper->GetStylePool() );
 326 }
 327
 328 //------------------------------------------------------------------------
 329
 330 void ScDocument::InvalidateTextWidth( const String& rStyleName )
 331 {
 332         const SCTAB nCount = GetTableCount();
 333         for ( SCTAB i=0; i<nCount && pTab[i]; i++ )
 334                 if ( pTab[i]->GetPageStyle() == rStyleName )
 335                         InvalidateTextWidth( i );
 336 }
 337
 338 //------------------------------------------------------------------------
 339
 340 void ScDocument::InvalidateTextWidth( SCTAB nTab )
 341 {
 342         ScAddress aAdrFrom( 0,    0,        nTab );
 343         ScAddress aAdrTo  ( MAXCOL, MAXROW, nTab );
 344     InvalidateTextWidth( &aAdrFrom, &aAdrTo, FALSE );
 345 }
 346
 347 //------------------------------------------------------------------------
 348
 349 BOOL ScDocument::IsPageStyleInUse( const String& rStrPageStyle, SCTAB* pInTab )
 350 {
 351         BOOL             bInUse = FALSE;
 352         const SCTAB nCount = GetTableCount();
 353         SCTAB i;
 354
 355         for ( i = 0; !bInUse && i < nCount && pTab[i]; i++ )
 356                 bInUse = ( pTab[i]->GetPageStyle() == rStrPageStyle );
 357
 358         if ( pInTab )
 359                 *pInTab = i-1;
 360
 361         return bInUse;
 362 }
 363
 364 //------------------------------------------------------------------------
 365
 366 BOOL ScDocument::RemovePageStyleInUse( const String& rStyle )
 367 {
 368         BOOL bWasInUse = FALSE;
 369         const SCTAB nCount = GetTableCount();
 370
 371         for ( SCTAB i=0; i<nCount && pTab[i]; i++ )
 372                 if ( pTab[i]->GetPageStyle() == rStyle )
 373                 {
 374                         bWasInUse = TRUE;
 375                         pTab[i]->SetPageStyle( ScGlobal::GetRscString(STR_STYLENAME_STANDARD) );
 376                 }
 377
 378         return bWasInUse;
 379 }
 380
 381 BOOL ScDocument::RenamePageStyleInUse( const String& rOld, const String& rNew )
 382 {
 383         BOOL bWasInUse = FALSE;
 384         const SCTAB nCount = GetTableCount();
 385
 386         for ( SCTAB i=0; i<nCount && pTab[i]; i++ )
 387                 if ( pTab[i]->GetPageStyle() == rOld )
 388                 {
 389                         bWasInUse = TRUE;
 390                         pTab[i]->SetPageStyle( rNew );
 391                 }
 392
 393         return bWasInUse;
 394 }
 395
 396 //------------------------------------------------------------------------
 397
 398 BYTE ScDocument::GetEditTextDirection(SCTAB nTab) const
 399 {
 400         EEHorizontalTextDirection eRet = EE_HTEXTDIR_DEFAULT;
 401
 402         String aStyleName = GetPageStyle( nTab );
 403         SfxStyleSheetBase* pStyle = xPoolHelper->GetStylePool()->Find( aStyleName, SFX_STYLE_FAMILY_PAGE );
 404         if ( pStyle )
 405         {
 406                 SfxItemSet& rStyleSet = pStyle->GetItemSet();
 407                 SvxFrameDirection eDirection = (SvxFrameDirection)
 408                         ((const SvxFrameDirectionItem&)rStyleSet.Get( ATTR_WRITINGDIR )).GetValue();
 409
 410                 if ( eDirection == FRMDIR_HORI_LEFT_TOP )
 411                         eRet = EE_HTEXTDIR_L2R;
 412                 else if ( eDirection == FRMDIR_HORI_RIGHT_TOP )
 413                         eRet = EE_HTEXTDIR_R2L;
 414                 // else (invalid for EditEngine): keep "default"
 415         }
 416
 417     return sal::static_int_cast<BYTE>(eRet);
 418 }
 419
 420 ScMacroManager* ScDocument::GetMacroManager()
 421 {
 422     if (!mpMacroMgr.get())
 423         mpMacroMgr.reset(new ScMacroManager(this));
 424     return mpMacroMgr.get();
 425 }
 426
 427 //------------------------------------------------------------------------
 428
 429 void ScDocument::InvalidateTextWidth( const ScAddress* pAdrFrom, const ScAddress* pAdrTo,
 430                                       BOOL bNumFormatChanged )
 431 {
 432     BOOL bBroadcast = (bNumFormatChanged && GetDocOptions().IsCalcAsShown() && !IsImportingXML() && !IsClipboard());
 433         if ( pAdrFrom && !pAdrTo )
 434         {
 435                 const SCTAB nTab = pAdrFrom->Tab();
 436
 437                 if ( pTab[nTab] )
 438             pTab[nTab]->InvalidateTextWidth( pAdrFrom, NULL, bNumFormatChanged, bBroadcast );
 439         }
 440         else
 441         {
 442                 const SCTAB nTabStart = pAdrFrom ? pAdrFrom->Tab() : 0;
 443                 const SCTAB nTabEnd   = pAdrTo   ? pAdrTo->Tab()   : MAXTAB;
 444
 445                 for ( SCTAB nTab=nTabStart; nTab<=nTabEnd; nTab++ )
 446                         if ( pTab[nTab] )
 447                 pTab[nTab]->InvalidateTextWidth( pAdrFrom, pAdrTo, bNumFormatChanged, bBroadcast );
 448         }
 449 }
 450
 451 //------------------------------------------------------------------------
 452
 453 #define CALCMAX                                 1000    // Berechnungen
 454 #define ABORT_EVENTS                    (INPUT_ANY & ~INPUT_TIMER & ~INPUT_OTHER)
 455
 456 BOOL ScDocument::IdleCalcTextWidth()                    // TRUE = demnaechst wieder versuchen
 457 {
 458     // #i75610# if a printer hasn't been set or created yet, don't create one for this
 459     if ( bIdleDisabled || IsInLinkUpdate() || GetPrinter(FALSE) == NULL )
 460                 return FALSE;
 461         bIdleDisabled = TRUE;
 462
 463 // ULONG nMs = 0;
 464 // USHORT nIter = 0;
 465
 466         const ULONG                     nStart   = Time::GetSystemTicks();
 467         double                          nPPTX    = 0.0;
 468         double                          nPPTY    = 0.0;
 469         OutputDevice*           pDev     = NULL;
 470         MapMode                         aOldMap;
 471         ScStyleSheet*           pStyle   = NULL;
 472         ScColumnIterator*       pColIter = NULL;
 473         ScTable*                        pTable   = NULL;
 474         ScColumn*                       pColumn  = NULL;
 475         ScBaseCell*                     pCell    = NULL;
 476         SCTAB                           nTab     = aCurTextWidthCalcPos.Tab();
 477         SCROW                           nRow     = aCurTextWidthCalcPos.Row();
 478         SCsCOL                          nCol     = aCurTextWidthCalcPos.Col();
 479         USHORT                          nRestart = 0;
 480         USHORT                          nZoom    = 0;
 481         BOOL                            bNeedMore= FALSE;
 482
 483         if ( !ValidRow(nRow) )
 484                 nRow = 0, nCol--;
 485         if ( nCol < 0 )
 486                 nCol = MAXCOL, nTab++;
 487         if ( !ValidTab(nTab) || !pTab[nTab] )
 488                 nTab = 0;
 489
 490 //      DBG_ERROR( String("Start = ") + String(nTab) + String(',') + String(nCol) + String(',') + String(nRow)  );
 491
 492         //      SearchMask/Family muss gemerkt werden,
 493         //      damit z.B. der Organizer nicht durcheinanderkommt, wenn zwischendurch eine
 494         //      Query-Box aufgemacht wird !!!
 495
 496         ScStyleSheetPool* pStylePool = xPoolHelper->GetStylePool();
 497         USHORT nOldMask = pStylePool->GetSearchMask();
 498         SfxStyleFamily eOldFam = pStylePool->GetSearchFamily();
 499
 500         pTable = pTab[nTab];
 501         pStylePool->SetSearchMask( SFX_STYLE_FAMILY_PAGE, SFXSTYLEBIT_ALL );
 502         pStyle = (ScStyleSheet*)pStylePool->Find( pTable->aPageStyle,
 503                                                                                           SFX_STYLE_FAMILY_PAGE );
 504
 505     DBG_ASSERT( pStyle, "Missing StyleSheet :-/" );
 506
 507         BOOL bProgress = FALSE;
 508         if ( pStyle && 0 == GET_SCALEVALUE(pStyle->GetItemSet(),ATTR_PAGE_SCALETOPAGES) )
 509         {
 510                 USHORT nCount = 0;
 511
 512                 nZoom    = GET_SCALEVALUE(pStyle->GetItemSet(),ATTR_PAGE_SCALE);
 513                 Fraction aZoomFract( nZoom, 100 );
 514                 pColumn  = &pTable->aCol[nCol];
 515                 pColIter = new ScColumnIterator( pColumn, nRow, MAXROW );
 516
 517                 while ( (nZoom > 0) && (nCount < CALCMAX) && (nRestart < 2) )
 518                 {
 519                         if ( pColIter->Next( nRow, pCell ) )
 520                         {
 521                                 if ( TEXTWIDTH_DIRTY == pCell->GetTextWidth() )
 522                                 {
 523                                         if ( !pDev )
 524                                         {
 525                                                 pDev = GetPrinter();
 526                                                 aOldMap = pDev->GetMapMode();
 527                                                 pDev->SetMapMode( MAP_PIXEL );  // wichtig fuer GetNeededSize
 528
 529                                                 Point aPix1000 = pDev->LogicToPixel( Point(1000,1000), MAP_TWIP );
 530                                                 nPPTX = aPix1000.X() / 1000.0;
 531                                                 nPPTY = aPix1000.Y() / 1000.0;
 532                                         }
 533                                         if ( !bProgress && pCell->GetCellType() == CELLTYPE_FORMULA
 534                                           && ((ScFormulaCell*)pCell)->GetDirty() )
 535                                         {
 536                                                 ScProgress::CreateInterpretProgress( this, FALSE );
 537                                                 bProgress = TRUE;
 538                                         }
 539
 540 //                                      DBG_ERROR( String("t,c,r = ") + String(nTab) + String(',') + String(nCol) + String(',') + String(nRow)  );
 541 //                                      DBG_ERROR( String("nOldWidth = ") + String(pCell->GetTextWidth()) );
 542
 543                                         USHORT nNewWidth = (USHORT)GetNeededSize( nCol, nRow, nTab,
 544                                                                                                                           pDev, nPPTX, nPPTY,
 545                                                                                                                           aZoomFract,aZoomFract, TRUE,
 546                                                                                                                           TRUE );       // bTotalSize
 547
 548 //                                      DBG_ERROR( String("nNewWidth = ") + String(nNewWidth) );
 549
 550                                         pCell->SetTextWidth( nNewWidth );
 551
 552                                         bNeedMore = TRUE;
 553                                 }
 554                         }
 555                         else
 556                         {
 557                                 BOOL bNewTab = FALSE;
 558
 559                                 nRow = 0;
 560                                 nCol--;
 561
 562                                 if ( nCol < 0 )
 563                                 {
 564                                         nCol = MAXCOL;
 565                                         nTab++;
 566                                         bNewTab = TRUE;
 567                                 }
 568
 569                                 if ( !ValidTab(nTab) || !pTab[nTab] )
 570                                 {
 571                                         nTab = 0;
 572                                         nRestart++;
 573                                         bNewTab = TRUE;
 574                                 }
 575
 576                                 if ( nRestart < 2 )
 577                                 {
 578                                         if ( bNewTab )
 579                                         {
 580                                                 pTable = pTab[nTab];
 581                                                 pStyle = (ScStyleSheet*)pStylePool->Find( pTable->aPageStyle,
 582                                                                                                                                   SFX_STYLE_FAMILY_PAGE );
 583
 584                                                 if ( pStyle )
 585                                                 {
 586                                                         SfxItemSet& rSet = pStyle->GetItemSet();
 587                                                         if ( GET_SCALEVALUE( rSet, ATTR_PAGE_SCALETOPAGES ) == 0 )
 588                                                                 nZoom = GET_SCALEVALUE(rSet, ATTR_PAGE_SCALE );
 589                                                         else
 590                                                                 nZoom = 0;
 591                                                 }
 592                                                 else
 593                                                 {
 594                                                         DBG_ERROR( "Missing StyleSheet :-/" );
 595                                                 }
 596                                         }
 597
 598                                         if ( nZoom > 0 )
 599                                         {
 600                                                 delete pColIter;
 601
 602                                                 pColumn  = &pTable->aCol[nCol];
 603                                                 pColIter = new ScColumnIterator( pColumn, nRow, MAXROW );
 604                                         }
 605                                         else
 606                                                 nTab++; // Tabelle nicht mit absolutem Zoom -> naechste
 607                                 }
 608                         }
 609
 610 // nIter = nCount;
 611
 612                         nCount++;
 613
 614                         // Idle Berechnung abbrechen, wenn Berechnungen laenger als
 615                         // 50ms dauern, oder nach 32 Berechnungen mal nachschauen, ob
 616                         // bestimmte Events anstehen, die Beachtung wuenschen:
 617
 618 // nMs = SysTicksToMs( GetSysTicks() - nStart );
 619
 620                         if (   ( 50L < Time::GetSystemTicks() - nStart )
 621                                 || ( !(nCount&31) && Application::AnyInput( ABORT_EVENTS ) ) )
 622                                 nCount = CALCMAX;
 623                 }
 624         }
 625         else
 626                 nTab++; // Tabelle nicht mit absolutem Zoom -> naechste
 627
 628         if ( bProgress )
 629                 ScProgress::DeleteInterpretProgress();
 630
 631         delete pColIter;
 632
 633 //      DBG_ERROR( String(nCount) + String(" End = ") + String(nTab) + String(',') + String(nCol) + String(',') + String(nRow)  );
 634
 635         if (pDev)
 636                 pDev->SetMapMode(aOldMap);
 637
 638         aCurTextWidthCalcPos.SetTab( nTab );
 639         aCurTextWidthCalcPos.SetRow( nRow );
 640         aCurTextWidthCalcPos.SetCol( (SCCOL)nCol );
 641
 642 // DBG_ERROR( String(nMs) + String(" ms (") + String(nIter) + String(')') );
 643
 644         pStylePool->SetSearchMask( eOldFam, nOldMask );
 645         bIdleDisabled = FALSE;
 646
 647         return bNeedMore;
 648 }
 649
 650 //------------------------------------------------------------------------
 651
 652 class ScSpellStatus
 653 {
 654 public:
 655         BOOL    bModified;
 656
 657         ScSpellStatus() : bModified(FALSE) {};
 658
 659         DECL_LINK (EventHdl, EditStatus*);
 660 };
 661
 662 IMPL_LINK( ScSpellStatus, EventHdl, EditStatus *, pStatus )
 663 {
 664         ULONG nStatus = pStatus->GetStatusWord();
 665         if ( nStatus & EE_STAT_WRONGWORDCHANGED )
 666                 bModified = TRUE;
 667
 668         return 0;
 669 }
 670
 671 //      SPELL_MAXCELLS muss mindestens 256 sein, solange am Iterator keine
 672 //      Start-Spalte gesetzt werden kann
 673
 674 //!     SPELL_MAXTEST fuer Timer und Idle unterschiedlich ???
 675
 676 //      SPELL_MAXTEST now divided between visible and rest of document
 677
 678 #define SPELL_MAXTEST_VIS       1
 679 #define SPELL_MAXTEST_ALL       3
 680 #define SPELL_MAXCELLS          256
 681
 682 BOOL ScDocument::OnlineSpellInRange( const ScRange& rSpellRange, ScAddress& rSpellPos,
 683                                                                          USHORT nMaxTest )
 684 {
 685         ScEditEngineDefaulter* pEngine = NULL;                          //! am Dokument speichern
 686         SfxItemSet* pDefaults = NULL;
 687         ScSpellStatus aStatus;
 688
 689         USHORT nCellCount = 0;                  // Zellen insgesamt
 690         USHORT nTestCount = 0;                  // Aufrufe Spelling
 691         BOOL bChanged = FALSE;                  // Aenderungen?
 692
 693         SCCOL nCol = rSpellRange.aStart.Col();          // iterator always starts on the left edge
 694         SCROW nRow = rSpellPos.Row();
 695         SCTAB nTab = rSpellPos.Tab();
 696         if ( !pTab[nTab] )                                                      // sheet deleted?
 697         {
 698                 nTab = rSpellRange.aStart.Tab();
 699                 nRow = rSpellRange.aStart.Row();
 700                 if ( !pTab[nTab] )
 701                 {
 702                         //      may happen for visible range
 703                         return FALSE;
 704                 }
 705         }
 706         ScHorizontalCellIterator aIter( this, nTab,
 707                                                                         rSpellRange.aStart.Col(), nRow,
 708                                                                         rSpellRange.aEnd.Col(), rSpellRange.aEnd.Row() );
 709         ScBaseCell* pCell = aIter.GetNext( nCol, nRow );
 710         //      skip everything left of rSpellPos:
 711         while ( pCell && nRow == rSpellPos.Row() && nCol < rSpellPos.Col() )
 712                 pCell = aIter.GetNext( nCol, nRow );
 713
 714         for (; pCell; pCell = aIter.GetNext(nCol, nRow))
 715         {
 716         if (pDPCollection && pDPCollection->HasDPTable(nCol, nRow, nTab))
 717             // Don't spell check within datapilot table.
 718             continue;
 719
 720                 CellType eType = pCell->GetCellType();
 721                 if ( eType == CELLTYPE_STRING || eType == CELLTYPE_EDIT )
 722                 {
 723                         if (!pEngine)
 724                         {
 725                                 //      #71154# ScTabEditEngine is needed
 726                                 //      because MapMode must be set for some old documents
 727                                 pEngine = new ScTabEditEngine( this );
 728                                 pEngine->SetControlWord( pEngine->GetControlWord() |
 729                                                         ( EE_CNTRL_ONLINESPELLING | EE_CNTRL_ALLOWBIGOBJS ) );
 730                                 pEngine->SetStatusEventHdl( LINK( &aStatus, ScSpellStatus, EventHdl ) );
 731                                 //      Delimiters hier wie in inputhdl.cxx !!!
 732                                 pEngine->SetWordDelimiters(
 733                                                         ScEditUtil::ModifyDelimiters( pEngine->GetWordDelimiters() ) );
 734                                 pDefaults = new SfxItemSet( pEngine->GetEmptyItemSet() );
 735
 736                 com::sun::star::uno::Reference<com::sun::star::linguistic2::XSpellChecker1> xXSpellChecker1( LinguMgr::GetSpellChecker() );
 737
 738                                 pEngine->SetSpeller( xXSpellChecker1 );
 739                         }
 740
 741                         const ScPatternAttr* pPattern = GetPattern( nCol, nRow, nTab );
 742                         pPattern->FillEditItemSet( pDefaults );
 743                         pEngine->SetDefaults( pDefaults, FALSE );                               //! noetig ?
 744
 745                         USHORT nCellLang = ((const SvxLanguageItem&)
 746                                                                         pPattern->GetItem(ATTR_FONT_LANGUAGE)).GetValue();
 747                         if ( nCellLang == LANGUAGE_SYSTEM )
 748                 nCellLang = Application::GetSettings().GetLanguage();   // never use SYSTEM for spelling
 749                         pEngine->SetDefaultLanguage( nCellLang );
 750
 751                         if ( eType == CELLTYPE_STRING )
 752                         {
 753                                 String aText;
 754                                 ((ScStringCell*)pCell)->GetString(aText);
 755                                 pEngine->SetText( aText );
 756                         }
 757                         else
 758                                 pEngine->SetText( *((ScEditCell*)pCell)->GetData() );
 759
 760                         aStatus.bModified = FALSE;
 761                         pEngine->CompleteOnlineSpelling();
 762                         if ( aStatus.bModified )                                // Fehler dazu oder weggekommen?
 763                         {
 764                                 BOOL bNeedEdit = TRUE;                                          //      Test auf einfachen Text
 765                                 if ( !pEngine->HasOnlineSpellErrors() )
 766                                 {
 767                                         ScEditAttrTester aTester( pEngine );
 768                                         bNeedEdit = aTester.NeedsObject();
 769                                 }
 770
 771                                 if ( bNeedEdit )
 772                                 {
 773                                         EditTextObject* pNewData = pEngine->CreateTextObject();
 774                                         if ( eType == CELLTYPE_EDIT )
 775                                                 ((ScEditCell*)pCell)->SetData( pNewData,
 776                                                         pEngine->GetEditTextObjectPool() );
 777                                         else
 778                                                 PutCell( nCol, nRow, nTab, new ScEditCell( pNewData,
 779                                                         this, pEngine->GetEditTextObjectPool() ) );
 780                                         delete pNewData;
 781                                 }
 782                                 else                                    // einfacher String
 783                                         PutCell( nCol, nRow, nTab, new ScStringCell( pEngine->GetText() ) );
 784
 785                                 //      Paint
 786                                 if (pShell)
 787                                 {
 788                                         //      #47751# Seitenvorschau ist davon nicht betroffen
 789                                         //      (sollte jedenfalls nicht)
 790                                         ScPaintHint aHint( ScRange( nCol, nRow, nTab ), PAINT_GRID );
 791                                         aHint.SetPrintFlag( FALSE );
 792                                         pShell->Broadcast( aHint );
 793                                 }
 794
 795                                 bChanged = TRUE;
 796                         }
 797
 798                         if ( ++nTestCount >= nMaxTest )                         // checked enough text?
 799                                 break;
 800                 }
 801
 802                 if ( ++nCellCount >= SPELL_MAXCELLS )                   // seen enough cells?
 803                         break;
 804         }
 805
 806         if ( pCell )
 807         {
 808                 ++nCol;                                                                                 // continue after last cell
 809                 if ( nCol > rSpellRange.aEnd.Col() )
 810                 {
 811                         nCol = rSpellRange.aStart.Col();
 812                         ++nRow;
 813                         if ( nRow > rSpellRange.aEnd.Row() )
 814                                 pCell = NULL;
 815                 }
 816         }
 817
 818         if (!pCell)                     // end of range reached -> next sheet
 819         {
 820                 ++nTab;
 821                 if ( nTab > rSpellRange.aEnd.Tab() || !pTab[nTab] )
 822                         nTab = rSpellRange.aStart.Tab();
 823                 nCol = rSpellRange.aStart.Col();
 824                 nRow = rSpellRange.aStart.Row();
 825
 826                 nVisSpellState = VSPL_DONE;             //! only if this is for the visible range
 827         }
 828         rSpellPos.Set( nCol, nRow, nTab );
 829
 830         delete pDefaults;
 831         delete pEngine;                 // bevor aStatus out of scope geht
 832
 833         return bChanged;
 834 }
 835
 836
 837 BOOL ScDocument::ContinueOnlineSpelling()
 838 {
 839         if ( bIdleDisabled || !pDocOptions->IsAutoSpell() || (pShell && pShell->IsReadOnly()) )
 840                 return FALSE;
 841
 842     // #i48433# set bInsertingFromOtherDoc flag so there are no broadcasts when PutCell is called
 843     // (same behavior as in RemoveAutoSpellObj: just transfer the broadcaster)
 844     BOOL bOldInserting = IsInsertingFromOtherDoc();
 845     SetInsertingFromOtherDoc( TRUE );
 846
 847         //!     use one EditEngine for both calls
 848
 849         //      #41504# first check visible range
 850         BOOL bResult = OnlineSpellInRange( aVisSpellRange, aVisSpellPos, SPELL_MAXTEST_VIS );
 851
 852         //      during first pass through visible range, always continue
 853         if ( nVisSpellState == VSPL_START )
 854                 bResult = TRUE;
 855
 856         if (bResult)
 857         {
 858                 //      if errors found, continue there
 859                 OnlineSpellInRange( aVisSpellRange, aVisSpellPos, SPELL_MAXTEST_ALL );
 860         }
 861         else
 862         {
 863                 //      if nothing found there, continue with rest of document
 864                 ScRange aTotalRange( 0,0,0, MAXCOL,MAXROW,MAXTAB );
 865                 bResult = OnlineSpellInRange( aTotalRange, aOnlineSpellPos, SPELL_MAXTEST_ALL );
 866         }
 867
 868     SetInsertingFromOtherDoc( bOldInserting );
 869
 870         return bResult;
 871 }
 872
 873
 874 void ScDocument::SetOnlineSpellPos( const ScAddress& rPos )
 875 {
 876         aOnlineSpellPos = rPos;
 877
 878         //      skip visible area for aOnlineSpellPos
 879         if ( aVisSpellRange.In( aOnlineSpellPos ) )
 880                 aOnlineSpellPos = aVisSpellRange.aEnd;
 881 }
 882
 883 BOOL ScDocument::SetVisibleSpellRange( const ScRange& rNewRange )
 884 {
 885         BOOL bChange = ( aVisSpellRange != rNewRange );
 886         if (bChange)
 887         {
 888                 //      continue spelling through visible range when scrolling down
 889                 BOOL bContDown = ( nVisSpellState == VSPL_START && rNewRange.In( aVisSpellPos ) &&
 890                                                         rNewRange.aStart.Row() >  aVisSpellRange.aStart.Row() &&
 891                                                         rNewRange.aStart.Col() == aVisSpellRange.aStart.Col() &&
 892                                                         rNewRange.aEnd.Col()   == aVisSpellRange.aEnd.Col() );
 893
 894                 aVisSpellRange = rNewRange;
 895
 896                 if ( !bContDown )
 897                 {
 898                         aVisSpellPos = aVisSpellRange.aStart;
 899                         nVisSpellState = VSPL_START;
 900                 }
 901
 902                 //      skip visible area for aOnlineSpellPos
 903                 if ( aVisSpellRange.In( aOnlineSpellPos ) )
 904                         aOnlineSpellPos = aVisSpellRange.aEnd;
 905         }
 906         return bChange;
 907 }
 908
 909 void ScDocument::RemoveAutoSpellObj()
 910 {
 911         //      alle Spelling-Informationen entfernen
 912
 913         for (SCTAB nTab=0; nTab<=MAXTAB && pTab[nTab]; nTab++)
 914                 pTab[nTab]->RemoveAutoSpellObj();
 915 }
 916
 917 //------------------------------------------------------------------------
 918
 919 BOOL ScDocument::IdleCheckLinks()                       // TRUE = demnaechst wieder versuchen
 920 {
 921         BOOL bAnyLeft = FALSE;
 922
 923     if (pLinkManager)
 924     {
 925         const ::sfx2::SvBaseLinks& rLinks = pLinkManager->GetLinks();
 926         USHORT nCount = rLinks.Count();
 927         for (USHORT i=0; i<nCount; i++)
 928         {
 929             ::sfx2::SvBaseLink* pBase = *rLinks[i];
 930             if (pBase->ISA(ScDdeLink))
 931             {
 932                 ScDdeLink* pDdeLink = (ScDdeLink*)pBase;
 933                 if (pDdeLink->NeedsUpdate())
 934                 {
 935                     pDdeLink->TryUpdate();
 936                     if (pDdeLink->NeedsUpdate())        // war nix?
 937                         bAnyLeft = TRUE;
 938                 }
 939             }
 940         }
 941     }
 942
 943         return bAnyLeft;
 944 }
 945
 946 void ScDocument::SaveDdeLinks(SvStream& rStream) const
 947 {
 948         //      bei 4.0-Export alle mit Modus != DEFAULT weglassen
 949         BOOL bExport40 = ( rStream.GetVersion() <= SOFFICE_FILEFORMAT_40 );
 950
 951         const ::sfx2::SvBaseLinks& rLinks = pLinkManager->GetLinks();
 952         USHORT nCount = rLinks.Count();
 953
 954         //      erstmal zaehlen...
 955
 956         USHORT nDdeCount = 0;
 957         USHORT i;
 958         for (i=0; i<nCount; i++)
 959         {
 960                 ::sfx2::SvBaseLink* pBase = *rLinks[i];
 961                 if (pBase->ISA(ScDdeLink))
 962                         if ( !bExport40 || ((ScDdeLink*)pBase)->GetMode() == SC_DDE_DEFAULT )
 963                                 ++nDdeCount;
 964         }
 965
 966         //      Header
 967
 968         ScMultipleWriteHeader aHdr( rStream );
 969         rStream << nDdeCount;
 970
 971         //      Links speichern
 972
 973         for (i=0; i<nCount; i++)
 974         {
 975                 ::sfx2::SvBaseLink* pBase = *rLinks[i];
 976                 if (pBase->ISA(ScDdeLink))
 977                 {
 978                         ScDdeLink* pLink = (ScDdeLink*)pBase;
 979                         if ( !bExport40 || pLink->GetMode() == SC_DDE_DEFAULT )
 980                                 pLink->Store( rStream, aHdr );
 981                 }
 982         }
 983 }
 984
 985 void ScDocument::LoadDdeLinks(SvStream& rStream)
 986 {
 987         ScMultipleReadHeader aHdr( rStream );
 988
 989         USHORT nCount;
 990         rStream >> nCount;
 991         for (USHORT i=0; i<nCount; i++)
 992         {
 993                 ScDdeLink* pLink = new ScDdeLink( this, rStream, aHdr );
 994                 pLinkManager->InsertDDELink( pLink,
 995                                                         pLink->GetAppl(), pLink->GetTopic(), pLink->GetItem() );
 996         }
 997 }
 998
 999 BOOL ScDocument::HasDdeLinks() const
1000 {
1001         if (pLinkManager)                       // Clipboard z.B. hat keinen LinkManager
1002         {
1003                 const ::sfx2::SvBaseLinks& rLinks = pLinkManager->GetLinks();
1004                 USHORT nCount = rLinks.Count();
1005                 for (USHORT i=0; i<nCount; i++)
1006                         if ((*rLinks[i])->ISA(ScDdeLink))
1007                                 return TRUE;
1008         }
1009
1010         return FALSE;
1011 }
1012
1013 void ScDocument::SetInLinkUpdate(BOOL bSet)
1014 {
1015         //      called from TableLink and AreaLink
1016
1017         DBG_ASSERT( bInLinkUpdate != bSet, "SetInLinkUpdate twice" );
1018         bInLinkUpdate = bSet;
1019 }
1020
1021 BOOL ScDocument::IsInLinkUpdate() const
1022 {
1023     return bInLinkUpdate || IsInDdeLinkUpdate();
1024 }
1025
1026 void ScDocument::UpdateExternalRefLinks()
1027 {
1028     if (!pLinkManager)
1029         return;
1030
1031     const ::sfx2::SvBaseLinks& rLinks = pLinkManager->GetLinks();
1032     USHORT nCount = rLinks.Count();
1033
1034     bool bAny = false;
1035     for (USHORT i = 0; i < nCount; ++i)
1036     {
1037         ::sfx2::SvBaseLink* pBase = *rLinks[i];
1038         ScExternalRefLink* pRefLink = dynamic_cast<ScExternalRefLink*>(pBase);
1039         if (pRefLink)
1040         {
1041             pRefLink->Update();
1042             bAny = true;
1043         }
1044     }
1045     if (bAny)
1046     {
1047         TrackFormulas();
1048         pShell->Broadcast( SfxSimpleHint(FID_DATACHANGED) );
1049         ResetChanged( ScRange(0, 0, 0, MAXCOL, MAXROW, MAXTAB) );
1050
1051         // #i101960# set document modified, as in TrackTimeHdl for DDE links
1052         if (!pShell->IsModified())
1053         {
1054             pShell->SetModified( TRUE );
1055             SfxBindings* pBindings = GetViewBindings();
1056             if (pBindings)
1057             {
1058                 pBindings->Invalidate( SID_SAVEDOC );
1059                 pBindings->Invalidate( SID_DOC_MODIFIED );
1060             }
1061         }
1062     }
1063 }
1064
1065 void ScDocument::UpdateDdeLinks()
1066 {
1067     if (pLinkManager)
1068     {
1069         const ::sfx2::SvBaseLinks& rLinks = pLinkManager->GetLinks();
1070         USHORT nCount = rLinks.Count();
1071         USHORT i;
1072
1073         //  #49226# falls das Updaten laenger dauert, erstmal alle Werte
1074         //  zuruecksetzen, damit nichts altes (falsches) stehen bleibt
1075         BOOL bAny = FALSE;
1076         for (i=0; i<nCount; i++)
1077         {
1078             ::sfx2::SvBaseLink* pBase = *rLinks[i];
1079             if (pBase->ISA(ScDdeLink))
1080             {
1081                 ((ScDdeLink*)pBase)->ResetValue();
1082                 bAny = TRUE;
1083             }
1084         }
1085         if (bAny)
1086         {
1087             //  Formeln berechnen und painten wie im TrackTimeHdl
1088             TrackFormulas();
1089             pShell->Broadcast( SfxSimpleHint( FID_DATACHANGED ) );
1090             ResetChanged( ScRange(0,0,0,MAXCOL,MAXROW,MAXTAB) );
1091
1092             //  wenn FID_DATACHANGED irgendwann mal asynchron werden sollte
1093             //  (z.B. mit Invalidate am Window), muss hier ein Update erzwungen werden.
1094         }
1095
1096         //  nun wirklich updaten...
1097         for (i=0; i<nCount; i++)
1098         {
1099             ::sfx2::SvBaseLink* pBase = *rLinks[i];
1100             if (pBase->ISA(ScDdeLink))
1101                 ((ScDdeLink*)pBase)->TryUpdate();       // bei DDE-Links TryUpdate statt Update
1102         }
1103     }
1104 }
1105
1106 BOOL ScDocument::UpdateDdeLink( const String& rAppl, const String& rTopic, const String& rItem )
1107 {
1108         //      fuer refresh() per StarOne Api
1109         //      ResetValue() fuer einzelnen Link nicht noetig
1110         //!     wenn's mal alles asynchron wird, aber auch hier
1111
1112         BOOL bFound = FALSE;
1113     if (pLinkManager)
1114     {
1115         const ::sfx2::SvBaseLinks& rLinks = pLinkManager->GetLinks();
1116         USHORT nCount = rLinks.Count();
1117         for (USHORT i=0; i<nCount; i++)
1118         {
1119             ::sfx2::SvBaseLink* pBase = *rLinks[i];
1120             if (pBase->ISA(ScDdeLink))
1121             {
1122                 ScDdeLink* pDdeLink = (ScDdeLink*)pBase;
1123                 if ( pDdeLink->GetAppl() == rAppl &&
1124                      pDdeLink->GetTopic() == rTopic &&
1125                      pDdeLink->GetItem() == rItem )
1126                 {
1127                     pDdeLink->TryUpdate();
1128                     bFound = TRUE;          // koennen theoretisch mehrere sein (Mode), darum weitersuchen
1129                 }
1130             }
1131         }
1132     }
1133         return bFound;
1134 }
1135
1136 void ScDocument::DisconnectDdeLinks()
1137 {
1138         if (pLinkManager)
1139         {
1140                 const ::sfx2::SvBaseLinks& rLinks = pLinkManager->GetLinks();
1141                 USHORT nCount = rLinks.Count();
1142                 for (USHORT i=0; i<nCount; i++)
1143                 {
1144                         ::sfx2::SvBaseLink* pBase = *rLinks[i];
1145                         if (pBase->ISA(ScDdeLink))
1146                                 pBase->Disconnect();                    // bleibt im LinkManager eingetragen
1147                 }
1148         }
1149 }
1150
1151 void ScDocument::CopyDdeLinks( ScDocument* pDestDoc ) const
1152 {
1153         if (bIsClip)            // aus Stream erzeugen
1154         {
1155                 if (pClipData)
1156                 {
1157                         pClipData->Seek(0);
1158                         pDestDoc->LoadDdeLinks(*pClipData);
1159                 }
1160         }
1161     else if (pLinkManager)              // Links direkt kopieren
1162         {
1163                 const ::sfx2::SvBaseLinks& rLinks = pLinkManager->GetLinks();
1164                 USHORT nCount = rLinks.Count();
1165                 for (USHORT i=0; i<nCount; i++)
1166                 {
1167                         ::sfx2::SvBaseLink* pBase = *rLinks[i];
1168                         if (pBase->ISA(ScDdeLink))
1169                         {
1170                                 ScDdeLink* pNew = new ScDdeLink( pDestDoc, *(ScDdeLink*)pBase );
1171
1172                                 pDestDoc->pLinkManager->InsertDDELink( pNew,
1173                                                                 pNew->GetAppl(), pNew->GetTopic(), pNew->GetItem() );
1174                         }
1175                 }
1176         }
1177 }
1178
1179 USHORT ScDocument::GetDdeLinkCount() const
1180 {
1181         USHORT nDdeCount = 0;
1182         if (pLinkManager)
1183         {
1184                 const ::sfx2::SvBaseLinks& rLinks = pLinkManager->GetLinks();
1185                 USHORT nCount = rLinks.Count();
1186                 for (USHORT i=0; i<nCount; i++)
1187                         if ((*rLinks[i])->ISA(ScDdeLink))
1188                                 ++nDdeCount;
1189         }
1190         return nDdeCount;
1191 }
1192
1193 // ----------------------------------------------------------------------------
1194
1195 namespace {
1196
1197 /** Tries to find the specified DDE link.
1198     @param pnDdePos  (out-param) if not 0, the index of the DDE link is returned here
1199                      (does not include other links from link manager).
1200     @return  The DDE link, if it exists, otherwise 0. */
1201 ScDdeLink* lclGetDdeLink(
1202         const SvxLinkManager* pLinkManager,
1203         const String& rAppl, const String& rTopic, const String& rItem, BYTE nMode,
1204         USHORT* pnDdePos = NULL )
1205 {
1206     if( pLinkManager )
1207     {
1208         const ::sfx2::SvBaseLinks& rLinks = pLinkManager->GetLinks();
1209         USHORT nCount = rLinks.Count();
1210         if( pnDdePos ) *pnDdePos = 0;
1211         for( USHORT nIndex = 0; nIndex < nCount; ++nIndex )
1212         {
1213             ::sfx2::SvBaseLink* pLink = *rLinks[ nIndex ];
1214             if( ScDdeLink* pDdeLink = PTR_CAST( ScDdeLink, pLink ) )
1215             {
1216                 if( (pDdeLink->GetAppl() == rAppl) &&
1217                     (pDdeLink->GetTopic() == rTopic) &&
1218                     (pDdeLink->GetItem() == rItem) &&
1219                     ((nMode == SC_DDE_IGNOREMODE) || (nMode == pDdeLink->GetMode())) )
1220                     return pDdeLink;
1221                 if( pnDdePos ) ++*pnDdePos;
1222             }
1223         }
1224     }
1225     return NULL;
1226 }
1227
1228 /** Returns a pointer to the specified DDE link.
1229     @param nDdePos  Index of the DDE link (does not include other links from link manager).
1230     @return  The DDE link, if it exists, otherwise 0. */
1231 ScDdeLink* lclGetDdeLink( const SvxLinkManager* pLinkManager, USHORT nDdePos )
1232 {
1233     if( pLinkManager )
1234     {
1235         const ::sfx2::SvBaseLinks& rLinks = pLinkManager->GetLinks();
1236         USHORT nCount = rLinks.Count();
1237         USHORT nDdeIndex = 0;       // counts only the DDE links
1238         for( USHORT nIndex = 0; nIndex < nCount; ++nIndex )
1239         {
1240             ::sfx2::SvBaseLink* pLink = *rLinks[ nIndex ];
1241             if( ScDdeLink* pDdeLink = PTR_CAST( ScDdeLink, pLink ) )
1242             {
1243                 if( nDdeIndex == nDdePos )
1244                     return pDdeLink;
1245                 ++nDdeIndex;
1246             }
1247         }
1248     }
1249     return NULL;
1250 }
1251
1252 } // namespace
1253
1254 // ----------------------------------------------------------------------------
1255
1256 bool ScDocument::FindDdeLink( const String& rAppl, const String& rTopic, const String& rItem, BYTE nMode, USHORT& rnDdePos )
1257 {
1258     return lclGetDdeLink( pLinkManager, rAppl, rTopic, rItem, nMode, &rnDdePos ) != NULL;
1259 }
1260
1261 bool ScDocument::GetDdeLinkData( USHORT nDdePos, String& rAppl, String& rTopic, String& rItem ) const
1262 {
1263     if( const ScDdeLink* pDdeLink = lclGetDdeLink( pLinkManager, nDdePos ) )
1264     {
1265         rAppl  = pDdeLink->GetAppl();
1266         rTopic = pDdeLink->GetTopic();
1267         rItem  = pDdeLink->GetItem();
1268         return true;
1269         }
1270     return false;
1271 }
1272
1273 bool ScDocument::GetDdeLinkMode( USHORT nDdePos, BYTE& rnMode ) const
1274 {
1275     if( const ScDdeLink* pDdeLink = lclGetDdeLink( pLinkManager, nDdePos ) )
1276     {
1277         rnMode = pDdeLink->GetMode();
1278         return true;
1279     }
1280     return false;
1281 }
1282
1283 const ScMatrix* ScDocument::GetDdeLinkResultMatrix( USHORT nDdePos ) const
1284 {
1285     const ScDdeLink* pDdeLink = lclGetDdeLink( pLinkManager, nDdePos );
1286     return pDdeLink ? pDdeLink->GetResult() : NULL;
1287 }
1288
1289 bool ScDocument::CreateDdeLink( const String& rAppl, const String& rTopic, const String& rItem, BYTE nMode, ScMatrix* pResults )
1290 {
1291     /*  Create a DDE link without updating it (i.e. for Excel import), to prevent
1292         unwanted connections. First try to find existing link. Set result array
1293         on existing and new links. */
1294     //! store DDE links additionally at document (for efficiency)?
1295     DBG_ASSERT( nMode != SC_DDE_IGNOREMODE, "ScDocument::CreateDdeLink - SC_DDE_IGNOREMODE not allowed here" );
1296     if( pLinkManager && (nMode != SC_DDE_IGNOREMODE) )
1297     {
1298         ScDdeLink* pDdeLink = lclGetDdeLink( pLinkManager, rAppl, rTopic, rItem, nMode );
1299         if( !pDdeLink )
1300         {
1301             // create a new DDE link, but without TryUpdate
1302             pDdeLink = new ScDdeLink( this, rAppl, rTopic, rItem, nMode );
1303             pLinkManager->InsertDDELink( pDdeLink, rAppl, rTopic, rItem );
1304         }
1305
1306         // insert link results
1307         if( pResults )
1308             pDdeLink->SetResult( pResults );
1309
1310         return true;
1311     }
1312     return false;
1313 }
1314
1315 bool ScDocument::SetDdeLinkResultMatrix( USHORT nDdePos, ScMatrix* pResults )
1316 {
1317     if( ScDdeLink* pDdeLink = lclGetDdeLink( pLinkManager, nDdePos ) )
1318     {
1319         pDdeLink->SetResult( pResults );
1320         return true;
1321     }
1322     return false;
1323 }
1324
1325 //------------------------------------------------------------------------
1326
1327 BOOL ScDocument::HasAreaLinks() const
1328 {
1329         if (pLinkManager)                       // Clipboard z.B. hat keinen LinkManager
1330         {
1331                 const ::sfx2::SvBaseLinks& rLinks = pLinkManager->GetLinks();
1332                 USHORT nCount = rLinks.Count();
1333                 for (USHORT i=0; i<nCount; i++)
1334                         if ((*rLinks[i])->ISA(ScAreaLink))
1335                                 return TRUE;
1336         }
1337
1338         return FALSE;
1339 }
1340
1341 void ScDocument::UpdateAreaLinks()
1342 {
1343     if (pLinkManager)
1344     {
1345         const ::sfx2::SvBaseLinks& rLinks = pLinkManager->GetLinks();
1346         USHORT nCount = rLinks.Count();
1347         for (USHORT i=0; i<nCount; i++)
1348         {
1349             ::sfx2::SvBaseLink* pBase = *rLinks[i];
1350             if (pBase->ISA(ScAreaLink))
1351                 pBase->Update();
1352         }
1353     }
1354 }
1355
1356 void ScDocument::DeleteAreaLinksOnTab( SCTAB nTab )
1357 {
1358     if (pLinkManager)
1359     {
1360         const ::sfx2::SvBaseLinks& rLinks = pLinkManager->GetLinks();
1361         USHORT nPos = 0;
1362         while ( nPos < rLinks.Count() )
1363         {
1364             const ::sfx2::SvBaseLink* pBase = *rLinks[nPos];
1365             if ( pBase->ISA(ScAreaLink) &&
1366                  static_cast<const ScAreaLink*>(pBase)->GetDestArea().aStart.Tab() == nTab )
1367                 pLinkManager->Remove( nPos );
1368             else
1369                 ++nPos;
1370         }
1371     }
1372 }
1373
1374 void ScDocument::UpdateRefAreaLinks( UpdateRefMode eUpdateRefMode,
1375                                                          const ScRange& rRange, SCsCOL nDx, SCsROW nDy, SCsTAB nDz )
1376 {
1377     if (pLinkManager)
1378     {
1379         bool bAnyUpdate = false;
1380
1381         const ::sfx2::SvBaseLinks& rLinks = pLinkManager->GetLinks();
1382         USHORT nCount = rLinks.Count();
1383         for (USHORT i=0; i<nCount; i++)
1384         {
1385             ::sfx2::SvBaseLink* pBase = *rLinks[i];
1386             if (pBase->ISA(ScAreaLink))
1387             {
1388                 ScAreaLink* pLink = (ScAreaLink*) pBase;
1389                 ScRange aOutRange = pLink->GetDestArea();
1390
1391                 SCCOL nCol1 = aOutRange.aStart.Col();
1392                 SCROW nRow1 = aOutRange.aStart.Row();
1393                 SCTAB nTab1 = aOutRange.aStart.Tab();
1394                 SCCOL nCol2 = aOutRange.aEnd.Col();
1395                 SCROW nRow2 = aOutRange.aEnd.Row();
1396                 SCTAB nTab2 = aOutRange.aEnd.Tab();
1397
1398                 ScRefUpdateRes eRes =
1399                     ScRefUpdate::Update( this, eUpdateRefMode,
1400                         rRange.aStart.Col(), rRange.aStart.Row(), rRange.aStart.Tab(),
1401                         rRange.aEnd.Col(), rRange.aEnd.Row(), rRange.aEnd.Tab(), nDx, nDy, nDz,
1402                         nCol1, nRow1, nTab1, nCol2, nRow2, nTab2 );
1403                 if ( eRes != UR_NOTHING )
1404                 {
1405                     pLink->SetDestArea( ScRange( nCol1, nRow1, nTab1, nCol2, nRow2, nTab2 ) );
1406                     bAnyUpdate = true;
1407                 }
1408             }
1409         }
1410
1411         if ( bAnyUpdate )
1412         {
1413             // #i52120# Look for duplicates (after updating all positions).
1414             // If several links start at the same cell, the one with the lower index is removed
1415             // (file format specifies only one link definition for a cell).
1416
1417             USHORT nFirstIndex = 0;
1418             while ( nFirstIndex < nCount )
1419             {
1420                 bool bFound = false;
1421                 ::sfx2::SvBaseLink* pFirst = *rLinks[nFirstIndex];
1422                 if ( pFirst->ISA(ScAreaLink) )
1423                 {
1424                     ScAddress aFirstPos = static_cast<ScAreaLink*>(pFirst)->GetDestArea().aStart;
1425                     for ( USHORT nSecondIndex = nFirstIndex + 1; nSecondIndex < nCount && !bFound; ++nSecondIndex )
1426                     {
1427                         ::sfx2::SvBaseLink* pSecond = *rLinks[nSecondIndex];
1428                         if ( pSecond->ISA(ScAreaLink) &&
1429                              static_cast<ScAreaLink*>(pSecond)->GetDestArea().aStart == aFirstPos )
1430                         {
1431                             // remove the first link, exit the inner loop, don't increment nFirstIndex
1432                             pLinkManager->Remove( pFirst );
1433                             nCount = rLinks.Count();
1434                             bFound = true;
1435                         }
1436                     }
1437                 }
1438                 if (!bFound)
1439                     ++nFirstIndex;
1440             }
1441         }
1442     }
1443 }
1444
1445 //------------------------------------------------------------------------
1446
1447 // TimerDelays etc.
1448 void ScDocument::KeyInput( const KeyEvent& )
1449 {
1450         if ( pChartListenerCollection->GetCount() )
1451                 pChartListenerCollection->StartTimer();
1452     if( apTemporaryChartLock.get() )
1453         apTemporaryChartLock->StartOrContinueLocking();
1454 }
1455
1456 //      ----------------------------------------------------------------------------
1457
1458 BOOL ScDocument::CheckMacroWarn()
1459 {
1460         //      The check for macro configuration, macro warning and disabling is now handled
1461         //      in SfxObjectShell::AdjustMacroMode, called by SfxObjectShell::CallBasic.
1462
1463         return TRUE;
1464 }
1465
1466 //------------------------------------------------------------------------
1467
1468 SfxBindings* ScDocument::GetViewBindings()
1469 {
1470         //      used to invalidate slots after changes to this document
1471
1472         if ( !pShell )
1473                 return NULL;            // no ObjShell -> no view
1474
1475         //      first check current view
1476         SfxViewFrame* pViewFrame = SfxViewFrame::Current();
1477         if ( pViewFrame && pViewFrame->GetObjectShell() != pShell )             // wrong document?
1478                 pViewFrame = NULL;
1479
1480         //      otherwise use first view for this doc
1481         if ( !pViewFrame )
1482                 pViewFrame = SfxViewFrame::GetFirst( pShell );
1483
1484         if (pViewFrame)
1485                 return &pViewFrame->GetBindings();
1486         else
1487                 return NULL;
1488 }
1489
1490 //------------------------------------------------------------------------
1491
1492 void lcl_TransliterateEditEngine( ScEditEngineDefaulter& rEngine,
1493                                                                 utl::TransliterationWrapper& rTranslitarationWrapper,
1494                                                                 BOOL bConsiderLanguage, ScDocument* pDoc )
1495 {
1496         //!     should use TransliterateText method of EditEngine instead, when available!
1497
1498         sal_uInt16 nLanguage = LANGUAGE_SYSTEM;
1499
1500         USHORT nParCount = rEngine.GetParagraphCount();
1501         for (USHORT nPar=0; nPar<nParCount; nPar++)
1502         {
1503                 SvUShorts aPortions;
1504                 rEngine.GetPortions( (USHORT)nPar, aPortions );
1505
1506                 for ( USHORT nPos = aPortions.Count(); nPos; )
1507                 {
1508                         --nPos;
1509                         USHORT nEnd = aPortions.GetObject( nPos );
1510                         USHORT nStart = nPos ? aPortions.GetObject( nPos - 1 ) : 0;
1511
1512                         ESelection aSel( nPar, nStart, nPar, nEnd );
1513                         String aOldStr = rEngine.GetText( aSel );
1514                         SfxItemSet aAttr = rEngine.GetAttribs( aSel );
1515
1516                         if ( aAttr.GetItemState( EE_FEATURE_FIELD ) != SFX_ITEM_ON )    // fields are not touched
1517                         {
1518                                 if ( bConsiderLanguage )
1519                                 {
1520                                         BYTE nScript = pDoc->GetStringScriptType( aOldStr );
1521                                         USHORT nWhich = ( nScript == SCRIPTTYPE_ASIAN ) ? EE_CHAR_LANGUAGE_CJK :
1522                                                                         ( ( nScript == SCRIPTTYPE_COMPLEX ) ? EE_CHAR_LANGUAGE_CTL :
1523                                                                                                                                                         EE_CHAR_LANGUAGE );
1524                                         nLanguage = ((const SvxLanguageItem&)aAttr.Get(nWhich)).GetValue();
1525                                 }
1526
1527                                 com::sun::star::uno::Sequence<sal_Int32> aOffsets;
1528                                 String aNewStr = rTranslitarationWrapper.transliterate( aOldStr, nLanguage, 0, aOldStr.Len(), &aOffsets );
1529
1530                                 if ( aNewStr != aOldStr )
1531                                 {
1532                                         // replace string, keep attributes
1533
1534                                         rEngine.QuickInsertText( aNewStr, aSel );
1535                                         aSel.nEndPos = aSel.nStartPos + aNewStr.Len();
1536                                         rEngine.QuickSetAttribs( aAttr, aSel );
1537                                 }
1538                         }
1539                 }
1540         }
1541 }
1542
1543 void ScDocument::TransliterateText( const ScMarkData& rMultiMark, sal_Int32 nType )
1544 {
1545         DBG_ASSERT( rMultiMark.IsMultiMarked(), "TransliterateText: no selection" );
1546
1547         utl::TransliterationWrapper aTranslitarationWrapper( xServiceManager, nType );
1548         BOOL bConsiderLanguage = aTranslitarationWrapper.needLanguageForTheMode();
1549         sal_uInt16 nLanguage = LANGUAGE_SYSTEM;
1550
1551         ScEditEngineDefaulter* pEngine = NULL;          // not using pEditEngine member because of defaults
1552
1553         SCTAB nCount = GetTableCount();
1554         for (SCTAB nTab = 0; nTab < nCount; nTab++)
1555                 if ( pTab[nTab] && rMultiMark.GetTableSelect(nTab) )
1556                 {
1557                         SCCOL nCol = 0;
1558                         SCROW nRow = 0;
1559
1560                         BOOL bFound = rMultiMark.IsCellMarked( nCol, nRow );
1561                         if (!bFound)
1562                                 bFound = GetNextMarkedCell( nCol, nRow, nTab, rMultiMark );
1563
1564                         while (bFound)
1565                         {
1566                                 const ScBaseCell* pCell = GetCell( ScAddress( nCol, nRow, nTab ) );
1567                                 CellType eType = pCell ? pCell->GetCellType() : CELLTYPE_NONE;
1568
1569                                 if ( eType == CELLTYPE_STRING )
1570                                 {
1571                                         String aOldStr;
1572                                         ((const ScStringCell*)pCell)->GetString(aOldStr);
1573                                         xub_StrLen nOldLen = aOldStr.Len();
1574
1575                                         if ( bConsiderLanguage )
1576                                         {
1577                                                 BYTE nScript = GetStringScriptType( aOldStr );          //! cell script type?
1578                                                 USHORT nWhich = ( nScript == SCRIPTTYPE_ASIAN ) ? ATTR_CJK_FONT_LANGUAGE :
1579                                                                                 ( ( nScript == SCRIPTTYPE_COMPLEX ) ? ATTR_CTL_FONT_LANGUAGE :
1580                                                                                                                                                                 ATTR_FONT_LANGUAGE );
1581                                                 nLanguage = ((const SvxLanguageItem*)GetAttr( nCol, nRow, nTab, nWhich ))->GetValue();
1582                                         }
1583
1584                                         com::sun::star::uno::Sequence<sal_Int32> aOffsets;
1585                                         String aNewStr = aTranslitarationWrapper.transliterate( aOldStr, nLanguage, 0, nOldLen, &aOffsets );
1586
1587                                         if ( aNewStr != aOldStr )
1588                                                 PutCell( nCol, nRow, nTab, new ScStringCell( aNewStr ) );
1589                                 }
1590                                 else if ( eType == CELLTYPE_EDIT )
1591                                 {
1592                                         if (!pEngine)
1593                                                 pEngine = new ScFieldEditEngine( GetEnginePool(), GetEditPool() );
1594
1595                                         // defaults from cell attributes must be set so right language is used
1596                                         const ScPatternAttr* pPattern = GetPattern( nCol, nRow, nTab );
1597                                         SfxItemSet* pDefaults = new SfxItemSet( pEngine->GetEmptyItemSet() );
1598                                         pPattern->FillEditItemSet( pDefaults );
1599                                         pEngine->SetDefaults( pDefaults, TRUE );
1600
1601                                         const EditTextObject* pData = ((const ScEditCell*)pCell)->GetData();
1602                                         pEngine->SetText( *pData );
1603
1604                                         pEngine->ClearModifyFlag();
1605
1606                                         lcl_TransliterateEditEngine( *pEngine, aTranslitarationWrapper, bConsiderLanguage, this );
1607
1608                                         if ( pEngine->IsModified() )
1609                                         {
1610                                                 ScEditAttrTester aTester( pEngine );
1611                                                 if ( aTester.NeedsObject() )
1612                                                 {
1613                                                         // remove defaults (paragraph attributes) before creating text object
1614                                                         SfxItemSet* pEmpty = new SfxItemSet( pEngine->GetEmptyItemSet() );
1615                                                         pEngine->SetDefaults( pEmpty, TRUE );
1616
1617                                                         EditTextObject* pNewData = pEngine->CreateTextObject();
1618                                                         PutCell( nCol, nRow, nTab,
1619                                                                 new ScEditCell( pNewData, this, pEngine->GetEditTextObjectPool() ) );
1620                                                         delete pNewData;
1621                                                 }
1622                                                 else
1623                                                 {
1624                                                         String aNewStr = pEngine->GetText();
1625                                                         PutCell( nCol, nRow, nTab, new ScStringCell( aNewStr ) );
1626                                                 }
1627                                         }
1628                                 }
1629
1630                                 bFound = GetNextMarkedCell( nCol, nRow, nTab, rMultiMark );
1631                         }
1632                 }
1633
1634         delete pEngine;
1635 }
1636