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