sc/source/ui/app/scmod.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <config_features.h>
  21
  22 #include <com/sun/star/ui/dialogs/XSLTFilterDialog.hpp>
  23 #include <comphelper/processfactory.hxx>
  24
  25 #include "scitems.hxx"
  26 #include <sfx2/app.hxx>
  27 #include <editeng/eeitem.hxx>
  28
  29 #include <editeng/flditem.hxx>
  30 #include <editeng/outliner.hxx>
  31 #include <basic/sbstar.hxx>
  32
  33 #include <sfx2/sfxdlg.hxx>
  34 #include <sfx2/viewfrm.hxx>
  35 #include <sfx2/objface.hxx>
  36
  37 #include "IAnyRefDialog.hxx"
  38 #include "anyrefdg.hxx"
  39
  40 #include <svtools/ehdl.hxx>
  41 #include <svtools/accessibilityoptions.hxx>
  42 #include <svl/ctloptions.hxx>
  43 #include <unotools/useroptions.hxx>
  44 #include <vcl/status.hxx>
  45 #include <sfx2/bindings.hxx>
  46 #include <sfx2/request.hxx>
  47 #include <sfx2/printer.hxx>
  48 #include <editeng/langitem.hxx>
  49 #include <svtools/colorcfg.hxx>
  50
  51 #include <svl/whiter.hxx>
  52 #include <svx/selctrl.hxx>
  53 #include <svx/insctrl.hxx>
  54 #include <svx/zoomctrl.hxx>
  55 #include <svx/modctrl.hxx>
  56 #include <svx/pszctrl.hxx>
  57 #include <svx/zoomsliderctrl.hxx>
  58 #include <vcl/msgbox.hxx>
  59 #include <svl/inethist.hxx>
  60 #include <vcl/waitobj.hxx>
  61 #include <svx/svxerr.hxx>
  62 #include <tools/diagnose_ex.h>
  63
  64
  65 #include "scmod.hxx"
  66 #include "global.hxx"
  67 #include "viewopti.hxx"
  68 #include "docoptio.hxx"
  69 #include "appoptio.hxx"
  70 #include "defaultsoptions.hxx"
  71 #include "formulaopt.hxx"
  72 #include "inputopt.hxx"
  73 #include "printopt.hxx"
  74 #include "navicfg.hxx"
  75 #include "addincfg.hxx"
  76 #include "tabvwsh.hxx"
  77 #include "prevwsh.hxx"
  78 #include "docsh.hxx"
  79 #include "drwlayer.hxx"
  80 #include "uiitems.hxx"
  81 #include "sc.hrc"
  82 #include "cfgids.hxx"
  83 #include "inputhdl.hxx"
  84 #include "inputwin.hxx"
  85 #include "msgpool.hxx"
  86 #include "scresid.hxx"
  87 #include "dwfunctr.hxx"
  88 #include "formdata.hxx"
  89 #include "tpprint.hxx"
  90 #include "tpdefaults.hxx"
  91 #include "transobj.hxx"
  92 #include "detfunc.hxx"
  93 #include "preview.hxx"
  94 #include "dragdata.hxx"
  95 #include "clipdata.hxx"
  96 #include "markdata.hxx"
  97
  98 #include <svx/xmlsecctrl.hxx>
  99
 100 #define ScModule
 101 #include "scslots.hxx"
 102
 103 #include "scabstdlg.hxx"
 104 #include "formula/errorcodes.hxx"
 105 #include "formulagroup.hxx"
 106
 107 #define SC_IDLE_MIN     150
 108 #define SC_IDLE_MAX     3000
 109 #define SC_IDLE_STEP    75
 110 #define SC_IDLE_COUNT   50
 111
 112 static sal_uInt16 nIdleCount = 0;
 113
 114 //------------------------------------------------------------------
 115
 116 SFX_IMPL_INTERFACE( ScModule, SfxShell, ScResId(RID_APPTITLE) )
 117 {
 118     SFX_OBJECTBAR_REGISTRATION( SFX_OBJECTBAR_APPLICATION | SFX_VISIBILITY_DESKTOP | SFX_VISIBILITY_STANDARD | SFX_VISIBILITY_CLIENT | SFX_VISIBILITY_VIEWER,
 119                                 ScResId(RID_OBJECTBAR_APP) );
 120     SFX_STATUSBAR_REGISTRATION( ScResId(SCCFG_STATUSBAR) );     // nur ID wichtig
 121 }
 122
 123 //------------------------------------------------------------------
 124
 125 ScModule::ScModule( SfxObjectFactory* pFact ) :
 126     SfxModule( SfxApplication::CreateResManager( "sc" ), false, pFact, NULL ),
 127     mpDragData(new ScDragData),
 128     mpClipData(new ScClipData),
 129     pSelTransfer( NULL ),
 130     pMessagePool( NULL ),
 131     pRefInputHandler( NULL ),
 132     pViewCfg( NULL ),
 133     pDocCfg( NULL ),
 134     pAppCfg( NULL ),
 135     pDefaultsCfg( NULL ),
 136     pFormulaCfg( NULL ),
 137     pInputCfg( NULL ),
 138     pPrintCfg( NULL ),
 139     pNavipiCfg( NULL ),
 140     pAddInCfg( NULL ),
 141     pColorConfig( NULL ),
 142     pAccessOptions( NULL ),
 143     pCTLOptions( NULL ),
 144     pUserOptions( NULL ),
 145     pErrorHdl( NULL ),
 146     pFormEditData( NULL ),
 147     nCurRefDlgId( 0 ),
 148     bIsWaterCan( false ),
 149     bIsInEditCommand( false ),
 150     bIsInExecuteDrop( false ),
 151     mbIsInSharedDocLoading( false ),
 152     mbIsInSharedDocSaving( false )
 153 {
 154     //  im ctor ist der ResManager (DLL-Daten) noch nicht initialisiert!
 155     SetName(OUString("StarCalc"));       // for Basic
 156
 157     ResetDragObject();
 158     SetClipObject( NULL, NULL );
 159
 160     //  InputHandler braucht nicht mehr angelegt zu werden
 161
 162     //  ErrorHandler anlegen - war in Init()
 163     //  zwischen OfficeApplication::Init und ScGlobal::Init
 164     SvxErrorHandler::ensure();
 165     pErrorHdl    = new SfxErrorHandler( RID_ERRHDLSC,
 166                                         ERRCODE_AREA_SC,
 167                                         ERRCODE_AREA_APP2-1,
 168                                         GetResMgr() );
 169
 170     aSpellTimer.SetTimeout(10);
 171     aSpellTimer.SetTimeoutHdl( LINK( this, ScModule, SpellTimerHdl ) );
 172     aIdleTimer.SetTimeout(SC_IDLE_MIN);
 173     aIdleTimer.SetTimeoutHdl( LINK( this, ScModule, IdleHandler ) );
 174     aIdleTimer.Start();
 175
 176     pMessagePool = new ScMessagePool;
 177     pMessagePool->FreezeIdRanges();
 178     SetPool( pMessagePool );
 179     ScGlobal::InitTextHeight( pMessagePool );
 180
 181     StartListening( *SFX_APP() );       // for SFX_HINT_DEINITIALIZING
 182 }
 183
 184 ScModule::~ScModule()
 185 {
 186     OSL_ENSURE( !pSelTransfer, "Selection Transfer object not deleted" );
 187
 188     //  InputHandler braucht nicht mehr geloescht zu werden (gibt keinen an der App mehr)
 189
 190     SfxItemPool::Free(pMessagePool);
 191
 192     DELETEZ( pFormEditData );
 193
 194     delete mpDragData;
 195     delete mpClipData;
 196     delete pErrorHdl;
 197
 198     ScGlobal::Clear();      // ruft auch ScDocumentPool::DeleteVersionMaps();
 199
 200     DeleteCfg();            // wurde mal aus Exit() gerufen
 201 }
 202
 203 //------------------------------------------------------------------
 204 void ScModule::ConfigurationChanged( utl::ConfigurationBroadcaster* p, sal_uInt32 )
 205 {
 206     if ( p == pColorConfig || p == pAccessOptions )
 207     {
 208         //  Test if detective objects have to be updated with new colors
 209         //  (if the detective colors haven't been used yet, there's nothing to update)
 210         if ( ScDetectiveFunc::IsColorsInitialized() )
 211         {
 212             const svtools::ColorConfig& rColors = GetColorConfig();
 213             sal_Bool bArrows =
 214                 ( ScDetectiveFunc::GetArrowColor() != (ColorData)rColors.GetColorValue(svtools::CALCDETECTIVE).nColor ||
 215                   ScDetectiveFunc::GetErrorColor() != (ColorData)rColors.GetColorValue(svtools::CALCDETECTIVEERROR).nColor );
 216             sal_Bool bComments =
 217                 ( ScDetectiveFunc::GetCommentColor() != (ColorData)rColors.GetColorValue(svtools::CALCNOTESBACKGROUND).nColor );
 218             if ( bArrows || bComments )
 219             {
 220                 ScDetectiveFunc::InitializeColors();        // get the new colors
 221
 222                 //  update detective objects in all open documents
 223                 SfxObjectShell* pObjSh = SfxObjectShell::GetFirst();
 224                 while ( pObjSh )
 225                 {
 226                     if ( pObjSh->Type() == TYPE(ScDocShell) )
 227                     {
 228                         ScDocShell* pDocSh = ((ScDocShell*)pObjSh);
 229                         if ( bArrows )
 230                             ScDetectiveFunc( pDocSh->GetDocument(), 0 ).UpdateAllArrowColors();
 231                         if ( bComments )
 232                             ScDetectiveFunc::UpdateAllComments( *pDocSh->GetDocument() );
 233                     }
 234                     pObjSh = SfxObjectShell::GetNext( *pObjSh );
 235                 }
 236             }
 237         }
 238
 239         //  force all views to repaint, using the new options
 240
 241         SfxViewShell* pViewShell = SfxViewShell::GetFirst();
 242         while(pViewShell)
 243         {
 244             if ( pViewShell->ISA(ScTabViewShell) )
 245             {
 246                 ScTabViewShell* pViewSh = (ScTabViewShell*)pViewShell;
 247                 pViewSh->PaintGrid();
 248                 pViewSh->PaintTop();
 249                 pViewSh->PaintLeft();
 250                 pViewSh->PaintExtras();
 251
 252                 ScInputHandler* pHdl = pViewSh->GetInputHandler();
 253                 if ( pHdl )
 254                     pHdl->ForgetLastPattern();  // EditEngine BackgroundColor may change
 255             }
 256             else if ( pViewShell->ISA(ScPreviewShell) )
 257             {
 258                 Window* pWin = pViewShell->GetWindow();
 259                 if (pWin)
 260                     pWin->Invalidate();
 261             }
 262             pViewShell = SfxViewShell::GetNext( *pViewShell );
 263         }
 264     }
 265     else if ( p == pCTLOptions )
 266     {
 267         //  for all documents: set digit language for printer, recalc output factor, update row heights
 268         SfxObjectShell* pObjSh = SfxObjectShell::GetFirst();
 269         while ( pObjSh )
 270         {
 271             if ( pObjSh->Type() == TYPE(ScDocShell) )
 272             {
 273                 ScDocShell* pDocSh = ((ScDocShell*)pObjSh);
 274                 OutputDevice* pPrinter = pDocSh->GetPrinter();
 275                 if ( pPrinter )
 276                     pPrinter->SetDigitLanguage( GetOptDigitLanguage() );
 277
 278                 pDocSh->CalcOutputFactor();
 279
 280                 SCTAB nTabCount = pDocSh->GetDocument()->GetTableCount();
 281                 for (SCTAB nTab=0; nTab<nTabCount; nTab++)
 282                     pDocSh->AdjustRowHeight( 0, MAXROW, nTab );
 283             }
 284             pObjSh = SfxObjectShell::GetNext( *pObjSh );
 285         }
 286
 287         //  for all views (table and preview): update digit language
 288         SfxViewShell* pSh = SfxViewShell::GetFirst();
 289         while ( pSh )
 290         {
 291             if ( pSh->ISA( ScTabViewShell ) )
 292             {
 293                 ScTabViewShell* pViewSh = (ScTabViewShell*)pSh;
 294
 295                 //  set ref-device for EditEngine (re-evaluates digit settings)
 296                 ScInputHandler* pHdl = GetInputHdl(pViewSh);
 297                 if (pHdl)
 298                     pHdl->UpdateRefDevice();
 299
 300                 pViewSh->DigitLanguageChanged();
 301                 pViewSh->PaintGrid();
 302             }
 303             else if ( pSh->ISA( ScPreviewShell ) )
 304             {
 305                 ScPreviewShell* pPreviewSh = (ScPreviewShell*)pSh;
 306                 ScPreview* pPreview = pPreviewSh->GetPreview();
 307
 308                 pPreview->SetDigitLanguage( GetOptDigitLanguage() );
 309                 pPreview->Invalidate();
 310             }
 311
 312             pSh = SfxViewShell::GetNext( *pSh );
 313         }
 314     }
 315 }
 316
 317 void ScModule::Notify( SfxBroadcaster&, const SfxHint& rHint )
 318 {
 319     if ( rHint.ISA(SfxSimpleHint) )
 320     {
 321         sal_uLong nHintId = ((SfxSimpleHint&)rHint).GetId();
 322         if ( nHintId == SFX_HINT_DEINITIALIZING )
 323         {
 324             //  ConfigItems must be removed before ConfigManager
 325             DeleteCfg();
 326         }
 327     }
 328 }
 329
 330 //------------------------------------------------------------------
 331
 332 void ScModule::DeleteCfg()
 333 {
 334     DELETEZ( pViewCfg ); // Speichern passiert vor Exit() automatisch
 335     DELETEZ( pDocCfg );
 336     DELETEZ( pAppCfg );
 337     DELETEZ( pDefaultsCfg );
 338     DELETEZ( pFormulaCfg );
 339     DELETEZ( pInputCfg );
 340     DELETEZ( pPrintCfg );
 341     DELETEZ( pNavipiCfg );
 342     DELETEZ( pAddInCfg );
 343
 344     if ( pColorConfig )
 345     {
 346         pColorConfig->RemoveListener(this);
 347         DELETEZ( pColorConfig );
 348     }
 349     if ( pAccessOptions )
 350     {
 351         pAccessOptions->RemoveListener(this);
 352         DELETEZ( pAccessOptions );
 353     }
 354     if ( pCTLOptions )
 355     {
 356         pCTLOptions->RemoveListener(this);
 357         DELETEZ( pCTLOptions );
 358     }
 359     if( pUserOptions )
 360     {
 361         DELETEZ( pUserOptions );
 362     }
 363 }
 364
 365 //------------------------------------------------------------------
 366 //
 367 //      von der Applikation verschoben:
 368 //
 369 //------------------------------------------------------------------
 370
 371 void ScModule::Execute( SfxRequest& rReq )
 372 {
 373     SfxViewFrame* pViewFrm = SfxViewFrame::Current();
 374     SfxBindings* pBindings = pViewFrm ? &pViewFrm->GetBindings() : NULL;
 375
 376     const SfxItemSet*   pReqArgs    = rReq.GetArgs();
 377     sal_uInt16              nSlot       = rReq.GetSlot();
 378
 379     switch ( nSlot )
 380     {
 381         case SID_CHOOSE_DESIGN:
 382             {
 383                 OUString aMacroName("Template.Samples.ShowStyles");
 384                 SfxApplication::CallAppBasic( aMacroName );
 385             }
 386             break;
 387         case SID_EURO_CONVERTER:
 388             {
 389                 OUString aMacroName("Euro.ConvertRun.Main");
 390                 SfxApplication::CallAppBasic( aMacroName );
 391             }
 392             break;
 393         case SID_AUTOSPELL_CHECK:
 394             {
 395                 sal_Bool bSet;
 396                 const SfxPoolItem* pItem;
 397                 if ( pReqArgs && SFX_ITEM_SET == pReqArgs->GetItemState( nSlot, sal_True, &pItem ) )
 398                     bSet = ((const SfxBoolItem*)pItem)->GetValue();
 399                 else
 400                 {                       //  Toggle
 401                     ScDocShell* pDocSh = PTR_CAST(ScDocShell, SfxObjectShell::Current());
 402                     if ( pDocSh )
 403                         bSet = !pDocSh->GetDocument()->GetDocOptions().IsAutoSpell();
 404                     else
 405                         bSet = !GetDocOptions().IsAutoSpell();
 406                 }
 407
 408                 SfxItemSet aSet( GetPool(), SID_AUTOSPELL_CHECK, SID_AUTOSPELL_CHECK );
 409                 aSet.Put( SfxBoolItem( SID_AUTOSPELL_CHECK, bSet ) );
 410                 ModifyOptions( aSet );
 411                 rReq.Done();
 412             }
 413             break;
 414
 415         case SID_ATTR_METRIC:
 416             {
 417                 const SfxPoolItem* pItem;
 418                 if ( pReqArgs && SFX_ITEM_SET == pReqArgs->GetItemState( nSlot, sal_True, &pItem ) )
 419                 {
 420                     FieldUnit eUnit = (FieldUnit)((const SfxUInt16Item*)pItem)->GetValue();
 421                     switch( eUnit )
 422                     {
 423                         case FUNIT_MM:      // nur die Einheiten, die auch im Dialog stehen
 424                         case FUNIT_CM:
 425                         case FUNIT_INCH:
 426                         case FUNIT_PICA:
 427                         case FUNIT_POINT:
 428                             {
 429                                 PutItem( *pItem );
 430                                 ScAppOptions aNewOpts( GetAppOptions() );
 431                                 aNewOpts.SetAppMetric( eUnit );
 432                                 SetAppOptions( aNewOpts );
 433                                 rReq.Done();
 434                             }
 435                             break;
 436                         default:
 437                         {
 438                             // added to avoid warnings
 439                         }
 440                     }
 441                 }
 442             }
 443             break;
 444
 445         case FID_AUTOCOMPLETE:
 446             {
 447                 ScAppOptions aNewOpts( GetAppOptions() );
 448                 sal_Bool bNew = !aNewOpts.GetAutoComplete();
 449                 aNewOpts.SetAutoComplete( bNew );
 450                 SetAppOptions( aNewOpts );
 451                 ScInputHandler::SetAutoComplete( bNew );
 452                 if (pBindings)
 453                     pBindings->Invalidate( FID_AUTOCOMPLETE );
 454                 rReq.Done();
 455             }
 456             break;
 457
 458         case SID_DETECTIVE_AUTO:
 459             {
 460                 ScAppOptions aNewOpts( GetAppOptions() );
 461                 sal_Bool bNew = !aNewOpts.GetDetectiveAuto();
 462                 SFX_REQUEST_ARG( rReq, pAuto, SfxBoolItem, SID_DETECTIVE_AUTO, false );
 463                 if ( pAuto )
 464                     bNew = pAuto->GetValue();
 465
 466                 aNewOpts.SetDetectiveAuto( bNew );
 467                 SetAppOptions( aNewOpts );
 468                 if (pBindings)
 469                     pBindings->Invalidate( SID_DETECTIVE_AUTO );
 470                 rReq.AppendItem( SfxBoolItem( SID_DETECTIVE_AUTO, bNew ) );
 471                 rReq.Done();
 472             }
 473             break;
 474
 475         case SID_PSZ_FUNCTION:
 476             if (pReqArgs)
 477             {
 478                 const SfxUInt16Item& rItem = (const SfxUInt16Item&)pReqArgs->Get(SID_PSZ_FUNCTION);
 479                 OSL_ENSURE(rItem.ISA(SfxUInt16Item),"falscher Parameter");
 480
 481                 ScAppOptions aNewOpts( GetAppOptions() );
 482                 aNewOpts.SetStatusFunc( rItem.GetValue() );
 483                 SetAppOptions( aNewOpts );
 484
 485                 if (pBindings)
 486                 {
 487                     pBindings->Invalidate( SID_TABLE_CELL );
 488                     pBindings->Update( SID_TABLE_CELL );            // sofort
 489
 490                     pBindings->Invalidate( SID_PSZ_FUNCTION );
 491                     pBindings->Update( SID_PSZ_FUNCTION );
 492                     // falls Menue gleich wieder aufgeklappt wird
 493                 }
 494             }
 495             break;
 496
 497         case SID_ATTR_LANGUAGE:
 498         case SID_ATTR_CHAR_CJK_LANGUAGE:
 499         case SID_ATTR_CHAR_CTL_LANGUAGE:
 500             {
 501                 const SfxPoolItem* pItem;
 502                 if ( pReqArgs && SFX_ITEM_SET == pReqArgs->GetItemState( GetPool().GetWhich(nSlot), sal_True, &pItem ) )
 503                 {
 504                     ScDocShell* pDocSh = PTR_CAST(ScDocShell, SfxObjectShell::Current());
 505                     ScDocument* pDoc = pDocSh ? pDocSh->GetDocument() : NULL;
 506                     if ( pDoc )
 507                     {
 508                         LanguageType eNewLang = ((SvxLanguageItem*)pItem)->GetLanguage();
 509                         LanguageType eLatin, eCjk, eCtl;
 510                         pDoc->GetLanguage( eLatin, eCjk, eCtl );
 511                         LanguageType eOld = ( nSlot == SID_ATTR_CHAR_CJK_LANGUAGE ) ? eCjk :
 512                                             ( ( nSlot == SID_ATTR_CHAR_CTL_LANGUAGE ) ? eCtl : eLatin );
 513                         if ( eNewLang != eOld )
 514                         {
 515                             if ( nSlot == SID_ATTR_CHAR_CJK_LANGUAGE )
 516                                 eCjk = eNewLang;
 517                             else if ( nSlot == SID_ATTR_CHAR_CTL_LANGUAGE )
 518                                 eCtl = eNewLang;
 519                             else
 520                                 eLatin = eNewLang;
 521
 522                             pDoc->SetLanguage( eLatin, eCjk, eCtl );
 523
 524                             ScInputHandler* pInputHandler = GetInputHdl();
 525                             if ( pInputHandler )
 526                                 pInputHandler->UpdateSpellSettings();   // EditEngine-Flags
 527                             ScTabViewShell* pViewSh = PTR_CAST(ScTabViewShell, SfxViewShell::Current());
 528                             if ( pViewSh )
 529                                 pViewSh->UpdateDrawTextOutliner();      // EditEngine-Flags
 530
 531                             pDocSh->SetDocumentModified();
 532                         }
 533                     }
 534                 }
 535             }
 536             break;
 537
 538         case FID_FOCUS_POSWND:
 539             {
 540                 ScInputHandler* pHdl = GetInputHdl();
 541                 if (pHdl)
 542                 {
 543                     ScInputWindow* pWin = pHdl->GetInputWindow();
 544                     if (pWin)
 545                         pWin->PosGrabFocus();
 546                 }
 547                 rReq.Done();
 548             }
 549             break;
 550
 551         case SID_OPEN_XML_FILTERSETTINGS:
 552         {
 553             try
 554             {
 555                 css::uno::Reference < css::ui::dialogs::XExecutableDialog > xDialog = css::ui::dialogs::XSLTFilterDialog::create( ::comphelper::getProcessComponentContext());
 556                 xDialog->execute();
 557             }
 558             catch( ::com::sun::star::uno::RuntimeException& )
 559             {
 560                 DBG_UNHANDLED_EXCEPTION();
 561             }
 562         }
 563         break;
 564
 565         default:
 566             OSL_FAIL( "ScApplication: Unknown Message." );
 567             break;
 568     }
 569 }
 570
 571 void ScModule::GetState( SfxItemSet& rSet )
 572 {
 573     ScDocShell* pDocSh = PTR_CAST(ScDocShell, SfxObjectShell::Current());
 574     bool bTabView = pDocSh && (pDocSh->GetBestViewShell(true) != NULL);
 575
 576     SfxWhichIter aIter(rSet);
 577     for (sal_uInt16 nWhich = aIter.FirstWhich(); nWhich; nWhich = aIter.NextWhich())
 578     {
 579         if (!bTabView)
 580         {
 581             // Not in the normal calc view shell (most likely in preview shell).  Disable all actions.
 582             rSet.DisableItem(nWhich);
 583             continue;
 584         }
 585
 586         switch ( nWhich )
 587         {
 588             case FID_AUTOCOMPLETE:
 589                 rSet.Put( SfxBoolItem( nWhich, GetAppOptions().GetAutoComplete() ) );
 590                 break;
 591             case SID_DETECTIVE_AUTO:
 592                 rSet.Put( SfxBoolItem( nWhich, GetAppOptions().GetDetectiveAuto() ) );
 593                 break;
 594             case SID_PSZ_FUNCTION:
 595                 rSet.Put( SfxUInt16Item( nWhich, GetAppOptions().GetStatusFunc() ) );
 596                 break;
 597             case SID_ATTR_METRIC:
 598                 rSet.Put( SfxUInt16Item( nWhich, sal::static_int_cast<sal_uInt16>(GetAppOptions().GetAppMetric()) ) );
 599                 break;
 600             case SID_AUTOSPELL_CHECK:
 601                 rSet.Put( SfxBoolItem( nWhich, pDocSh->GetDocument()->GetDocOptions().IsAutoSpell()) );
 602                 break;
 603             case SID_ATTR_LANGUAGE:
 604             case ATTR_CJK_FONT_LANGUAGE:        // WID for SID_ATTR_CHAR_CJK_LANGUAGE
 605             case ATTR_CTL_FONT_LANGUAGE:        // WID for SID_ATTR_CHAR_CTL_LANGUAGE
 606                 {
 607                     ScDocument* pDoc = pDocSh->GetDocument();
 608                     if ( pDoc )
 609                     {
 610                         LanguageType eLatin, eCjk, eCtl;
 611                         pDoc->GetLanguage( eLatin, eCjk, eCtl );
 612                         LanguageType eLang = ( nWhich == ATTR_CJK_FONT_LANGUAGE ) ? eCjk :
 613                                             ( ( nWhich == ATTR_CTL_FONT_LANGUAGE ) ? eCtl : eLatin );
 614                         rSet.Put( SvxLanguageItem( eLang, nWhich ) );
 615                     }
 616                 }
 617                 break;
 618         }
 619     }
 620 }
 621
 622
 623 void ScModule::HideDisabledSlots( SfxItemSet& rSet )
 624 {
 625     if( SfxViewFrame* pViewFrm = SfxViewFrame::Current() )
 626     {
 627         SfxBindings& rBindings = pViewFrm->GetBindings();
 628         SfxWhichIter aIter( rSet );
 629         for( sal_uInt16 nWhich = aIter.FirstWhich(); nWhich != 0; nWhich = aIter.NextWhich() )
 630         {
 631             ScViewUtil::HideDisabledSlot( rSet, rBindings, nWhich );
 632             // always disable the slots
 633             rSet.DisableItem( nWhich );
 634         }
 635     }
 636 }
 637
 638
 639 //------------------------------------------------------------------
 640
 641 void ScModule::ResetDragObject()
 642 {
 643     mpDragData->pCellTransfer = NULL;
 644     mpDragData->pDrawTransfer = NULL;
 645     mpDragData->pJumpLocalDoc = NULL;
 646     mpDragData->aLinkDoc = OUString();
 647     mpDragData->aLinkTable = OUString();
 648     mpDragData->aLinkArea = OUString();
 649     mpDragData->aJumpTarget = OUString();
 650     mpDragData->aJumpText = OUString();
 651 }
 652
 653 const ScDragData& ScModule::GetDragData() const
 654 {
 655     return *mpDragData;
 656 }
 657
 658 void ScModule::SetDragObject( ScTransferObj* pCellObj, ScDrawTransferObj* pDrawObj )
 659 {
 660     ResetDragObject();
 661     mpDragData->pCellTransfer = pCellObj;
 662     mpDragData->pDrawTransfer = pDrawObj;
 663 }
 664
 665 void ScModule::SetDragLink(
 666     const OUString& rDoc, const OUString& rTab, const OUString& rArea )
 667 {
 668     ResetDragObject();
 669     mpDragData->aLinkDoc   = rDoc;
 670     mpDragData->aLinkTable = rTab;
 671     mpDragData->aLinkArea  = rArea;
 672 }
 673
 674 void ScModule::SetDragJump(
 675     ScDocument* pLocalDoc, const OUString& rTarget, const OUString& rText )
 676 {
 677     ResetDragObject();
 678
 679     mpDragData->pJumpLocalDoc = pLocalDoc;
 680     mpDragData->aJumpTarget = rTarget;
 681     mpDragData->aJumpText = rText;
 682 }
 683
 684 const ScClipData& ScModule::GetClipData() const
 685 {
 686     return *mpClipData;
 687 }
 688
 689 void ScModule::SetClipObject( ScTransferObj* pCellObj, ScDrawTransferObj* pDrawObj )
 690 {
 691     OSL_ENSURE( !pCellObj || !pDrawObj, "SetClipObject: not allowed to set both objects" );
 692
 693     mpClipData->pCellClipboard = pCellObj;
 694     mpClipData->pDrawClipboard = pDrawObj;
 695 }
 696
 697 ScDocument* ScModule::GetClipDoc()
 698 {
 699     //  called from document
 700
 701     ScTransferObj* pObj = ScTransferObj::GetOwnClipboard( NULL );
 702     if (pObj)
 703         return pObj->GetDocument();
 704
 705     return NULL;
 706 }
 707
 708 //------------------------------------------------------------------
 709
 710 void ScModule::SetSelectionTransfer( ScSelectionTransferObj* pNew )
 711 {
 712     pSelTransfer = pNew;
 713 }
 714
 715 //------------------------------------------------------------------
 716
 717 void ScModule::InitFormEditData()
 718 {
 719     pFormEditData = new ScFormEditData;
 720 }
 721
 722 void ScModule::ClearFormEditData()
 723 {
 724     DELETEZ( pFormEditData );
 725 }
 726
 727 //------------------------------------------------------------------
 728
 729 void ScModule::SetViewOptions( const ScViewOptions& rOpt )
 730 {
 731     if ( !pViewCfg )
 732         pViewCfg = new ScViewCfg;
 733
 734     pViewCfg->SetOptions( rOpt );
 735 }
 736
 737 const ScViewOptions& ScModule::GetViewOptions()
 738 {
 739     if ( !pViewCfg )
 740         pViewCfg = new ScViewCfg;
 741
 742     return *pViewCfg;
 743 }
 744
 745 void ScModule::SetDocOptions( const ScDocOptions& rOpt )
 746 {
 747     if ( !pDocCfg )
 748         pDocCfg = new ScDocCfg;
 749
 750     pDocCfg->SetOptions( rOpt );
 751 }
 752
 753 const ScDocOptions& ScModule::GetDocOptions()
 754 {
 755     if ( !pDocCfg )
 756         pDocCfg = new ScDocCfg;
 757
 758     return *pDocCfg;
 759 }
 760
 761 #ifndef LRU_MAX
 762 #define LRU_MAX 10
 763 #endif
 764
 765 void ScModule::InsertEntryToLRUList(sal_uInt16 nFIndex)
 766 {
 767     if(nFIndex != 0)
 768     {
 769         const ScAppOptions& rAppOpt = GetAppOptions();
 770         sal_uInt16 nLRUFuncCount = std::min( rAppOpt.GetLRUFuncListCount(), (sal_uInt16)LRU_MAX );
 771         sal_uInt16* pLRUListIds = rAppOpt.GetLRUFuncList();
 772
 773         sal_uInt16  aIdxList[LRU_MAX];
 774         sal_uInt16  n = 0;
 775         sal_Bool    bFound = false;
 776
 777         while ((n < LRU_MAX) && n<nLRUFuncCount)                        // alte Liste abklappern
 778         {
 779             if (!bFound && (pLRUListIds[n]== nFIndex))
 780                 bFound = sal_True;                                          // erster! Treffer
 781             else if (bFound)
 782                 aIdxList[n  ] = pLRUListIds[n];                         // hinter Treffer kopieren
 783             else if ((n+1) < LRU_MAX)
 784                 aIdxList[n+1] = pLRUListIds[n];                         // vor Treffer verschieben
 785             n++;
 786         }
 787         if (!bFound && (n < LRU_MAX))                                   // Eintrag nicht gefunden?
 788             n++;                                                        //  einen mehr
 789         aIdxList[0] = nFIndex;                                          // Current on Top
 790
 791         ScAppOptions aNewOpts(rAppOpt);                                 // an App melden
 792         aNewOpts.SetLRUFuncList(aIdxList, n);
 793         SetAppOptions(aNewOpts);
 794
 795         RecentFunctionsChanged();
 796     }
 797 }
 798
 799 void ScModule::RecentFunctionsChanged()
 800 {
 801     //  update function list window
 802     sal_uInt16 nFuncListID = ScFunctionChildWindow::GetChildWindowId();
 803
 804     //! notify all views
 805     SfxViewFrame* pViewFrm = SfxViewFrame::Current();
 806     if ( pViewFrm && pViewFrm->HasChildWindow(nFuncListID) )
 807     {
 808         ScFunctionChildWindow* pWnd =(ScFunctionChildWindow*)pViewFrm->GetChildWindow( nFuncListID );
 809
 810         ScFunctionDockWin* pFuncList=(ScFunctionDockWin*)pWnd->GetWindow();
 811
 812         pFuncList->InitLRUList();
 813     }
 814 }
 815
 816 void ScModule::SetAppOptions( const ScAppOptions& rOpt )
 817 {
 818     if ( !pAppCfg )
 819         pAppCfg = new ScAppCfg;
 820
 821     pAppCfg->SetOptions( rOpt );
 822 }
 823
 824 void global_InitAppOptions()
 825 {
 826     SC_MOD()->GetAppOptions();
 827 }
 828
 829 const ScAppOptions& ScModule::GetAppOptions()
 830 {
 831     if ( !pAppCfg )
 832         pAppCfg = new ScAppCfg;
 833
 834     return *pAppCfg;
 835 }
 836
 837 void ScModule::SetDefaultsOptions( const ScDefaultsOptions& rOpt )
 838 {
 839     if ( !pDefaultsCfg )
 840         pDefaultsCfg = new ScDefaultsCfg;
 841
 842     pDefaultsCfg->SetOptions( rOpt );
 843 }
 844
 845 const ScDefaultsOptions& ScModule::GetDefaultsOptions()
 846 {
 847     if ( !pDefaultsCfg )
 848         pDefaultsCfg = new ScDefaultsCfg;
 849
 850     return *pDefaultsCfg;
 851 }
 852
 853 void ScModule::SetFormulaOptions( const ScFormulaOptions& rOpt )
 854 {
 855     if ( !pFormulaCfg )
 856         pFormulaCfg = new ScFormulaCfg;
 857
 858     pFormulaCfg->SetOptions( rOpt );
 859 }
 860
 861 const ScFormulaOptions& ScModule::GetFormulaOptions()
 862 {
 863     if ( !pFormulaCfg )
 864         pFormulaCfg = new ScFormulaCfg;
 865
 866     return *pFormulaCfg;
 867 }
 868
 869 void ScModule::SetInputOptions( const ScInputOptions& rOpt )
 870 {
 871     if ( !pInputCfg )
 872         pInputCfg = new ScInputCfg;
 873
 874     pInputCfg->SetOptions( rOpt );
 875 }
 876
 877 const ScInputOptions& ScModule::GetInputOptions()
 878 {
 879     if ( !pInputCfg )
 880         pInputCfg = new ScInputCfg;
 881
 882     return *pInputCfg;
 883 }
 884
 885 void ScModule::SetPrintOptions( const ScPrintOptions& rOpt )
 886 {
 887     if ( !pPrintCfg )
 888         pPrintCfg = new ScPrintCfg;
 889
 890     pPrintCfg->SetOptions( rOpt );
 891 }
 892
 893 const ScPrintOptions& ScModule::GetPrintOptions()
 894 {
 895     if ( !pPrintCfg )
 896         pPrintCfg = new ScPrintCfg;
 897
 898     return *pPrintCfg;
 899 }
 900
 901 ScNavipiCfg& ScModule::GetNavipiCfg()
 902 {
 903     if ( !pNavipiCfg )
 904         pNavipiCfg = new ScNavipiCfg;
 905
 906     return *pNavipiCfg;
 907 }
 908
 909 ScAddInCfg& ScModule::GetAddInCfg()
 910 {
 911     if ( !pAddInCfg )
 912         pAddInCfg = new ScAddInCfg;
 913
 914     return *pAddInCfg;
 915 }
 916
 917 svtools::ColorConfig& ScModule::GetColorConfig()
 918 {
 919     if ( !pColorConfig )
 920     {
 921         pColorConfig = new svtools::ColorConfig;
 922         pColorConfig->AddListener(this);
 923     }
 924
 925     return *pColorConfig;
 926 }
 927
 928 SvtAccessibilityOptions& ScModule::GetAccessOptions()
 929 {
 930     if ( !pAccessOptions )
 931     {
 932         pAccessOptions = new SvtAccessibilityOptions;
 933         pAccessOptions->AddListener(this);
 934     }
 935
 936     return *pAccessOptions;
 937 }
 938
 939 SvtCTLOptions& ScModule::GetCTLOptions()
 940 {
 941     if ( !pCTLOptions )
 942     {
 943         pCTLOptions = new SvtCTLOptions;
 944         pCTLOptions->AddListener(this);
 945     }
 946
 947     return *pCTLOptions;
 948 }
 949
 950 SvtUserOptions&  ScModule::GetUserOptions()
 951 {
 952     if( !pUserOptions )
 953     {
 954         pUserOptions = new SvtUserOptions;
 955     }
 956     return *pUserOptions;
 957 }
 958
 959 sal_uInt16 ScModule::GetOptDigitLanguage()
 960 {
 961     SvtCTLOptions::TextNumerals eNumerals = GetCTLOptions().GetCTLTextNumerals();
 962     return ( eNumerals == SvtCTLOptions::NUMERALS_ARABIC ) ? LANGUAGE_ENGLISH_US :
 963            ( eNumerals == SvtCTLOptions::NUMERALS_HINDI)   ? LANGUAGE_ARABIC_SAUDI_ARABIA :
 964                                                              LANGUAGE_SYSTEM;
 965 }
 966
 967 //------------------------------------------------------------------
 968 //
 969 //                          Optionen
 970 //
 971 //------------------------------------------------------------------
 972
 973 //
 974 //      ModifyOptions - Items aus Calc-Options-Dialog
 975 //                      und SID_AUTOSPELL_CHECK
 976 //
 977
 978 void ScModule::ModifyOptions( const SfxItemSet& rOptSet )
 979 {
 980     sal_uInt16 nOldSpellLang, nOldCjkLang, nOldCtlLang;
 981     sal_Bool bOldAutoSpell;
 982     GetSpellSettings( nOldSpellLang, nOldCjkLang, nOldCtlLang, bOldAutoSpell );
 983
 984     if (!pAppCfg)
 985         GetAppOptions();
 986     OSL_ENSURE( pAppCfg, "AppOptions not initialised :-(" );
 987
 988     if (!pInputCfg)
 989         GetInputOptions();
 990     OSL_ENSURE( pInputCfg, "InputOptions not initialised :-(" );
 991
 992     //--------------------------------------------------------------
 993
 994     SfxViewFrame* pViewFrm = SfxViewFrame::Current();
 995     SfxBindings* pBindings = pViewFrm ? &pViewFrm->GetBindings() : NULL;
 996
 997     ScTabViewShell*         pViewSh = PTR_CAST(ScTabViewShell, SfxViewShell::Current());
 998     ScDocShell*             pDocSh  = PTR_CAST(ScDocShell, SfxObjectShell::Current());
 999     ScDocument*             pDoc    = pDocSh ? pDocSh->GetDocument() : NULL;
1000     const SfxPoolItem*      pItem   = NULL;
1001     bool bRepaint = false;
1002     bool bUpdateMarks = false;
1003     bool bUpdateRefDev = false;
1004     bool bCalcAll = false;
1005     bool bSaveAppOptions = false;
1006     bool bSaveInputOptions = false;
1007     bool bCompileErrorCells = false;
1008
1009     //--------------------------------------------------------------------------
1010
1011     //  SFX_APP()->SetOptions( rOptSet );
1012
1013     //  Linguistik nicht mehr
1014
1015     if (rOptSet.HasItem(SID_ATTR_METRIC, &pItem))
1016     {
1017         PutItem( *pItem );
1018         pAppCfg->SetAppMetric( (FieldUnit)((const SfxUInt16Item*)pItem)->GetValue() );
1019         bSaveAppOptions = sal_True;
1020     }
1021
1022     if (rOptSet.HasItem(SCITEM_USERLIST, &pItem))
1023     {
1024         ScGlobal::SetUserList( ((const ScUserListItem*)pItem)->GetUserList() );
1025         bSaveAppOptions = sal_True;
1026     }
1027
1028     if (rOptSet.HasItem(SID_SC_OPT_SYNCZOOM, &pItem))
1029     {
1030         pAppCfg->SetSynchronizeZoom( static_cast<const SfxBoolItem*>(pItem)->GetValue() );
1031         bSaveAppOptions = sal_True;
1032     }
1033
1034     if (rOptSet.HasItem(SID_SC_OPT_KEY_BINDING_COMPAT, &pItem))
1035     {
1036         sal_uInt16 nVal = static_cast<const SfxUInt16Item*>(pItem)->GetValue();
1037         ScOptionsUtil::KeyBindingType eOld = pAppCfg->GetKeyBindingType();
1038         ScOptionsUtil::KeyBindingType eNew = static_cast<ScOptionsUtil::KeyBindingType>(nVal);
1039         if (eOld != eNew)
1040         {
1041             pAppCfg->SetKeyBindingType(eNew);
1042             bSaveAppOptions = true;
1043             pDocSh->ResetKeyBindings(eNew);
1044         }
1045     }
1046
1047     //============================================
1048     // DefaultsOptions
1049     //============================================
1050
1051     if (rOptSet.HasItem(SID_SCDEFAULTSOPTIONS, &pItem))
1052     {
1053         const ScDefaultsOptions& rOpt = ((const ScTpDefaultsItem*)pItem)->GetDefaultsOptions();
1054         SetDefaultsOptions( rOpt );
1055     }
1056
1057     //============================================
1058     // FormulaOptions
1059     //============================================
1060
1061     if (rOptSet.HasItem(SID_SCFORMULAOPTIONS, &pItem))
1062     {
1063         const ScFormulaOptions& rOpt = ((const ScTpFormulaItem*)pItem)->GetFormulaOptions();
1064
1065         if (!pFormulaCfg || (*pFormulaCfg != rOpt))
1066             // Formula options have changed. Repaint the column headers.
1067             bRepaint = true;
1068
1069         if (pFormulaCfg && pFormulaCfg->GetUseEnglishFuncName() != rOpt.GetUseEnglishFuncName())
1070         {
1071             // Re-compile formula cells with error as the error may have been
1072             // caused by unresolved function names.
1073             bCompileErrorCells = true;
1074         }
1075
1076         SetFormulaOptions( rOpt );
1077
1078         if ( pDocSh )
1079         {
1080             pDocSh->SetFormulaOptions( rOpt );
1081             pDocSh->SetDocumentModified();
1082         }
1083     }
1084
1085     //============================================
1086     // ViewOptions
1087     //============================================
1088
1089     if (rOptSet.HasItem(SID_SCVIEWOPTIONS, &pItem))
1090     {
1091         const ScViewOptions& rNewOpt = ((const ScTpViewItem*)pItem)->GetViewOptions();
1092
1093         if ( pViewSh )
1094         {
1095             ScViewData*             pViewData = pViewSh->GetViewData();
1096             const ScViewOptions&    rOldOpt   = pViewData->GetOptions();
1097
1098             sal_Bool bAnchorList = ( rOldOpt.GetOption( VOPT_ANCHOR ) !=
1099                                  rNewOpt.GetOption( VOPT_ANCHOR ) );
1100
1101             if ( rOldOpt != rNewOpt )
1102             {
1103                 pViewData->SetOptions( rNewOpt );   // veraendert rOldOpt
1104                 pViewData->GetDocument()->SetViewOptions( rNewOpt );
1105                 pDocSh->SetDocumentModified();
1106                 bRepaint = sal_True;
1107             }
1108             if ( bAnchorList )
1109                 pViewSh->UpdateAnchorHandles();
1110         }
1111         SetViewOptions( rNewOpt );
1112         if (pBindings)
1113         {
1114             pBindings->Invalidate(SID_HELPLINES_MOVE);
1115             pBindings->Invalidate(SID_SCGRIDSHOW);
1116         }
1117     }
1118
1119     //============================================
1120     // GridOptions, Auswertung nach ViewOptions,
1121     // da GridOptions Member der ViewOptions ist!
1122     //============================================
1123
1124     if ( rOptSet.HasItem(SID_ATTR_GRID_OPTIONS,&pItem) )
1125     {
1126         ScGridOptions aNewGridOpt( (const SvxOptionsGrid&)((const SvxGridItem&)*pItem) );
1127
1128         if ( pViewSh )
1129         {
1130             ScViewData*          pViewData = pViewSh->GetViewData();
1131             ScViewOptions        aNewViewOpt( pViewData->GetOptions() );
1132             const ScGridOptions& rOldGridOpt = aNewViewOpt.GetGridOptions();
1133
1134             if ( rOldGridOpt != aNewGridOpt )
1135             {
1136                 aNewViewOpt.SetGridOptions( aNewGridOpt );
1137                 pViewData->SetOptions( aNewViewOpt );
1138                 pViewData->GetDocument()->SetViewOptions( aNewViewOpt );
1139                 pDocSh->SetDocumentModified();
1140                 bRepaint = sal_True;
1141             }
1142         }
1143         ScViewOptions aNewViewOpt ( GetViewOptions() );
1144         aNewViewOpt.SetGridOptions( aNewGridOpt );
1145         SetViewOptions( aNewViewOpt );
1146         if (pBindings)
1147         {
1148             pBindings->Invalidate(SID_GRID_VISIBLE);
1149             pBindings->Invalidate(SID_GRID_USE);
1150         }
1151     }
1152
1153
1154     //============================================
1155     // DocOptions
1156     //============================================
1157
1158     if ( rOptSet.HasItem(SID_SCDOCOPTIONS,&pItem) )
1159     {
1160         const ScDocOptions& rNewOpt = ((const ScTpCalcItem*)pItem)->GetDocOptions();
1161
1162         if ( pDoc )
1163         {
1164             const ScDocOptions& rOldOpt = pDoc->GetDocOptions();
1165
1166             bRepaint = ( bRepaint || ( rOldOpt != rNewOpt )   );
1167             bCalcAll =   bRepaint &&
1168                          (  rOldOpt.IsIter()       != rNewOpt.IsIter()
1169                          || rOldOpt.GetIterCount() != rNewOpt.GetIterCount()
1170                          || rOldOpt.GetIterEps()   != rNewOpt.GetIterEps()
1171                          || rOldOpt.IsIgnoreCase() != rNewOpt.IsIgnoreCase()
1172                          || rOldOpt.IsCalcAsShown() != rNewOpt.IsCalcAsShown()
1173                          || (rNewOpt.IsCalcAsShown() &&
1174                             rOldOpt.GetStdPrecision() != rNewOpt.GetStdPrecision())
1175                          || rOldOpt.IsMatchWholeCell() != rNewOpt.IsMatchWholeCell()
1176                          || rOldOpt.GetYear2000()   != rNewOpt.GetYear2000()
1177                          || rOldOpt.IsFormulaRegexEnabled() != rNewOpt.IsFormulaRegexEnabled()
1178                          );
1179             pDoc->SetDocOptions( rNewOpt );
1180             pDocSh->SetDocumentModified();
1181         }
1182         SetDocOptions( rNewOpt );
1183     }
1184
1185     // nach den eigentlichen DocOptions auch noch die TabDistance setzen
1186     if ( rOptSet.HasItem(SID_ATTR_DEFTABSTOP,&pItem) )
1187     {
1188         sal_uInt16 nTabDist = ((SfxUInt16Item*)pItem)->GetValue();
1189         ScDocOptions aOpt(GetDocOptions());
1190         aOpt.SetTabDistance(nTabDist);
1191         SetDocOptions( aOpt );
1192
1193         if ( pDoc )
1194         {
1195             ScDocOptions aDocOpt(pDoc->GetDocOptions());
1196             aDocOpt.SetTabDistance(nTabDist);
1197             pDoc->SetDocOptions( aDocOpt );
1198             pDocSh->SetDocumentModified();
1199             if(pDoc->GetDrawLayer())
1200                 pDoc->GetDrawLayer()->SetDefaultTabulator(nTabDist);
1201         }
1202     }
1203
1204     //  AutoSpell nach den Doc-Options (weil Member)
1205
1206     if ( rOptSet.HasItem(SID_AUTOSPELL_CHECK,&pItem) )              // an Doc-Options
1207     {
1208         sal_Bool bDoAutoSpell = ((const SfxBoolItem*)pItem)->GetValue();
1209
1210         if (pDoc)
1211         {
1212             ScDocOptions aNewOpt = pDoc->GetDocOptions();
1213             if ( aNewOpt.IsAutoSpell() != bDoAutoSpell )
1214             {
1215                 aNewOpt.SetAutoSpell( bDoAutoSpell );
1216                 pDoc->SetDocOptions( aNewOpt );
1217
1218                 if (pViewSh)
1219                     pViewSh->EnableAutoSpell(bDoAutoSpell);
1220
1221                 bRepaint = true;            //  weil HideAutoSpell evtl. ungueltig
1222                                             //! alle Views painten ???
1223             }
1224         }
1225
1226         if ( bOldAutoSpell != bDoAutoSpell )
1227             SetAutoSpellProperty( bDoAutoSpell );
1228         if ( pDocSh )
1229             pDocSh->PostPaintGridAll();                     // wegen Markierungen
1230         ScInputHandler* pInputHandler = GetInputHdl();
1231         if ( pInputHandler )
1232             pInputHandler->UpdateSpellSettings();           // EditEngine-Flags
1233         if ( pViewSh )
1234             pViewSh->UpdateDrawTextOutliner();              // EditEngine-Flags
1235
1236         if (pBindings)
1237             pBindings->Invalidate( SID_AUTOSPELL_CHECK );
1238     }
1239
1240     //============================================
1241     // InputOptions
1242     //============================================
1243
1244     if ( rOptSet.HasItem(SID_SC_INPUT_SELECTIONPOS,&pItem) )
1245     {
1246         pInputCfg->SetMoveDir( ((const SfxUInt16Item*)pItem)->GetValue() );
1247         bSaveInputOptions = sal_True;
1248     }
1249     if ( rOptSet.HasItem(SID_SC_INPUT_SELECTION,&pItem) )
1250     {
1251         pInputCfg->SetMoveSelection( ((const SfxBoolItem*)pItem)->GetValue() );
1252         bSaveInputOptions = sal_True;
1253     }
1254     if ( rOptSet.HasItem(SID_SC_INPUT_EDITMODE,&pItem) )
1255     {
1256         pInputCfg->SetEnterEdit( ((const SfxBoolItem*)pItem)->GetValue() );
1257         bSaveInputOptions = sal_True;
1258     }
1259     if ( rOptSet.HasItem(SID_SC_INPUT_FMT_EXPAND,&pItem) )
1260     {
1261         pInputCfg->SetExtendFormat( ((const SfxBoolItem*)pItem)->GetValue() );
1262         bSaveInputOptions = sal_True;
1263     }
1264     if ( rOptSet.HasItem(SID_SC_INPUT_RANGEFINDER,&pItem) )
1265     {
1266         pInputCfg->SetRangeFinder( ((const SfxBoolItem*)pItem)->GetValue() );
1267         bSaveInputOptions = sal_True;
1268     }
1269     if ( rOptSet.HasItem(SID_SC_INPUT_REF_EXPAND,&pItem) )
1270     {
1271         pInputCfg->SetExpandRefs( ((const SfxBoolItem*)pItem)->GetValue() );
1272         bSaveInputOptions = sal_True;
1273     }
1274     if ( rOptSet.HasItem(SID_SC_INPUT_MARK_HEADER,&pItem) )
1275     {
1276         pInputCfg->SetMarkHeader( ((const SfxBoolItem*)pItem)->GetValue() );
1277         bSaveInputOptions = sal_True;
1278         bUpdateMarks = sal_True;
1279     }
1280     if ( rOptSet.HasItem(SID_SC_INPUT_TEXTWYSIWYG,&pItem) )
1281     {
1282         sal_Bool bNew = ((const SfxBoolItem*)pItem)->GetValue();
1283         if ( bNew != pInputCfg->GetTextWysiwyg() )
1284         {
1285             pInputCfg->SetTextWysiwyg( bNew );
1286             bSaveInputOptions = sal_True;
1287             bUpdateRefDev = sal_True;
1288         }
1289     }
1290     if( rOptSet.HasItem( SID_SC_INPUT_REPLCELLSWARN, &pItem ) )
1291     {
1292         pInputCfg->SetReplaceCellsWarn( ((const SfxBoolItem*)pItem)->GetValue() );
1293         bSaveInputOptions = sal_True;
1294     }
1295
1296     if( rOptSet.HasItem( SID_SC_INPUT_LEGACY_CELL_SELECTION, &pItem ) )
1297     {
1298         pInputCfg->SetLegacyCellSelection( ((const SfxBoolItem*)pItem)->GetValue() );
1299         bSaveInputOptions = sal_True;
1300     }
1301
1302     //============================================
1303     // PrintOptions
1304     //============================================
1305
1306     if ( rOptSet.HasItem(SID_SCPRINTOPTIONS,&pItem) )
1307     {
1308         const ScPrintOptions& rNewOpt = ((const ScTpPrintItem*)pItem)->GetPrintOptions();
1309         SetPrintOptions( rNewOpt );
1310
1311         //  broadcast causes all previews to recalc page numbers
1312         SFX_APP()->Broadcast( SfxSimpleHint( SID_SCPRINTOPTIONS ) );
1313     }
1314
1315     //----------------------------------------------------------
1316
1317     if ( bSaveAppOptions )
1318         pAppCfg->OptionsChanged();
1319
1320     if ( bSaveInputOptions )
1321         pInputCfg->OptionsChanged();
1322
1323     // Neuberechnung anstossen?
1324
1325     if (pDoc && bCompileErrorCells)
1326     {
1327         // Re-compile cells with name error, and recalc if at least one cell
1328         // has been re-compiled.  In the future we may want to find a way to
1329         // recalc only those that are affected.
1330         if (pDoc->CompileErrorCells(ScErrorCodes::errNoName))
1331             bCalcAll = true;
1332     }
1333
1334     if ( pDoc && bCalcAll )
1335     {
1336         WaitObject aWait( pDocSh->GetActiveDialogParent() );
1337         pDoc->CalcAll();
1338         if ( pViewSh )
1339             pViewSh->UpdateCharts( sal_True );
1340         else
1341             ScDBFunc::DoUpdateCharts( ScAddress(), pDoc, sal_True );
1342         if (pBindings)
1343             pBindings->Invalidate( SID_ATTR_SIZE ); //SvxPosSize-StatusControl-Update
1344     }
1345
1346     if ( pViewSh && bUpdateMarks )
1347         pViewSh->UpdateAutoFillMark();
1348
1349     // View neuzeichnen?
1350
1351     if ( pViewSh && bRepaint )
1352     {
1353         pViewSh->UpdateFixPos();
1354         pViewSh->PaintGrid();
1355         pViewSh->PaintTop();
1356         pViewSh->PaintLeft();
1357         pViewSh->PaintExtras();
1358         pViewSh->InvalidateBorder();
1359         if (pBindings)
1360         {
1361             pBindings->Invalidate( FID_TOGGLEHEADERS ); // -> Checks im Menue
1362             pBindings->Invalidate( FID_TOGGLESYNTAX );
1363         }
1364     }
1365
1366     // update ref device (for all documents)
1367
1368     if ( bUpdateRefDev )
1369     {
1370         //  for all documents: recalc output factor, update row heights
1371         SfxObjectShell* pObjSh = SfxObjectShell::GetFirst();
1372         while ( pObjSh )
1373         {
1374             if ( pObjSh->Type() == TYPE(ScDocShell) )
1375             {
1376                 ScDocShell* pOneDocSh = ((ScDocShell*)pObjSh);
1377                 pOneDocSh->CalcOutputFactor();
1378                 SCTAB nTabCount = pOneDocSh->GetDocument()->GetTableCount();
1379                 for (SCTAB nTab=0; nTab<nTabCount; nTab++)
1380                     pOneDocSh->AdjustRowHeight( 0, MAXROW, nTab );
1381             }
1382             pObjSh = SfxObjectShell::GetNext( *pObjSh );
1383         }
1384
1385         //  for all (tab-) views:
1386         TypeId aScType = TYPE(ScTabViewShell);
1387         SfxViewShell* pSh = SfxViewShell::GetFirst( &aScType );
1388         while ( pSh )
1389         {
1390             ScTabViewShell* pOneViewSh = (ScTabViewShell*)pSh;
1391
1392             //  set ref-device for EditEngine
1393             ScInputHandler* pHdl = GetInputHdl(pOneViewSh);
1394             if (pHdl)
1395                 pHdl->UpdateRefDevice();
1396
1397             //  update view scale
1398             ScViewData* pViewData = pOneViewSh->GetViewData();
1399             pOneViewSh->SetZoom( pViewData->GetZoomX(), pViewData->GetZoomY(), false );
1400
1401             //  repaint
1402             pOneViewSh->PaintGrid();
1403             pOneViewSh->PaintTop();
1404             pOneViewSh->PaintLeft();
1405
1406             pSh = SfxViewShell::GetNext( *pSh, &aScType );
1407         }
1408     }
1409 }
1410
1411 //------------------------------------------------------------------
1412 //
1413 //                      Input-Handler
1414 //
1415 //------------------------------------------------------------------
1416
1417 ScInputHandler* ScModule::GetInputHdl( ScTabViewShell* pViewSh, sal_Bool bUseRef )
1418 {
1419     if ( pRefInputHandler && bUseRef )
1420         return pRefInputHandler;
1421
1422     ScInputHandler* pHdl = NULL;
1423     if ( !pViewSh )
1424     {
1425         // in case a UIActive embedded object has no ViewShell ( UNO component )
1426         // the own calc view shell will be set as current, but no handling should happen
1427
1428         ScTabViewShell* pCurViewSh = PTR_CAST( ScTabViewShell, SfxViewShell::Current() );
1429         if ( pCurViewSh && !pCurViewSh->GetUIActiveClient() )
1430             pViewSh = pCurViewSh;
1431     }
1432
1433     if ( pViewSh )
1434         pHdl = pViewSh->GetInputHandler();      // Viewshell hat jetzt immer einen
1435
1436     //  wenn keine ViewShell uebergeben oder aktiv, kann NULL herauskommen
1437     OSL_ENSURE( pHdl || !pViewSh, "GetInputHdl: kein InputHandler gefunden" );
1438     return pHdl;
1439 }
1440
1441 void ScModule::ViewShellChanged()
1442 {
1443     ScInputHandler* pHdl   = GetInputHdl();
1444     ScTabViewShell* pShell = ScTabViewShell::GetActiveViewShell();
1445     if ( pShell && pHdl )
1446         pShell->UpdateInputHandler();
1447 }
1448
1449 void ScModule::SetInputMode( ScInputMode eMode )
1450 {
1451     ScInputHandler* pHdl = GetInputHdl();
1452     if (pHdl)
1453         pHdl->SetMode( eMode );
1454 }
1455
1456 sal_Bool ScModule::IsEditMode()
1457 {
1458     ScInputHandler* pHdl = GetInputHdl();
1459     return pHdl && pHdl->IsEditMode();
1460 }
1461
1462 sal_Bool ScModule::IsInputMode()
1463 {
1464     ScInputHandler* pHdl = GetInputHdl();
1465     return pHdl && pHdl->IsInputMode();
1466 }
1467
1468 sal_Bool ScModule::InputKeyEvent( const KeyEvent& rKEvt, sal_Bool bStartEdit )
1469 {
1470     ScInputHandler* pHdl = GetInputHdl();
1471     return ( pHdl ? pHdl->KeyInput( rKEvt, bStartEdit ) : false );
1472 }
1473
1474 void ScModule::InputEnterHandler( sal_uInt8 nBlockMode )
1475 {
1476     if ( !SFX_APP()->IsDowning() )                                  // nicht beim Programmende
1477     {
1478         ScInputHandler* pHdl = GetInputHdl();
1479         if (pHdl)
1480             pHdl->EnterHandler( nBlockMode );
1481     }
1482 }
1483
1484 void ScModule::InputCancelHandler()
1485 {
1486     ScInputHandler* pHdl = GetInputHdl();
1487     if (pHdl)
1488         pHdl->CancelHandler();
1489 }
1490
1491 void ScModule::InputSelection( EditView* pView )
1492 {
1493     ScInputHandler* pHdl = GetInputHdl();
1494     if (pHdl)
1495         pHdl->InputSelection( pView );
1496 }
1497
1498 void ScModule::InputChanged( EditView* pView )
1499 {
1500     ScInputHandler* pHdl = GetInputHdl();
1501     if (pHdl)
1502         pHdl->InputChanged( pView );
1503 }
1504
1505 void ScModule::ViewShellGone( ScTabViewShell* pViewSh )
1506 {
1507     ScInputHandler* pHdl = GetInputHdl();
1508     if (pHdl)
1509         pHdl->ViewShellGone( pViewSh );
1510 }
1511
1512 void ScModule::SetRefInputHdl( ScInputHandler* pNew )
1513 {
1514     pRefInputHandler = pNew;
1515 }
1516
1517 ScInputHandler* ScModule::GetRefInputHdl()
1518 {
1519     return pRefInputHandler;
1520 }
1521
1522 //------------------------------------------------------------------------
1523 //  Olk's Krempel:
1524
1525 void ScModule::InputGetSelection( xub_StrLen& rStart, xub_StrLen& rEnd )
1526 {
1527     ScInputHandler* pHdl = GetInputHdl();
1528     if (pHdl)
1529         pHdl->InputGetSelection( rStart, rEnd );
1530 }
1531
1532 void ScModule::InputSetSelection( xub_StrLen nStart, xub_StrLen nEnd )
1533 {
1534     ScInputHandler* pHdl = GetInputHdl();
1535     if (pHdl)
1536         pHdl->InputSetSelection( nStart, nEnd );
1537 }
1538
1539 void ScModule::InputReplaceSelection( const OUString& rStr )
1540 {
1541     ScInputHandler* pHdl = GetInputHdl();
1542     if (pHdl)
1543         pHdl->InputReplaceSelection( rStr );
1544 }
1545
1546 void ScModule::InputTurnOffWinEngine()
1547 {
1548     ScInputHandler* pHdl = GetInputHdl();
1549     if (pHdl)
1550         pHdl->InputTurnOffWinEngine();
1551 }
1552
1553 OUString ScModule::InputGetFormulaStr()
1554 {
1555     ScInputHandler* pHdl = GetInputHdl();
1556     OUString aStr;
1557     if ( pHdl )
1558         aStr = pHdl->GetFormString();
1559     return aStr;
1560 }
1561
1562 void ScModule::ActivateInputWindow( const OUString* pStrFormula, sal_Bool bMatrix )
1563 {
1564     ScInputHandler* pHdl = GetInputHdl();
1565     if ( pHdl )
1566     {
1567         ScInputWindow* pWin = pHdl->GetInputWindow();
1568         if ( pStrFormula )
1569         {
1570             // Formel uebernehmen
1571             if ( pWin )
1572             {
1573                 pWin->SetFuncString( *pStrFormula, false );
1574                 // SetSumAssignMode wegen sal_False nicht noetig
1575             }
1576             sal_uInt8 nMode = bMatrix ? SC_ENTER_MATRIX : SC_ENTER_NORMAL;
1577             pHdl->EnterHandler( nMode );
1578
1579             //  ohne Invalidate bleibt die Selektion stehen, wenn die Formel unveraendert ist
1580             if (pWin)
1581                 pWin->TextInvalidate();
1582         }
1583         else
1584         {
1585             // Abbrechen
1586             if ( pWin )
1587             {
1588                 pWin->SetFuncString( EMPTY_OUSTRING, false );
1589                 // SetSumAssignMode wegen sal_False nicht noetig
1590             }
1591             pHdl->CancelHandler();
1592         }
1593     }
1594 }
1595
1596 //------------------------------------------------------------------
1597 //
1598 //                  Referenz - Dialoge
1599 //
1600 //------------------------------------------------------------------
1601
1602 void ScModule::SetRefDialog( sal_uInt16 nId, sal_Bool bVis, SfxViewFrame* pViewFrm )
1603 {
1604     //! move reference dialog handling to view
1605     //! (only keep function autopilot here for references to other documents)
1606
1607     if(nCurRefDlgId==0 || (nId==nCurRefDlgId && !bVis))
1608     {
1609         if ( !pViewFrm )
1610             pViewFrm = SfxViewFrame::Current();
1611
1612         // bindings update causes problems with update of stylist if
1613         // current style family has changed
1614         //if ( pViewFrm )
1615         //  pViewFrm->GetBindings().Update();       // to avoid trouble in LockDispatcher
1616
1617         nCurRefDlgId = bVis ? nId : 0 ;             // before SetChildWindow
1618
1619         if ( pViewFrm )
1620         {
1621             //  store the dialog id also in the view shell
1622             SfxViewShell* pViewSh = pViewFrm->GetViewShell();
1623             if ( pViewSh && pViewSh->ISA( ScTabViewShell ) )
1624                 ((ScTabViewShell*)pViewSh)->SetCurRefDlgId( nCurRefDlgId );
1625             else
1626             {
1627                 // no ScTabViewShell - possible for example from a Basic macro
1628                 bVis = false;
1629                 nCurRefDlgId = 0;   // don't set nCurRefDlgId if no dialog is created
1630             }
1631
1632             pViewFrm->SetChildWindow( nId, bVis );
1633         }
1634
1635         SfxApplication* pSfxApp = SFX_APP();
1636         pSfxApp->Broadcast( SfxSimpleHint( FID_REFMODECHANGED ) );
1637     }
1638 }
1639
1640 static SfxChildWindow* lcl_GetChildWinFromAnyView( sal_uInt16 nId )
1641 {
1642     //  first try the current view
1643
1644     SfxViewFrame* pViewFrm = SfxViewFrame::Current();
1645     // #i46999# current view frame can be null (for example, when closing help)
1646     SfxChildWindow* pChildWnd = pViewFrm ? pViewFrm->GetChildWindow( nId ) : NULL;
1647     if ( pChildWnd )
1648         return pChildWnd;           // found in the current view
1649
1650     //  if not found there, get the child window from any open view
1651     //  it can be open only in one view because nCurRefDlgId is global
1652
1653     pViewFrm = SfxViewFrame::GetFirst();
1654     while ( pViewFrm )
1655     {
1656         pChildWnd = pViewFrm->GetChildWindow( nId );
1657         if ( pChildWnd )
1658             return pChildWnd;       // found in any view
1659
1660         pViewFrm = SfxViewFrame::GetNext( *pViewFrm );
1661     }
1662
1663     return NULL;                    // none found
1664 }
1665
1666 sal_Bool ScModule::IsModalMode(SfxObjectShell* pDocSh)
1667 {
1668     //! move reference dialog handling to view
1669     //! (only keep function autopilot here for references to other documents)
1670
1671     sal_Bool bIsModal = false;
1672
1673     if ( nCurRefDlgId )
1674     {
1675         SfxChildWindow* pChildWnd = lcl_GetChildWinFromAnyView( nCurRefDlgId );
1676         ScAnyRefModalDlg* pModalDlg = GetCurrentAnyRefDlg();
1677         if ( pChildWnd )
1678         {
1679             IAnyRefDialog* pRefDlg = dynamic_cast<IAnyRefDialog*>(pChildWnd->GetWindow());
1680             bIsModal = pChildWnd->IsVisible() &&
1681                 !( pRefDlg->IsRefInputMode() && pRefDlg->IsDocAllowed(pDocSh) );
1682         }
1683         else if(pModalDlg)
1684         {
1685             bIsModal = pModalDlg->IsVisible() && !(pModalDlg->IsRefInputMode() && pModalDlg->IsDocAllowed(pDocSh) );
1686         }
1687         else
1688         {
1689             // in 592 and above, the dialog isn't visible in other views
1690             //  if the dialog is open but can't be accessed, disable input
1691
1692             bIsModal = sal_True;
1693         }
1694
1695         //  pChildWnd kann 0 sein, wenn der Dialog nach dem Umschalten
1696         //  von einer anderen Shell noch nicht erzeugt wurde (z.B. in GetFocus)
1697     }
1698     else if (pDocSh)
1699     {
1700         ScInputHandler* pHdl = GetInputHdl();
1701         if ( pHdl )
1702             bIsModal = pHdl->IsModalMode(pDocSh);
1703     }
1704
1705     return bIsModal;
1706 }
1707
1708 sal_Bool ScModule::IsTableLocked()
1709 {
1710     //! move reference dialog handling to view
1711     //! (only keep function autopilot here for references to other documents)
1712
1713     sal_Bool bLocked = false;
1714
1715     //  bisher nur bei ScAnyRefDlg
1716
1717     if ( nCurRefDlgId )
1718     {
1719         SfxChildWindow* pChildWnd = lcl_GetChildWinFromAnyView( nCurRefDlgId );
1720         ScAnyRefModalDlg* pModalDlg = GetCurrentAnyRefDlg();
1721         if ( pChildWnd )
1722             bLocked = dynamic_cast<IAnyRefDialog*>(pChildWnd->GetWindow())->IsTableLocked();
1723         else if( pModalDlg )
1724             bLocked = pModalDlg->IsTableLocked();
1725         else
1726             bLocked = sal_True;     // for other views, see IsModalMode
1727     }
1728
1729     return bLocked;
1730 }
1731
1732 sal_Bool ScModule::IsRefDialogOpen()
1733 {
1734     //! move reference dialog handling to view
1735     //! (only keep function autopilot here for references to other documents)
1736
1737     sal_Bool bIsOpen = false;
1738
1739     if ( nCurRefDlgId )
1740     {
1741         SfxChildWindow* pChildWnd = lcl_GetChildWinFromAnyView( nCurRefDlgId );
1742         ScAnyRefModalDlg* pModalDlg = GetCurrentAnyRefDlg();
1743         if ( pChildWnd )
1744             bIsOpen = pChildWnd->IsVisible();
1745         else if(pModalDlg)
1746             bIsOpen = pModalDlg->IsVisible();
1747         else
1748             bIsOpen = sal_True;     // for other views, see IsModalMode
1749     }
1750
1751     return bIsOpen;
1752 }
1753
1754 sal_Bool ScModule::IsFormulaMode()
1755 {
1756     //! move reference dialog handling to view
1757     //! (only keep function autopilot here for references to other documents)
1758
1759     sal_Bool bIsFormula = false;
1760
1761     if ( nCurRefDlgId )
1762     {
1763         SfxChildWindow* pChildWnd = lcl_GetChildWinFromAnyView( nCurRefDlgId );
1764         ScAnyRefModalDlg* pModalDlg = GetCurrentAnyRefDlg();
1765         if ( pChildWnd )
1766         {
1767             IAnyRefDialog* pRefDlg = dynamic_cast<IAnyRefDialog*>(pChildWnd->GetWindow());
1768             bIsFormula = pChildWnd->IsVisible() && pRefDlg->IsRefInputMode();
1769         }
1770         else if(pModalDlg)
1771         {
1772             bIsFormula = pModalDlg->IsVisible() && pModalDlg->IsRefInputMode();
1773         }
1774         else
1775             bIsFormula = true;
1776     }
1777     else
1778     {
1779         ScInputHandler* pHdl = GetInputHdl();
1780         if ( pHdl )
1781             bIsFormula = pHdl->IsFormulaMode();
1782     }
1783
1784     if (bIsInEditCommand)
1785         bIsFormula = sal_True;
1786
1787     return bIsFormula;
1788 }
1789
1790 static void lcl_MarkedTabs( const ScMarkData& rMark, SCTAB& rStartTab, SCTAB& rEndTab )
1791 {
1792     if (rMark.GetSelectCount() > 1)
1793     {
1794         rEndTab = rMark.GetLastSelected();
1795         rStartTab = rMark.GetFirstSelected();
1796     }
1797 }
1798
1799 void ScModule::SetReference( const ScRange& rRef, ScDocument* pDoc,
1800                                     const ScMarkData* pMarkData )
1801 {
1802     //! move reference dialog handling to view
1803     //! (only keep function autopilot here for references to other documents)
1804
1805     //  in Ref-Dialogen wird hiermit auch das Zoom-In ausgeloest,
1806     //  wenn Start und Ende der Ref unterschiedlich sind
1807
1808     ScRange aNew = rRef;
1809     aNew.Justify();                 // immer "richtig herum"
1810
1811     if( nCurRefDlgId )
1812     {
1813         SfxChildWindow* pChildWnd = lcl_GetChildWinFromAnyView( nCurRefDlgId );
1814         ScAnyRefModalDlg* pModalDlg = GetCurrentAnyRefDlg();
1815         OSL_ENSURE( pChildWnd || pModalDlg, "NoChildWin" );
1816         if ( pChildWnd )
1817         {
1818             if ( nCurRefDlgId == SID_OPENDLG_CONSOLIDATE && pMarkData )
1819             {
1820                 SCTAB nStartTab = aNew.aStart.Tab();
1821                 SCTAB nEndTab   = aNew.aEnd.Tab();
1822                 lcl_MarkedTabs( *pMarkData, nStartTab, nEndTab );
1823                 aNew.aStart.SetTab(nStartTab);
1824                 aNew.aEnd.SetTab(nEndTab);
1825             }
1826
1827             IAnyRefDialog* pRefDlg = dynamic_cast<IAnyRefDialog*>(pChildWnd->GetWindow());
1828
1829             //  hide the (color) selection now instead of later from LoseFocus,
1830             //  don't abort the ref input that causes this call (bDoneRefMode = sal_False)
1831             pRefDlg->HideReference( false );
1832             pRefDlg->SetReference( aNew, pDoc );
1833         }
1834         else if(pModalDlg)
1835         {
1836             //  hide the (color) selection now instead of later from LoseFocus,
1837             //  don't abort the ref input that causes this call (bDoneRefMode = sal_False)
1838             pModalDlg->HideReference( false );
1839             pModalDlg->SetReference( aNew, pDoc );
1840         }
1841     }
1842     else
1843     {
1844         ScInputHandler* pHdl = GetInputHdl();
1845         if (pHdl)
1846             pHdl->SetReference( aNew, pDoc );
1847         else
1848         {
1849             OSL_FAIL("SetReference ohne Empfaenger");
1850         }
1851     }
1852 }
1853
1854 void ScModule::AddRefEntry()                        // "Mehrfachselektion"
1855 {
1856     //! move reference dialog handling to view
1857     //! (only keep function autopilot here for references to other documents)
1858
1859     if ( nCurRefDlgId )
1860     {
1861         SfxChildWindow* pChildWnd = lcl_GetChildWinFromAnyView( nCurRefDlgId );
1862         ScAnyRefModalDlg* pModalDlg = GetCurrentAnyRefDlg();
1863         OSL_ENSURE( pChildWnd || pModalDlg, "NoChildWin" );
1864         if ( pChildWnd )
1865         {
1866             IAnyRefDialog* pRefDlg = dynamic_cast<IAnyRefDialog*>(pChildWnd->GetWindow());
1867             pRefDlg->AddRefEntry();
1868         }
1869         else if(pModalDlg)
1870             pModalDlg->AddRefEntry();
1871     }
1872     else
1873     {
1874         ScInputHandler* pHdl = GetInputHdl();
1875         if (pHdl)
1876             pHdl->AddRefEntry();
1877     }
1878 }
1879
1880 void ScModule::EndReference()
1881 {
1882     //! move reference dialog handling to view
1883     //! (only keep function autopilot here for references to other documents)
1884
1885     //  in Ref-Dialogen wird hiermit auch das Zoom-In wieder aufgehoben
1886
1887     //! ShowRefFrame am InputHdl, wenn der Funktions-AP offen ist ???
1888
1889     if ( nCurRefDlgId )
1890     {
1891         SfxChildWindow* pChildWnd = lcl_GetChildWinFromAnyView( nCurRefDlgId );
1892         ScAnyRefModalDlg* pModalDlg = GetCurrentAnyRefDlg();
1893         OSL_ENSURE( pChildWnd || pModalDlg, "NoChildWin" );
1894         if ( pChildWnd )
1895         {
1896             IAnyRefDialog* pRefDlg = dynamic_cast<IAnyRefDialog*>(pChildWnd->GetWindow());
1897             pRefDlg->SetActive();
1898         }
1899         else
1900             pModalDlg->SetActive();
1901     }
1902 }
1903
1904 //------------------------------------------------------------------
1905 //
1906 //                  Idle / Online-Spelling
1907 //
1908 //------------------------------------------------------------------
1909
1910 void ScModule::AnythingChanged()
1911 {
1912     sal_uLong nOldTime = aIdleTimer.GetTimeout();
1913     if ( nOldTime != SC_IDLE_MIN )
1914         aIdleTimer.SetTimeout( SC_IDLE_MIN );
1915
1916     nIdleCount = 0;
1917 }
1918
1919 static void lcl_CheckNeedsRepaint( ScDocShell* pDocShell )
1920 {
1921     SfxViewFrame* pFrame = SfxViewFrame::GetFirst( pDocShell );
1922     while ( pFrame )
1923     {
1924         SfxViewShell* p = pFrame->GetViewShell();
1925         ScTabViewShell* pViewSh = PTR_CAST(ScTabViewShell,p);
1926         if ( pViewSh )
1927             pViewSh->CheckNeedsRepaint();
1928         pFrame = SfxViewFrame::GetNext( *pFrame, pDocShell );
1929     }
1930 }
1931
1932 IMPL_LINK_NOARG(ScModule, IdleHandler)
1933 {
1934     if ( Application::AnyInput( VCL_INPUT_MOUSEANDKEYBOARD ) )
1935     {
1936         aIdleTimer.Start();         // Timeout unveraendert
1937         return 0;
1938     }
1939
1940     bool bMore = false;
1941     bool bAutoSpell = false;
1942     ScDocShell* pDocSh = dynamic_cast<ScDocShell*>(SfxObjectShell::Current());
1943
1944     if ( pDocSh )
1945     {
1946         ScDocument* pDoc = pDocSh->GetDocument();
1947         bAutoSpell = pDoc->GetDocOptions().IsAutoSpell();
1948         if (pDocSh->IsReadOnly())
1949             bAutoSpell = false;
1950
1951         sal_Bool bLinks = pDoc->IdleCheckLinks();
1952         sal_Bool bWidth = pDoc->IdleCalcTextWidth();
1953
1954         bMore = bLinks || bWidth;         // ueberhaupt noch was?
1955
1956         //  While calculating a Basic formula, a paint event may have occurred,
1957         //  so check the bNeedsRepaint flags for this document's views
1958         if (bWidth)
1959             lcl_CheckNeedsRepaint( pDocSh );
1960     }
1961
1962     if (bAutoSpell)
1963     {
1964         ScTabViewShell* pViewSh = dynamic_cast<ScTabViewShell*>(SfxViewShell::Current());
1965         if (pViewSh)
1966         {
1967             bool bSpell = pViewSh->ContinueOnlineSpelling();
1968             if (bSpell)
1969             {
1970                 aSpellTimer.Start();
1971                 bMore = true;
1972             }
1973         }
1974     }
1975
1976     sal_uLong nOldTime = aIdleTimer.GetTimeout();
1977     sal_uLong nNewTime = nOldTime;
1978     if ( bMore )
1979     {
1980         nNewTime = SC_IDLE_MIN;
1981         nIdleCount = 0;
1982     }
1983     else
1984     {
1985         //  SC_IDLE_COUNT mal mit initialem Timeout, dann hochzaehlen
1986
1987         if ( nIdleCount < SC_IDLE_COUNT )
1988             ++nIdleCount;
1989         else
1990         {
1991             nNewTime += SC_IDLE_STEP;
1992             if ( nNewTime > SC_IDLE_MAX )
1993                 nNewTime = SC_IDLE_MAX;
1994         }
1995     }
1996     if ( nNewTime != nOldTime )
1997         aIdleTimer.SetTimeout( nNewTime );
1998
1999     aIdleTimer.Start();
2000     return 0;
2001 }
2002
2003 IMPL_LINK_NOARG(ScModule, SpellTimerHdl)
2004 {
2005     if ( Application::AnyInput( VCL_INPUT_KEYBOARD ) )
2006     {
2007         aSpellTimer.Start();
2008         return 0;                   // dann spaeter wieder...
2009     }
2010
2011     ScTabViewShell* pViewSh = dynamic_cast<ScTabViewShell*>(SfxViewShell::Current());
2012     if (pViewSh)
2013     {
2014         if (pViewSh->ContinueOnlineSpelling())
2015             aSpellTimer.Start();
2016     }
2017     return 0;
2018 }
2019
2020     //virtuelle Methoden fuer den Optionendialog
2021 SfxItemSet*  ScModule::CreateItemSet( sal_uInt16 nId )
2022 {
2023     SfxItemSet*  pRet = 0;
2024     if(SID_SC_EDITOPTIONS == nId)
2025     {
2026         pRet = new SfxItemSet( GetPool(),
2027                             // TP_CALC:
2028                             SID_SCDOCOPTIONS,       SID_SCDOCOPTIONS,
2029                             // TP_VIEW:
2030                             SID_SCVIEWOPTIONS,      SID_SCVIEWOPTIONS,
2031                             SID_SC_OPT_SYNCZOOM,    SID_SC_OPT_SYNCZOOM,
2032                             // TP_INPUT:
2033                             SID_SC_INPUT_SELECTION,SID_SC_INPUT_MARK_HEADER,
2034                             SID_SC_INPUT_TEXTWYSIWYG,SID_SC_INPUT_TEXTWYSIWYG,
2035                             SID_SC_INPUT_REPLCELLSWARN,SID_SC_INPUT_REPLCELLSWARN,
2036                             SID_SC_INPUT_LEGACY_CELL_SELECTION,SID_SC_INPUT_LEGACY_CELL_SELECTION,
2037                             // TP_USERLISTS:
2038                             SCITEM_USERLIST,        SCITEM_USERLIST,
2039                             // TP_PRINT:
2040                             SID_SCPRINTOPTIONS, SID_SCPRINTOPTIONS,
2041                             // TP_GRID:
2042                             SID_ATTR_GRID_OPTIONS, SID_ATTR_GRID_OPTIONS,
2043                             //
2044                             SID_ATTR_METRIC,        SID_ATTR_METRIC,
2045                             SID_ATTR_DEFTABSTOP,    SID_ATTR_DEFTABSTOP,
2046                             // TP_COMPATIBILITY
2047                             SID_SC_OPT_KEY_BINDING_COMPAT, SID_SC_OPT_KEY_BINDING_COMPAT,
2048                             // TP_DEFAULTS
2049                             SID_SCDEFAULTSOPTIONS, SID_SCDEFAULTSOPTIONS,
2050                             // TP_FORMULA
2051                             SID_SCFORMULAOPTIONS, SID_SCFORMULAOPTIONS,
2052                             0 );
2053
2054         const ScAppOptions& rAppOpt = GetAppOptions();
2055
2056         ScDocShell*     pDocSh = PTR_CAST(ScDocShell,
2057                                             SfxObjectShell::Current());
2058         ScDocOptions    aCalcOpt = pDocSh
2059                             ? pDocSh->GetDocument()->GetDocOptions()
2060                             : GetDocOptions();
2061
2062         ScTabViewShell* pViewSh = PTR_CAST(ScTabViewShell,
2063                                             SfxViewShell::Current());
2064         ScViewOptions   aViewOpt = pViewSh
2065                             ? pViewSh->GetViewData()->GetOptions()
2066                             : GetViewOptions();
2067
2068         ScUserListItem  aULItem( SCITEM_USERLIST );
2069         ScUserList*     pUL = ScGlobal::GetUserList();
2070
2071         //  SFX_APP()->GetOptions( aSet );
2072
2073         pRet->Put( SfxUInt16Item( SID_ATTR_METRIC,
2074                         sal::static_int_cast<sal_uInt16>(rAppOpt.GetAppMetric()) ) );
2075
2076         // TP_CALC
2077         pRet->Put( SfxUInt16Item( SID_ATTR_DEFTABSTOP,
2078                         aCalcOpt.GetTabDistance()));
2079         pRet->Put( ScTpCalcItem( SID_SCDOCOPTIONS, aCalcOpt ) );
2080
2081         // TP_VIEW
2082         pRet->Put( ScTpViewItem( SID_SCVIEWOPTIONS, aViewOpt ) );
2083         pRet->Put( SfxBoolItem( SID_SC_OPT_SYNCZOOM, rAppOpt.GetSynchronizeZoom() ) );
2084
2085         // TP_INPUT
2086         const ScInputOptions& rInpOpt = GetInputOptions();
2087         pRet->Put( SfxUInt16Item( SID_SC_INPUT_SELECTIONPOS,
2088                     rInpOpt.GetMoveDir() ) );
2089         pRet->Put( SfxBoolItem( SID_SC_INPUT_SELECTION,
2090                     rInpOpt.GetMoveSelection() ) );
2091         pRet->Put( SfxBoolItem( SID_SC_INPUT_EDITMODE,
2092                     rInpOpt.GetEnterEdit() ) );
2093         pRet->Put( SfxBoolItem( SID_SC_INPUT_FMT_EXPAND,
2094                     rInpOpt.GetExtendFormat() ) );
2095         pRet->Put( SfxBoolItem( SID_SC_INPUT_RANGEFINDER,
2096                     rInpOpt.GetRangeFinder() ) );
2097         pRet->Put( SfxBoolItem( SID_SC_INPUT_REF_EXPAND,
2098                     rInpOpt.GetExpandRefs() ) );
2099         pRet->Put( SfxBoolItem( SID_SC_INPUT_MARK_HEADER,
2100                     rInpOpt.GetMarkHeader() ) );
2101         pRet->Put( SfxBoolItem( SID_SC_INPUT_TEXTWYSIWYG,
2102                     rInpOpt.GetTextWysiwyg() ) );
2103         pRet->Put( SfxBoolItem( SID_SC_INPUT_REPLCELLSWARN,
2104                     rInpOpt.GetReplaceCellsWarn() ) );
2105         pRet->Put( SfxBoolItem( SID_SC_INPUT_LEGACY_CELL_SELECTION,
2106                     rInpOpt.GetLegacyCellSelection() ) );
2107
2108
2109         // RID_SC_TP_PRINT
2110         pRet->Put( ScTpPrintItem( SID_SCPRINTOPTIONS, GetPrintOptions() ) );
2111
2112         // TP_GRID
2113         SvxGridItem* pSvxGridItem = aViewOpt.CreateGridItem();
2114         pRet->Put( *pSvxGridItem );
2115         delete pSvxGridItem;
2116
2117         // TP_USERLISTS
2118         if ( pUL )
2119         {
2120             aULItem.SetUserList( *pUL );
2121             pRet->Put(aULItem);
2122         }
2123
2124         // TP_COMPATIBILITY
2125         pRet->Put( SfxUInt16Item( SID_SC_OPT_KEY_BINDING_COMPAT,
2126                                    rAppOpt.GetKeyBindingType() ) );
2127
2128         // TP_DEFAULTS
2129         pRet->Put( ScTpDefaultsItem( SID_SCDEFAULTSOPTIONS, GetDefaultsOptions() ) );
2130
2131         // TP_FORMULA
2132         pRet->Put( ScTpFormulaItem( SID_SCFORMULAOPTIONS, GetFormulaOptions() ) );
2133     }
2134     return pRet;
2135 }
2136
2137 void ScModule::ApplyItemSet( sal_uInt16 nId, const SfxItemSet& rSet )
2138 {
2139     if(SID_SC_EDITOPTIONS == nId)
2140     {
2141         ModifyOptions( rSet );
2142     }
2143 }
2144
2145 SfxTabPage*  ScModule::CreateTabPage( sal_uInt16 nId, Window* pParent, const SfxItemSet& rSet )
2146 {
2147     SfxTabPage* pRet = NULL;
2148     ScAbstractDialogFactory* pFact = ScAbstractDialogFactory::Create();
2149     OSL_ENSURE(pFact, "ScAbstractFactory create fail!");
2150     switch(nId)
2151     {
2152         case SID_SC_TP_LAYOUT:
2153                                 {
2154                                     ::CreateTabPage ScTpLayoutOptionsCreate = pFact->GetTabPageCreatorFunc( RID_SCPAGE_LAYOUT );
2155                                     if ( ScTpLayoutOptionsCreate )
2156                                         pRet =  (*ScTpLayoutOptionsCreate) (pParent, rSet);
2157                                 }
2158                                 break;
2159         case SID_SC_TP_CONTENT:
2160                                 {
2161                                     ::CreateTabPage ScTpContentOptionsCreate = pFact->GetTabPageCreatorFunc(RID_SCPAGE_CONTENT);
2162                                     if ( ScTpContentOptionsCreate )
2163                                         pRet = (*ScTpContentOptionsCreate)(pParent, rSet);
2164                                 }
2165                                 break;
2166         case SID_SC_TP_GRID:            pRet = SvxGridTabPage::Create(pParent, rSet); break;
2167         case SID_SC_TP_USERLISTS:
2168                                 {
2169                                     ::CreateTabPage ScTpUserListsCreate = pFact->GetTabPageCreatorFunc( RID_SCPAGE_USERLISTS );
2170                                     if ( ScTpUserListsCreate )
2171                                             pRet = (*ScTpUserListsCreate)( pParent, rSet);
2172                                 }
2173                                 break;
2174         case SID_SC_TP_CALC:
2175                                 {
2176                                                     ::CreateTabPage ScTpCalcOptionsCreate = pFact->GetTabPageCreatorFunc( RID_SCPAGE_CALC );
2177                                                     if ( ScTpCalcOptionsCreate )
2178                                                         pRet = (*ScTpCalcOptionsCreate)(pParent, rSet);
2179                                 }
2180                                 break;
2181         case SID_SC_TP_FORMULA:
2182         {
2183             ::CreateTabPage ScTpFormulaOptionsCreate = pFact->GetTabPageCreatorFunc (RID_SCPAGE_FORMULA);
2184             if (ScTpFormulaOptionsCreate)
2185                 pRet = (*ScTpFormulaOptionsCreate)(pParent, rSet);
2186         }
2187         break;
2188         case SID_SC_TP_COMPATIBILITY:
2189         {
2190             ::CreateTabPage ScTpCompatOptionsCreate = pFact->GetTabPageCreatorFunc (RID_SCPAGE_COMPATIBILITY);
2191             if (ScTpCompatOptionsCreate)
2192                 pRet = (*ScTpCompatOptionsCreate)(pParent, rSet);
2193         }
2194         break;
2195         case SID_SC_TP_CHANGES:
2196                                 {
2197                                             ::CreateTabPage ScRedlineOptionsTabPageCreate = pFact->GetTabPageCreatorFunc( RID_SCPAGE_OPREDLINE );
2198                                             if ( ScRedlineOptionsTabPageCreate )
2199                                                     pRet =(*ScRedlineOptionsTabPageCreate)(pParent, rSet);
2200                                 }
2201                         break;
2202         case RID_SC_TP_PRINT:
2203                                 {
2204                                     ::CreateTabPage ScTpPrintOptionsCreate =    pFact->GetTabPageCreatorFunc( RID_SCPAGE_PRINT );
2205                                     if ( ScTpPrintOptionsCreate )
2206                                         pRet = (*ScTpPrintOptionsCreate)( pParent, rSet);
2207                                 }
2208             break;
2209         case RID_SC_TP_DEFAULTS:
2210             {
2211                 ::CreateTabPage ScTpDefaultsOptionsCreate = pFact->GetTabPageCreatorFunc( RID_SCPAGE_DEFAULTS );
2212                 if ( ScTpDefaultsOptionsCreate )
2213                     pRet = (*ScTpDefaultsOptionsCreate)( pParent, rSet);
2214             }
2215             break;
2216     }
2217
2218     OSL_ENSURE( pRet, "ScModule::CreateTabPage(): no valid ID for TabPage!" );
2219
2220     return pRet;
2221 }
2222
2223 //------------------------------------------------------------------
2224
2225 IMPL_LINK( ScModule, CalcFieldValueHdl, EditFieldInfo*, pInfo )
2226 {
2227     //! mit ScFieldEditEngine zusammenfassen !!!
2228
2229     if (pInfo)
2230     {
2231         const SvxFieldItem& rField = pInfo->GetField();
2232         const SvxFieldData* pField = rField.GetField();
2233
2234         if (pField && pField->ISA(SvxURLField))
2235         {
2236             /******************************************************************
2237             * URL-Field
2238             ******************************************************************/
2239
2240             const SvxURLField* pURLField = (const SvxURLField*) pField;
2241             OUString aURL = pURLField->GetURL();
2242
2243             switch ( pURLField->GetFormat() )
2244             {
2245                 case SVXURLFORMAT_APPDEFAULT: //!!! einstellbar an App???
2246                 case SVXURLFORMAT_REPR:
2247                 {
2248                     pInfo->SetRepresentation( pURLField->GetRepresentation() );
2249                 }
2250                 break;
2251
2252                 case SVXURLFORMAT_URL:
2253                 {
2254                     pInfo->SetRepresentation( aURL );
2255                 }
2256                 break;
2257             }
2258
2259             svtools::ColorConfigEntry eEntry =
2260                 INetURLHistory::GetOrCreate()->QueryUrl( aURL ) ? svtools::LINKSVISITED : svtools::LINKS;
2261             pInfo->SetTxtColor( GetColorConfig().GetColorValue(eEntry).nColor );
2262         }
2263         else
2264         {
2265             OSL_FAIL("unbekannter Feldbefehl");
2266             pInfo->SetRepresentation(OUString('?'));
2267         }
2268     }
2269
2270     return 0;
2271 }
2272
2273 sal_Bool ScModule::RegisterRefWindow( sal_uInt16 nSlotId, Window *pWnd )
2274 {
2275     std::list<Window*> & rlRefWindow = m_mapRefWindow[nSlotId];
2276
2277     if( std::find( rlRefWindow.begin(), rlRefWindow.end(), pWnd ) == rlRefWindow.end() )
2278     {
2279         rlRefWindow.push_back( pWnd );
2280         return sal_True;
2281     }
2282
2283     return false;
2284 }
2285
2286 sal_Bool  ScModule::UnregisterRefWindow( sal_uInt16 nSlotId, Window *pWnd )
2287 {
2288     std::map<sal_uInt16, std::list<Window*> >::iterator iSlot = m_mapRefWindow.find( nSlotId );
2289
2290     if( iSlot == m_mapRefWindow.end() )
2291         return false;
2292
2293     std::list<Window*> & rlRefWindow = iSlot->second;
2294
2295     std::list<Window*>::iterator i = std::find( rlRefWindow.begin(), rlRefWindow.end(), pWnd );
2296
2297     if( i == rlRefWindow.end() )
2298         return false;
2299
2300     rlRefWindow.erase( i );
2301
2302     if( rlRefWindow.empty() )
2303         m_mapRefWindow.erase( nSlotId );
2304
2305     return sal_True;
2306 }
2307
2308 sal_Bool  ScModule::IsAliveRefDlg( sal_uInt16 nSlotId, Window *pWnd )
2309 {
2310     std::map<sal_uInt16, std::list<Window*> >::iterator iSlot = m_mapRefWindow.find( nSlotId );
2311
2312     if( iSlot == m_mapRefWindow.end() )
2313         return false;
2314
2315     std::list<Window*> & rlRefWindow = iSlot->second;
2316
2317     return rlRefWindow.end() != std::find( rlRefWindow.begin(), rlRefWindow.end(), pWnd );
2318 }
2319
2320 Window *  ScModule::Find1RefWindow( sal_uInt16 nSlotId, Window *pWndAncestor )
2321 {
2322     if (!pWndAncestor)
2323         return NULL;
2324
2325     std::map<sal_uInt16, std::list<Window*> >::iterator iSlot = m_mapRefWindow.find( nSlotId );
2326
2327     if( iSlot == m_mapRefWindow.end() )
2328         return NULL;
2329
2330     std::list<Window*> & rlRefWindow = iSlot->second;
2331
2332     while( Window *pParent = pWndAncestor->GetParent() ) pWndAncestor = pParent;
2333
2334     for( std::list<Window*>::iterator i = rlRefWindow.begin(); i!=rlRefWindow.end(); ++i )
2335         if ( pWndAncestor->IsWindowOrChild( *i, (*i)->IsSystemWindow() ) )
2336             return *i;
2337
2338     return NULL;
2339 }
2340
2341 ScAnyRefModalDlg* ScModule::GetCurrentAnyRefDlg()
2342 {
2343     if(!maAnyRefDlgStack.empty())
2344         return maAnyRefDlgStack.top();
2345
2346     return NULL;
2347 }
2348
2349 void ScModule::PushNewAnyRefDlg( ScAnyRefModalDlg* pNewDlg )
2350 {
2351     maAnyRefDlgStack.push( pNewDlg );
2352
2353     // prevent mismatch between calls to
2354     // SetInRefMode(true) and SetInRefMode(false)
2355     if(maAnyRefDlgStack.size() != 1)
2356         return;
2357
2358     SfxViewShell* pViewShell = SfxViewShell::GetFirst();
2359     while(pViewShell)
2360     {
2361         if ( pViewShell->ISA(ScTabViewShell) )
2362         {
2363             ScTabViewShell* pViewSh = (ScTabViewShell*)pViewShell;
2364             pViewSh->SetInRefMode( true );
2365         }
2366         pViewShell = SfxViewShell::GetNext( *pViewShell );
2367     }
2368 }
2369
2370 void ScModule::PopAnyRefDlg()
2371 {
2372     maAnyRefDlgStack.pop();
2373
2374     if(maAnyRefDlgStack.empty())
2375     {
2376         // no modal ref dlg any more
2377         // disable the flag in ScGridWindow
2378
2379         SfxViewShell* pViewShell = SfxViewShell::GetFirst();
2380         while(pViewShell)
2381         {
2382             if ( pViewShell->ISA(ScTabViewShell) )
2383             {
2384                 ScTabViewShell* pViewSh = (ScTabViewShell*)pViewShell;
2385                 pViewSh->SetInRefMode( false );
2386             }
2387             pViewShell = SfxViewShell::GetNext( *pViewShell );
2388         }
2389
2390     }
2391 }
2392
2393 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */