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