sc/source/ui/miscdlgs/anyrefdg.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: anyrefdg.cxx,v $
  10  * $Revision: 1.21.30.3 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_sc.hxx"
  33
  34
  35
  36 //----------------------------------------------------------------------------
  37
  38 #include "rangelst.hxx"
  39 #include <sfx2/app.hxx>
  40 #include <sfx2/viewsh.hxx>
  41 #include <vcl/wrkwin.hxx>
  42 #include <vcl/mnemonic.hxx>
  43 #include <tools/shl.hxx>
  44 #include <svtools/taskbar.hxx>
  45 #include <sfx2/topfrm.hxx>
  46 #include <sfx2/bindings.hxx>
  47 #include <sfx2/dispatch.hxx>
  48
  49
  50 #define ANYREFDG_CXX
  51 #include "anyrefdg.hxx"
  52 #undef ANYREFDG_CXX
  53
  54 #include "sc.hrc"
  55 #include "inputhdl.hxx"
  56 #include "scmod.hxx"
  57 #include "scresid.hxx"
  58 #include "inputwin.hxx"
  59 #include "tabvwsh.hxx"
  60 #include "docsh.hxx"
  61 #include "rfindlst.hxx"
  62 #include "compiler.hxx"
  63 #include "cell.hxx"
  64 #include "global.hxx"
  65 #include "inputopt.hxx"
  66 #include "rangeutl.hxx"
  67
  68
  69 ScFormulaReferenceHelper::ScFormulaReferenceHelper(IAnyRefDialog* _pDlg,SfxBindings* _pBindings)
  70  : m_pDlg(_pDlg)
  71  , pRefEdit (NULL)
  72  , m_pWindow(NULL)
  73  , m_pBindings(_pBindings)
  74  , pAccel( NULL )
  75  , pHiddenMarks(NULL)
  76  , nRefTab(0)
  77  , bHighLightRef( FALSE )
  78  , bAccInserted( FALSE )
  79 {
  80     ScInputOptions aInputOption=SC_MOD()->GetInputOptions();
  81     bEnableColorRef=aInputOption.GetRangeFinder();
  82 }
  83 // -----------------------------------------------------------------------------
  84 ScFormulaReferenceHelper::~ScFormulaReferenceHelper()
  85 {
  86     if (bAccInserted)
  87         Application::RemoveAccel( pAccel.get() );
  88
  89     // common cleanup for ScAnyRefDlg and ScFormulaDlg is done here
  90
  91     HideReference();
  92     enableInput( TRUE );
  93
  94     ScInputHandler* pInputHdl = SC_MOD()->GetInputHdl();
  95     if ( pInputHdl )
  96         pInputHdl->ResetDelayTimer();   // stop the timer for disabling the input line
  97 }
  98 // -----------------------------------------------------------------------------
  99 void ScFormulaReferenceHelper::enableInput( BOOL bEnable )
 100 {
 101     TypeId aType(TYPE(ScDocShell));
 102     ScDocShell* pDocShell = (ScDocShell*)SfxObjectShell::GetFirst(&aType);
 103     while( pDocShell )
 104     {
 105         SfxViewFrame* pFrame = SfxViewFrame::GetFirst( pDocShell );
 106         while( pFrame )
 107         {
 108             //  #71577# enable everything except InPlace, including bean frames
 109             if ( !pFrame->GetFrame()->IsInPlace() )
 110             {
 111                 SfxViewShell* p = pFrame->GetViewShell();
 112                 ScTabViewShell* pViewSh = PTR_CAST(ScTabViewShell,p);
 113                 if(pViewSh!=NULL)
 114                 {
 115                     Window *pWin=pViewSh->GetWindow();
 116                     if(pWin)
 117                     {
 118                         Window *pParent=pWin->GetParent();
 119                         if(pParent)
 120                         {
 121                             pParent->EnableInput(bEnable,TRUE /* FALSE */);
 122                             if(TRUE /*bChilds*/)
 123                                 pViewSh->EnableRefInput(bEnable);
 124                         }
 125                     }
 126                 }
 127             }
 128             pFrame = SfxViewFrame::GetNext( *pFrame, pDocShell );
 129         }
 130
 131         pDocShell = (ScDocShell*)SfxObjectShell::GetNext(*pDocShell, &aType);
 132     }
 133 }
 134 // -----------------------------------------------------------------------------
 135 void ScFormulaReferenceHelper::ShowSimpleReference( const XubString& rStr )
 136 {
 137     if( /*!pRefEdit &&*/ bEnableColorRef )
 138     {
 139         bHighLightRef=TRUE;
 140         ScViewData* pViewData=ScDocShell::GetViewData();
 141         if ( pViewData )
 142         {
 143             ScDocument* pDoc=pViewData->GetDocument();
 144             ScTabViewShell*     pTabViewShell=pViewData->GetViewShell();
 145
 146             ScRangeList aRangeList;
 147
 148             pTabViewShell->DoneRefMode( FALSE );
 149             pTabViewShell->ClearHighlightRanges();
 150
 151             if( ParseWithNames( aRangeList, rStr, pDoc ) )
 152             {
 153                 ScRange* pRangeEntry = aRangeList.First();
 154
 155                 USHORT nIndex=0;
 156                 while(pRangeEntry != NULL)
 157                 {
 158                     ColorData aColName = ScRangeFindList::GetColorName(nIndex++);
 159                     pTabViewShell->AddHighlightRange(*pRangeEntry, aColName);
 160
 161                     pRangeEntry = aRangeList.Next();
 162                 }
 163             }
 164         }
 165     }
 166 }
 167 // -----------------------------------------------------------------------------
 168 bool ScFormulaReferenceHelper::ParseWithNames( ScRangeList& rRanges, const String& rStr, ScDocument* pDoc )
 169 {
 170     bool bError = false;
 171     rRanges.RemoveAll();
 172
 173     ScAddress::Details aDetails(pDoc->GetAddressConvention(), 0, 0);
 174     ScRangeUtil aRangeUtil;
 175     xub_StrLen nTokenCnt = rStr.GetTokenCount();
 176     for( xub_StrLen nToken = 0; nToken < nTokenCnt; ++nToken )
 177     {
 178         ScRange aRange;
 179         String aRangeStr( rStr.GetToken( nToken ) );
 180
 181         USHORT nFlags = aRange.ParseAny( aRangeStr, pDoc, aDetails );
 182         if ( nFlags & SCA_VALID )
 183         {
 184             if ( (nFlags & SCA_TAB_3D) == 0 )
 185                 aRange.aStart.SetTab( nRefTab );
 186             if ( (nFlags & SCA_TAB2_3D) == 0 )
 187                 aRange.aEnd.SetTab( aRange.aStart.Tab() );
 188             rRanges.Append( aRange );
 189         }
 190         else if ( aRangeUtil.MakeRangeFromName( aRangeStr, pDoc, nRefTab, aRange, RUTL_NAMES, aDetails ) )
 191             rRanges.Append( aRange );
 192         else
 193             bError = true;
 194     }
 195
 196     return !bError;
 197 }
 198 // -----------------------------------------------------------------------------
 199 void ScFormulaReferenceHelper::ShowFormulaReference( const XubString& rStr )
 200 {
 201     if( /*!pRefEdit &&*/ bEnableColorRef)
 202     {
 203         bHighLightRef=TRUE;
 204         ScViewData* pViewData=ScDocShell::GetViewData();
 205         if ( pViewData && pRefComp.get() )
 206         {
 207             ScTabViewShell*     pTabViewShell=pViewData->GetViewShell();
 208             SCCOL nCol = pViewData->GetCurX();
 209             SCROW nRow = pViewData->GetCurY();
 210             SCTAB nTab = pViewData->GetTabNo();
 211             ScAddress aPos( nCol, nRow, nTab );
 212
 213             ScTokenArray* pScTokA=pRefComp->CompileString(rStr);
 214             //pRefComp->CompileTokenArray();
 215
 216             if(pTabViewShell!=NULL && pScTokA!=NULL)
 217             {
 218                 pTabViewShell->DoneRefMode( FALSE );
 219                 pTabViewShell->ClearHighlightRanges();
 220
 221                 pScTokA->Reset();
 222                 const ScToken* pToken = static_cast<const ScToken*>(pScTokA->GetNextReference());
 223
 224                 USHORT nIndex=0;
 225
 226                 while(pToken!=NULL)
 227                 {
 228                     BOOL bDoubleRef=(pToken->GetType()==formula::svDoubleRef);
 229
 230
 231                     if(pToken->GetType()==formula::svSingleRef || bDoubleRef)
 232                     {
 233                         ScRange aRange;
 234                         if(bDoubleRef)
 235                         {
 236                             ScComplexRefData aRef( pToken->GetDoubleRef() );
 237                             aRef.CalcAbsIfRel( aPos );
 238                             aRange.aStart.Set( aRef.Ref1.nCol, aRef.Ref1.nRow, aRef.Ref1.nTab );
 239                             aRange.aEnd.Set( aRef.Ref2.nCol, aRef.Ref2.nRow, aRef.Ref2.nTab );
 240                         }
 241                         else
 242                         {
 243                             ScSingleRefData aRef( pToken->GetSingleRef() );
 244                             aRef.CalcAbsIfRel( aPos );
 245                             aRange.aStart.Set( aRef.nCol, aRef.nRow, aRef.nTab );
 246                             aRange.aEnd = aRange.aStart;
 247                         }
 248                         ColorData aColName=ScRangeFindList::GetColorName(nIndex++);
 249                         pTabViewShell->AddHighlightRange(aRange, aColName);
 250                     }
 251
 252                     pToken = static_cast<const ScToken*>(pScTokA->GetNextReference());
 253                 }
 254             }
 255             if(pScTokA!=NULL) delete pScTokA;
 256         }
 257     }
 258 }
 259 // -----------------------------------------------------------------------------
 260 void ScFormulaReferenceHelper::HideReference( BOOL bDoneRefMode )
 261 {
 262     ScViewData* pViewData=ScDocShell::GetViewData();
 263
 264     if( pViewData && /*!pRefEdit &&*/ bHighLightRef && bEnableColorRef)
 265     {
 266         ScTabViewShell* pTabViewShell=pViewData->GetViewShell();
 267
 268         if(pTabViewShell!=NULL)
 269         {
 270             //  bDoneRefMode is FALSE when called from before SetReference.
 271             //  In that case, RefMode was just started and must not be ended now.
 272
 273             if ( bDoneRefMode )
 274                 pTabViewShell->DoneRefMode( FALSE );
 275             pTabViewShell->ClearHighlightRanges();
 276         }
 277         bHighLightRef=FALSE;
 278     }
 279 }
 280 // -----------------------------------------------------------------------------
 281 void ScFormulaReferenceHelper::ShowReference( const XubString& rStr )
 282 {
 283     if( /*!pRefEdit &&*/ bEnableColorRef )
 284     {
 285         if(     rStr.Search('(')!=STRING_NOTFOUND ||
 286             rStr.Search('+')!=STRING_NOTFOUND ||
 287             rStr.Search('*')!=STRING_NOTFOUND ||
 288             rStr.Search('-')!=STRING_NOTFOUND ||
 289             rStr.Search('/')!=STRING_NOTFOUND ||
 290             rStr.Search('&')!=STRING_NOTFOUND ||
 291             rStr.Search('<')!=STRING_NOTFOUND ||
 292             rStr.Search('>')!=STRING_NOTFOUND ||
 293             rStr.Search('=')!=STRING_NOTFOUND ||
 294             rStr.Search('^')!=STRING_NOTFOUND)
 295         {
 296             ShowFormulaReference(rStr);
 297         }
 298         else
 299         {
 300             ShowSimpleReference(rStr);
 301         }
 302     }
 303 }
 304 // -----------------------------------------------------------------------------
 305 void ScFormulaReferenceHelper::ReleaseFocus( formula::RefEdit* pEdit, formula::RefButton* pButton )
 306 {
 307     if( !pRefEdit && pEdit )
 308     {
 309         m_pDlg->RefInputStart( pEdit, pButton );
 310 //        if( pRefEdit )
 311 //            pRefEdit->SilentGrabFocus();
 312     }
 313
 314     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
 315     if( pViewShell )
 316     {
 317         pViewShell->ActiveGrabFocus();
 318         if( pRefEdit )
 319         {
 320             const ScViewData* pViewData = pViewShell->GetViewData();
 321             ScDocument* pDoc = pViewData->GetDocument();
 322             ScRangeList aRangeList;
 323             if( ParseWithNames( aRangeList, pRefEdit->GetText(), pDoc ) )
 324             {
 325                 const ScRange* pRange = aRangeList.GetObject( 0 );
 326                 if( pRange )
 327                 {
 328                     pViewShell->SetTabNo( pRange->aStart.Tab() );
 329                     pViewShell->MoveCursorAbs(  pRange->aStart.Col(),
 330                         pRange->aStart.Row(), SC_FOLLOW_JUMP, FALSE, FALSE );
 331                     pViewShell->MoveCursorAbs( pRange->aEnd.Col(),
 332                         pRange->aEnd.Row(), SC_FOLLOW_JUMP, TRUE, FALSE );
 333                     m_pDlg->SetReference( *pRange, pDoc );
 334                 }
 335             }
 336         }
 337     }
 338 }
 339 // -----------------------------------------------------------------------------
 340 void ScFormulaReferenceHelper::Init()
 341 {
 342     ScViewData* pViewData=ScDocShell::GetViewData();    //! use pScViewShell?
 343     if ( pViewData )
 344     {
 345         ScDocument* pDoc = pViewData->GetDocument();
 346         SCCOL nCol = pViewData->GetCurX();
 347         SCROW nRow = pViewData->GetCurY();
 348         SCTAB nTab = pViewData->GetTabNo();
 349         ScAddress aCursorPos( nCol, nRow, nTab );
 350
 351         String rStrExp;
 352         pRefCell.reset( new ScFormulaCell( pDoc, aCursorPos, rStrExp ) );
 353         pRefComp.reset( new ScCompiler( pDoc, aCursorPos) );
 354         pRefComp->SetGrammar( pDoc->GetGrammar() );
 355         pRefComp->SetCompileForFAP(TRUE);
 356
 357         nRefTab = nTab;
 358     } // if ( pViewData )
 359 }
 360 // -----------------------------------------------------------------------------
 361 IMPL_LINK( ScFormulaReferenceHelper, AccelSelectHdl, Accelerator *, pSelAccel )
 362 {
 363     if ( !pSelAccel )
 364         return 0;
 365
 366     switch ( pSelAccel->GetCurKeyCode().GetCode() )
 367     {
 368         case KEY_RETURN:
 369         case KEY_ESCAPE:
 370             if( pRefEdit )
 371                 pRefEdit->GrabFocus();
 372             m_pDlg->RefInputDone( TRUE );
 373         break;
 374     }
 375     return TRUE;
 376 }
 377 //----------------------------------------------------------------------------
 378 void ScFormulaReferenceHelper::RefInputDone( BOOL bForced )
 379 {
 380     if (pRefEdit && (bForced || !pRefBtn))
 381     {
 382         if (bAccInserted)                       // Accelerator wieder abschalten
 383         {
 384             Application::RemoveAccel( pAccel.get() );
 385             bAccInserted = FALSE;
 386         }
 387
 388         // Fenstertitel anpassen
 389         m_pWindow->SetText(sOldDialogText);
 390
 391         // Fenster wieder gross
 392         m_pWindow->SetOutputSizePixel(aOldDialogSize);
 393
 394         // pEditCell an alte Position
 395         pRefEdit->SetPosSizePixel(aOldEditPos, aOldEditSize);
 396
 397         // set button position and image
 398         if( pRefBtn )
 399         {
 400             pRefBtn->SetPosPixel( aOldButtonPos );
 401             pRefBtn->SetStartImage();
 402         }
 403
 404         // Alle anderen: Show();
 405         USHORT nChildren = m_pWindow->GetChildCount();
 406         for ( USHORT i = 0; i < nChildren; i++ )
 407             if (pHiddenMarks[i])
 408             {
 409                 m_pWindow->GetChild(i)->GetWindow( WINDOW_CLIENT )->Show();
 410             }
 411         delete [] pHiddenMarks;
 412
 413         pRefEdit = NULL;
 414         pRefBtn = NULL;
 415     }
 416 }
 417 // -----------------------------------------------------------------------------
 418 void ScFormulaReferenceHelper::RefInputStart( formula::RefEdit* pEdit, formula::RefButton* pButton )
 419 {
 420     if (!pRefEdit)
 421     {
 422         pRefEdit = pEdit;
 423         pRefBtn  = pButton;
 424
 425         // Neuen Fenstertitel basteln
 426         String sNewDialogText;
 427         sOldDialogText = m_pWindow->GetText();
 428         sNewDialogText  = sOldDialogText;
 429         sNewDialogText.AppendAscii(RTL_CONSTASCII_STRINGPARAM( ": " ));
 430
 431         // Alle Elemente ausser EditCell und Button verstecken
 432         USHORT nChildren = m_pWindow->GetChildCount();
 433         pHiddenMarks = new BOOL [nChildren];
 434         for (USHORT i = 0; i < nChildren; i++)
 435         {
 436             pHiddenMarks[i] = FALSE;
 437             Window* pWin = m_pWindow->GetChild(i);
 438             pWin = pWin->GetWindow( WINDOW_CLIENT );
 439             if (pWin == (Window*)pRefEdit)
 440             {
 441                 sNewDialogText += m_pWindow->GetChild(i-1)->GetWindow( WINDOW_CLIENT )->GetText();
 442             }
 443             else if (pWin == (Window*)pRefBtn)
 444                 ;       // do nothing
 445             else if (pWin->IsVisible())
 446             {
 447                 pHiddenMarks[i] = TRUE;
 448                 pWin->Hide();
 449             }
 450         }
 451
 452         // Alte Daten merken
 453         aOldDialogSize = m_pWindow->GetOutputSizePixel();
 454         aOldEditPos = pRefEdit->GetPosPixel();
 455         aOldEditSize = pRefEdit->GetSizePixel();
 456         if (pRefBtn)
 457             aOldButtonPos = pRefBtn->GetPosPixel();
 458
 459         // Edit-Feld verschieben und anpassen
 460         Size aNewDlgSize(aOldDialogSize.Width(), aOldEditSize.Height());
 461         Size aNewEditSize(aNewDlgSize);
 462         long nOffset = 0;
 463         if (pRefBtn)
 464         {
 465             aNewEditSize.Width() -= pRefBtn->GetSizePixel().Width();
 466             aNewEditSize.Width() -= aOldButtonPos.X() - (aOldEditPos.X()+aOldEditSize.Width());
 467
 468             long nHeight = pRefBtn->GetSizePixel().Height();
 469             if ( nHeight > aOldEditSize.Height() )
 470             {
 471                 aNewDlgSize.Height() = nHeight;
 472                 nOffset = (nHeight-aOldEditSize.Height()) / 2;
 473             }
 474             aNewEditSize.Width() -= nOffset;
 475         }
 476         pRefEdit->SetPosSizePixel(Point(nOffset, nOffset), aNewEditSize);
 477
 478         // set button position and image
 479         if( pRefBtn )
 480         {
 481             pRefBtn->SetPosPixel( Point( aOldDialogSize.Width() - pRefBtn->GetSizePixel().Width(), 0 ) );
 482             pRefBtn->SetEndImage();
 483         }
 484
 485         // Fenster verkleinern
 486         m_pWindow->SetOutputSizePixel(aNewDlgSize);
 487
 488         // Fenstertitel anpassen
 489         m_pWindow->SetText( MnemonicGenerator::EraseAllMnemonicChars( sNewDialogText ) );
 490
 491 //        if ( pButton )      // ueber den Button: Enter und Escape abfangen
 492 //        {
 493             if (!pAccel.get())
 494             {
 495                 pAccel.reset( new Accelerator );
 496                 pAccel->InsertItem( 1, KeyCode( KEY_RETURN ) );
 497                 pAccel->InsertItem( 2, KeyCode( KEY_ESCAPE ) );
 498                 pAccel->SetSelectHdl( LINK( this, ScFormulaReferenceHelper, AccelSelectHdl ) );
 499             }
 500             Application::InsertAccel( pAccel.get() );
 501             bAccInserted = TRUE;
 502 //        }
 503     }
 504 }
 505 // -----------------------------------------------------------------------------
 506 void ScFormulaReferenceHelper::ToggleCollapsed( formula::RefEdit* pEdit, formula::RefButton* pButton )
 507 {
 508     if( pEdit )
 509     {
 510         if( pRefEdit == pEdit )                 // is this the active ref edit field?
 511         {
 512             pRefEdit->GrabFocus();              // before RefInputDone()
 513             m_pDlg->RefInputDone( TRUE );               // finish ref input
 514         }
 515         else
 516         {
 517             m_pDlg->RefInputDone( TRUE );               // another active ref edit?
 518             m_pDlg->RefInputStart( pEdit, pButton );    // start ref input
 519             // pRefEdit might differ from pEdit after RefInputStart() (i.e. ScFormulaDlg)
 520             if( pRefEdit )
 521                 pRefEdit->GrabFocus();
 522         }
 523     }
 524 }
 525 // -----------------------------------------------------------------------------
 526 BOOL ScFormulaReferenceHelper::DoClose( USHORT nId )
 527 {
 528     SfxApplication* pSfxApp = SFX_APP();
 529
 530     SetDispatcherLock( FALSE );                 //! here and in dtor ?
 531
 532     SfxViewFrame* pViewFrm = SfxViewFrame::Current();
 533     if ( pViewFrm && pViewFrm->HasChildWindow(FID_INPUTLINE_STATUS) )
 534     {
 535         //      Die Eingabezeile wird per ToolBox::Disable disabled, muss darum auch
 536         //      per ToolBox::Enable wieder aktiviert werden (vor dem Enable des AppWindow),
 537         //      damit die Buttons auch wieder enabled gezeichnet werden.
 538         SfxChildWindow* pChild = pViewFrm->GetChildWindow(FID_INPUTLINE_STATUS);
 539         if (pChild)
 540         {
 541             ScInputWindow* pWin = (ScInputWindow*)pChild->GetWindow();
 542             pWin->Enable();
 543         }
 544     }
 545
 546     // find parent view frame to close dialog
 547     SfxViewFrame* pMyViewFrm = NULL;
 548     if ( m_pBindings )
 549     {
 550         SfxDispatcher* pMyDisp = m_pBindings->GetDispatcher();
 551         if (pMyDisp)
 552             pMyViewFrm = pMyDisp->GetFrame();
 553     }
 554     SC_MOD()->SetRefDialog( nId, FALSE, pMyViewFrm );
 555
 556     pSfxApp->Broadcast( SfxSimpleHint( FID_KILLEDITVIEW ) );
 557
 558     ScTabViewShell* pScViewShell = ScTabViewShell::GetActiveViewShell();
 559     if ( pScViewShell )
 560         pScViewShell->UpdateInputHandler(TRUE);
 561
 562     return TRUE;
 563 }
 564 void ScFormulaReferenceHelper::SetDispatcherLock( BOOL bLock )
 565 {
 566     //  lock / unlock only the dispatchers of Calc documents
 567
 568     TypeId aType(TYPE(ScDocShell));
 569     ScDocShell* pDocShell = (ScDocShell*)SfxObjectShell::GetFirst(&aType);
 570     while( pDocShell )
 571     {
 572         SfxViewFrame* pFrame = SfxViewFrame::GetFirst( pDocShell );
 573         while( pFrame )
 574         {
 575             SfxDispatcher* pDisp = pFrame->GetDispatcher();
 576             if (pDisp)
 577                 pDisp->Lock( bLock );
 578
 579             pFrame = SfxViewFrame::GetNext( *pFrame, pDocShell );
 580         }
 581         pDocShell = (ScDocShell*)SfxObjectShell::GetNext(*pDocShell, &aType);
 582     }
 583
 584     //  if a new view is created while the dialog is open,
 585     //  that view's dispatcher is locked when trying to create the dialog
 586     //  for that view (ScTabViewShell::CreateRefDialog)
 587 }
 588 // -----------------------------------------------------------------------------
 589 void ScFormulaReferenceHelper::ViewShellChanged(ScTabViewShell* /* pScViewShell */)
 590 {
 591     enableInput( FALSE );
 592
 593     EnableSpreadsheets();
 594 }
 595 void ScFormulaReferenceHelper::EnableSpreadsheets(BOOL bFlag, BOOL bChilds)
 596 {
 597     TypeId aType(TYPE(ScDocShell));
 598     ScDocShell* pDocShell = (ScDocShell*)SfxObjectShell::GetFirst(&aType);
 599     while( pDocShell )
 600     {
 601         SfxViewFrame* pFrame = SfxViewFrame::GetFirst( pDocShell );
 602         while( pFrame )
 603         {
 604             //  #71577# enable everything except InPlace, including bean frames
 605             if ( !pFrame->GetFrame()->IsInPlace() )
 606             {
 607                 SfxViewShell* p = pFrame->GetViewShell();
 608                 ScTabViewShell* pViewSh = PTR_CAST(ScTabViewShell,p);
 609                 if(pViewSh!=NULL)
 610                 {
 611                     Window *pWin=pViewSh->GetWindow();
 612                     if(pWin)
 613                     {
 614                         Window *pParent=pWin->GetParent();
 615                         if(pParent)
 616                         {
 617                             pParent->EnableInput(bFlag,FALSE);
 618                             if(bChilds)
 619                                 pViewSh->EnableRefInput(bFlag);
 620                         }
 621                     }
 622                 }
 623             }
 624             pFrame = SfxViewFrame::GetNext( *pFrame, pDocShell );
 625         }
 626
 627         pDocShell = (ScDocShell*)SfxObjectShell::GetNext(*pDocShell, &aType);
 628     }
 629 }
 630
 631 //----------------------------------------------------------------------------
 632
 633
 634
 635 void lcl_InvalidateWindows()
 636 {
 637     TypeId aType(TYPE(ScDocShell));
 638     ScDocShell* pDocShell = (ScDocShell*)SfxObjectShell::GetFirst(&aType);
 639     while( pDocShell )
 640     {
 641         SfxViewFrame* pFrame = SfxViewFrame::GetFirst( pDocShell );
 642         while( pFrame )
 643         {
 644             //  #71577# enable everything except InPlace, including bean frames
 645             if ( !pFrame->GetFrame()->IsInPlace() )
 646             {
 647                 SfxViewShell* p = pFrame->GetViewShell();
 648                 ScTabViewShell* pViewSh = PTR_CAST(ScTabViewShell,p);
 649                 if(pViewSh!=NULL)
 650                 {
 651                     Window *pWin=pViewSh->GetWindow();
 652                     if(pWin)
 653                     {
 654                         Window *pParent=pWin->GetParent();
 655                         if(pParent)
 656                             pParent->Invalidate();
 657                     }
 658                 }
 659             }
 660             pFrame = SfxViewFrame::GetNext( *pFrame, pDocShell );
 661         }
 662
 663         pDocShell = (ScDocShell*)SfxObjectShell::GetNext(*pDocShell, &aType);
 664     }
 665 }
 666 //----------------------------------------------------------------------------
 667
 668 void lcl_HideAllReferences()
 669 {
 670     TypeId aScType = TYPE(ScTabViewShell);
 671     SfxViewShell* pSh = SfxViewShell::GetFirst( &aScType );
 672     while ( pSh )
 673     {
 674         ((ScTabViewShell*)pSh)->ClearHighlightRanges();
 675         pSh = SfxViewShell::GetNext( *pSh, &aScType );
 676     }
 677 }
 678
 679 //============================================================================
 680 //      class ScAnyRefDlg
 681 //----------------------------------------------------------------------------
 682
 683 ScAnyRefDlg::ScAnyRefDlg( SfxBindings* pB, SfxChildWindow* pCW,
 684                           Window* pParent, USHORT nResId)
 685     :   SfxModelessDialog ( pB, pCW, pParent, ScResId( nResId ) ),
 686         m_aHelper(this,pB),
 687         pMyBindings( pB ),
 688         pActiveWin(NULL)
 689 {
 690     m_aHelper.SetWindow(this);
 691     if(GetHelpId()==0)                          //Hack, da im SfxModelessDialog die HelpId
 692         SetHelpId(GetUniqueId());       //fuer einen ModelessDialog entfernt und
 693                                     //in eine UniqueId gewandelt wird, machen
 694                                     //wir das an dieser Stelle rueckgaengig.
 695     aTimer.SetTimeout(200);
 696     aTimer.SetTimeoutHdl(LINK( this, ScAnyRefDlg, UpdateFocusHdl));
 697
 698     SC_MOD()->InputEnterHandler();
 699 //    ScTabViewShell* pScViewShell = ScTabViewShell::GetActiveViewShell();
 700
 701     ScTabViewShell* pScViewShell = NULL;
 702
 703     // title has to be from the view that opened the dialog,
 704     // even if it's not the current view
 705
 706     SfxObjectShell* pParentDoc = NULL;
 707     if ( pMyBindings )
 708     {
 709         SfxDispatcher* pMyDisp = pMyBindings->GetDispatcher();
 710         if (pMyDisp)
 711         {
 712             SfxViewFrame* pMyViewFrm = pMyDisp->GetFrame();
 713             if (pMyViewFrm)
 714             {
 715                 pScViewShell = PTR_CAST( ScTabViewShell, pMyViewFrm->GetViewShell() );
 716                 if( pScViewShell )
 717                     pScViewShell->UpdateInputHandler(TRUE);
 718                 pParentDoc = pMyViewFrm->GetObjectShell();
 719             }
 720         }
 721     }
 722     if ( !pParentDoc && pScViewShell )                                  // use current only if above fails
 723         pParentDoc = pScViewShell->GetObjectShell();
 724     if ( pParentDoc )
 725         aDocName = pParentDoc->GetTitle();
 726
 727     ScInputHandler*     pInputHdl = SC_MOD()->GetInputHdl(pScViewShell);
 728
 729     DBG_ASSERT( pInputHdl, "Missing input handler :-/" );
 730
 731     if ( pInputHdl )
 732         pInputHdl->NotifyChange( NULL );
 733
 734     m_aHelper.enableInput( FALSE );
 735
 736     m_aHelper.EnableSpreadsheets();
 737
 738     m_aHelper.Init();
 739
 740     m_aHelper.SetDispatcherLock( TRUE );
 741     //@Test
 742     //SFX_APPWINDOW->Disable(TRUE);       //@BugID 54702
 743 }
 744
 745 //----------------------------------------------------------------------------
 746
 747 ScAnyRefDlg::~ScAnyRefDlg()
 748 {
 749     lcl_HideAllReferences();
 750
 751     SetModalInputMode(FALSE);
 752     SetDispatcherLock( FALSE );                 //! here and in DoClose ?
 753
 754     ScTabViewShell* pScViewShell = ScTabViewShell::GetActiveViewShell();
 755     if( pScViewShell )
 756         pScViewShell->UpdateInputHandler(TRUE);
 757
 758     //SFX_APPWINDOW->Enable(TRUE,TRUE);
 759     lcl_InvalidateWindows();
 760 }
 761
 762 //----------------------------------------------------------------------------
 763
 764 SfxBindings& ScAnyRefDlg::GetBindings()
 765 {
 766     //! SfxModelessDialog should allow access to pBindings pointer
 767
 768     return *pMyBindings;
 769 }
 770
 771 //----------------------------------------------------------------------------
 772
 773 void ScAnyRefDlg::SwitchToDocument()
 774 {
 775     ScTabViewShell* pCurrent = ScTabViewShell::GetActiveViewShell();
 776     if (pCurrent)
 777     {
 778         SfxObjectShell* pObjSh = pCurrent->GetObjectShell();
 779         if ( pObjSh && pObjSh->GetTitle() == aDocName )
 780         {
 781             //  right document already visible -> nothing to do
 782             return;
 783         }
 784     }
 785
 786     TypeId aScType = TYPE(ScTabViewShell);
 787     SfxViewShell* pSh = SfxViewShell::GetFirst( &aScType );
 788     while ( pSh )
 789     {
 790         SfxObjectShell* pObjSh = pSh->GetObjectShell();
 791         if ( pObjSh && pObjSh->GetTitle() == aDocName )
 792         {
 793             //  switch to first TabViewShell for document
 794             ((ScTabViewShell*)pSh)->SetActive();
 795             return;
 796         }
 797         pSh = SfxViewShell::GetNext( *pSh, &aScType );
 798     }
 799 }
 800
 801 //----------------------------------------------------------------------------
 802
 803 BOOL ScAnyRefDlg::IsDocAllowed(SfxObjectShell* pDocSh) const    // pDocSh may be 0
 804 {
 805     //  default: allow only same document (overridden in function dialog)
 806     String aCmpName;
 807     if ( pDocSh )
 808         aCmpName = pDocSh->GetTitle();
 809
 810     //  if aDocName isn't initialized, allow
 811     return ( aDocName.Len() == 0 || aDocName == aCmpName );
 812 }
 813
 814 //----------------------------------------------------------------------------
 815
 816 BOOL __EXPORT ScAnyRefDlg::IsRefInputMode() const
 817 {
 818     return IsVisible(); // nur wer sichtbar ist kann auch Referenzen bekommen
 819 }
 820
 821 //----------------------------------------------------------------------------
 822
 823 BOOL __EXPORT ScAnyRefDlg::DoClose( USHORT nId )
 824 {
 825     m_aHelper.DoClose(nId);
 826     return TRUE;
 827 }
 828
 829 void ScAnyRefDlg::SetDispatcherLock( BOOL bLock )
 830 {
 831     m_aHelper.SetDispatcherLock( bLock );
 832 }
 833
 834 //----------------------------------------------------------------------------
 835
 836 void ScAnyRefDlg::ViewShellChanged(ScTabViewShell*  pScViewShell )
 837 {
 838     m_aHelper.ViewShellChanged(pScViewShell);
 839 }
 840
 841 //----------------------------------------------------------------------------
 842
 843 void ScAnyRefDlg::AddRefEntry()
 844 {
 845     //  wenn nicht ueberladen, gibt es keine Mehrfach-Referenzen
 846 }
 847
 848 //----------------------------------------------------------------------------
 849
 850 BOOL __EXPORT ScAnyRefDlg::IsTableLocked() const
 851 {
 852     // per Default kann bei Referenzeingabe auch die Tabelle umgeschaltet werden
 853
 854     return FALSE;
 855 }
 856
 857 //----------------------------------------------------------------------------
 858 //
 859 //      RefInputStart/Done: Zoom-In (AutoHide) auf einzelnes Feld
 860 //      (per Button oder Bewegung)
 861 //
 862 //----------------------------------------------------------------------------
 863
 864 void ScAnyRefDlg::RefInputStart( formula::RefEdit* pEdit, formula::RefButton* pButton )
 865 {
 866     m_aHelper.RefInputStart( pEdit, pButton );
 867 }
 868
 869
 870 void ScAnyRefDlg::ToggleCollapsed( formula::RefEdit* pEdit, formula::RefButton* pButton )
 871 {
 872     m_aHelper.ToggleCollapsed( pEdit, pButton );
 873 }
 874 long ScAnyRefDlg::PreNotify( NotifyEvent& rNEvt )
 875 {
 876     USHORT nSwitch=rNEvt.GetType();
 877     if(nSwitch==EVENT_GETFOCUS)
 878     {
 879         pActiveWin=rNEvt.GetWindow();
 880     }
 881     return SfxModelessDialog::PreNotify(rNEvt);
 882 }
 883
 884 void ScAnyRefDlg::StateChanged( StateChangedType nStateChange )
 885 {
 886     SfxModelessDialog::StateChanged( nStateChange );
 887
 888     if(nStateChange == STATE_CHANGE_VISIBLE)
 889     {
 890         if(IsVisible())
 891         {
 892             m_aHelper.enableInput( FALSE );
 893             m_aHelper.EnableSpreadsheets();
 894             m_aHelper.SetDispatcherLock( TRUE );
 895             aTimer.Start();
 896         }
 897         else
 898         {
 899             m_aHelper.enableInput( TRUE );
 900             m_aHelper.SetDispatcherLock( FALSE );                       //! here and in DoClose ?
 901         }
 902     }
 903 }
 904
 905 IMPL_LINK( ScAnyRefDlg, UpdateFocusHdl, Timer*, EMPTYARG )
 906 {
 907     if (pActiveWin)
 908     {
 909         pActiveWin->GrabFocus();
 910     }
 911     return 0;
 912 }
 913 // -----------------------------------------------------------------------------
 914 bool ScAnyRefDlg::ParseWithNames( ScRangeList& rRanges, const String& rStr, ScDocument* pDoc )
 915 {
 916     return m_aHelper.ParseWithNames( rRanges, rStr, pDoc );
 917 }
 918 // -----------------------------------------------------------------------------
 919 void ScAnyRefDlg::HideReference( BOOL bDoneRefMode )
 920 {
 921     m_aHelper.HideReference( bDoneRefMode );
 922 }
 923 // -----------------------------------------------------------------------------
 924 void ScAnyRefDlg::ShowReference( const XubString& rStr )
 925 {
 926     m_aHelper.ShowReference( rStr );
 927 }
 928 // -----------------------------------------------------------------------------
 929 void ScAnyRefDlg::ReleaseFocus( formula::RefEdit* pEdit, formula::RefButton* pButton )
 930 {
 931     m_aHelper.ReleaseFocus( pEdit,pButton );
 932 }
 933 //----------------------------------------------------------------------------
 934 void ScAnyRefDlg::RefInputDone( BOOL bForced )
 935 {
 936     m_aHelper.RefInputDone( bForced );
 937 }
 938