basctl/source/basicide/basidesh.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include "basidesh.hxx"
  21
  22 #include <tools/diagnose_ex.h>
  23 #include <basic/basmgr.hxx>
  24 #include <basidesh.hrc>
  25 #include "baside2.hxx"
  26 #include "baside3.hxx"
  27 #include <basdoc.hxx>
  28 #include <basicbox.hxx>
  29 #include <editeng/sizeitem.hxx>
  30 #include <objdlg.hxx>
  31 #include <tbxctl.hxx>
  32 #include <iderdll2.hxx>
  33 #include <basidectrlr.hxx>
  34 #include <localizationmgr.hxx>
  35 #include <sfx2/app.hxx>
  36 #include <sfx2/dinfdlg.hxx>
  37 #include <sfx2/dispatch.hxx>
  38 #include <sfx2/minfitem.hxx>
  39 #include <sfx2/objface.hxx>
  40 #include <svl/aeitem.hxx>
  41 #include <svl/intitem.hxx>
  42 #include <svl/srchitem.hxx>
  43
  44 #define basctl_Shell
  45 #define SFX_TYPEMAP
  46 #include <idetemp.hxx>
  47 #include <basslots.hxx>
  48 #include <iderdll.hxx>
  49 #include <svx/pszctrl.hxx>
  50 #include <svx/insctrl.hxx>
  51 #include <svx/srchdlg.hxx>
  52 #include <svx/tbcontrl.hxx>
  53 #include <com/sun/star/script/XLibraryContainerPassword.hpp>
  54 #include <com/sun/star/container/XContainer.hpp>
  55 #include <svx/xmlsecctrl.hxx>
  56 #include <sfx2/viewfac.hxx>
  57 #include <vcl/msgbox.hxx>
  58
  59 namespace basctl
  60 {
  61
  62 using namespace ::com::sun::star::uno;
  63 using namespace ::com::sun::star;
  64
  65 typedef ::cppu::WeakImplHelper1< container::XContainerListener > ContainerListenerBASE;
  66
  67 class ContainerListenerImpl : public ContainerListenerBASE
  68 {
  69     Shell* mpShell;
  70 public:
  71
  72     ContainerListenerImpl (Shell* pShell) : mpShell(pShell) { }
  73
  74     ~ContainerListenerImpl()
  75     { }
  76
  77     void addContainerListener( const ScriptDocument& rScriptDocument, const OUString& aLibName )
  78     {
  79         try
  80         {
  81             uno::Reference< container::XContainer > xContainer( rScriptDocument.getLibrary( E_SCRIPTS, aLibName, false ), uno::UNO_QUERY );
  82             if ( xContainer.is() )
  83             {
  84                 uno::Reference< container::XContainerListener > xContainerListener( this );
  85                 xContainer->addContainerListener( xContainerListener );
  86             }
  87         }
  88         catch(const uno::Exception& ) {}
  89     }
  90     void removeContainerListener( const ScriptDocument& rScriptDocument, const OUString& aLibName )
  91     {
  92         try
  93         {
  94             uno::Reference< container::XContainer > xContainer( rScriptDocument.getLibrary( E_SCRIPTS, aLibName, false ), uno::UNO_QUERY );
  95             if ( xContainer.is() )
  96             {
  97                 uno::Reference< container::XContainerListener > xContainerListener( this );
  98                 xContainer->removeContainerListener( xContainerListener );
  99             }
 100         }
 101         catch(const uno::Exception& ) {}
 102     }
 103
 104     // XEventListener
 105     virtual void SAL_CALL disposing( const lang::EventObject& ) throw( uno::RuntimeException ) {}
 106
 107     // XContainerListener
 108     virtual void SAL_CALL elementInserted( const container::ContainerEvent& Event ) throw( uno::RuntimeException )
 109     {
 110         OUString sModuleName;
 111         if( mpShell && ( Event.Accessor >>= sModuleName ) )
 112             mpShell->FindBasWin( mpShell->m_aCurDocument, mpShell->m_aCurLibName, sModuleName, true, false );
 113     }
 114     virtual void SAL_CALL elementReplaced( const container::ContainerEvent& ) throw( com::sun::star::uno::RuntimeException ) { }
 115     virtual void SAL_CALL elementRemoved( const container::ContainerEvent& Event ) throw( com::sun::star::uno::RuntimeException )
 116     {
 117         OUString sModuleName;
 118         if( mpShell  && ( Event.Accessor >>= sModuleName ) )
 119         {
 120             ModulWindow* pWin = mpShell->FindBasWin(mpShell->m_aCurDocument, mpShell->m_aCurLibName, sModuleName, false, true);
 121             if( pWin )
 122                 mpShell->RemoveWindow( pWin, true, true );
 123         }
 124     }
 125
 126 };
 127
 128 TYPEINIT1( Shell, SfxViewShell );
 129
 130 SFX_IMPL_NAMED_VIEWFACTORY( Shell, "Default" )
 131 {
 132     SFX_VIEW_REGISTRATION( DocShell );
 133 }
 134
 135
 136 SFX_IMPL_INTERFACE( basctl_Shell, SfxViewShell, IDEResId( RID_STR_IDENAME ) )
 137 {
 138     SFX_CHILDWINDOW_REGISTRATION( SID_SEARCH_DLG );
 139     SFX_FEATURED_CHILDWINDOW_REGISTRATION(SID_SHOW_PROPERTYBROWSER, BASICIDE_UI_FEATURE_SHOW_BROWSER);
 140     SFX_POPUPMENU_REGISTRATION( IDEResId( RID_POPUP_DLGED ) );
 141 }
 142
 143
 144
 145 namespace
 146 {
 147
 148 unsigned const ShellFlags = SFX_VIEW_CAN_PRINT | SFX_VIEW_NO_NEWWINDOW;
 149
 150 }
 151
 152
 153 unsigned Shell::nShellCount = 0;
 154
 155 Shell::Shell( SfxViewFrame* pFrame_, SfxViewShell* /* pOldShell */ ) :
 156     SfxViewShell( pFrame_, ShellFlags ),
 157     m_aCurDocument( ScriptDocument::getApplicationScriptDocument() ),
 158     aHScrollBar( &GetViewFrame()->GetWindow(), WinBits( WB_HSCROLL | WB_DRAG ) ),
 159     aVScrollBar( &GetViewFrame()->GetWindow(), WinBits( WB_VSCROLL | WB_DRAG ) ),
 160     aScrollBarBox( &GetViewFrame()->GetWindow(), WinBits( WB_SIZEABLE ) ),
 161     pLayout(0),
 162     aObjectCatalog(&GetViewFrame()->GetWindow()),
 163     m_bAppBasicModified( false ),
 164     m_aNotifier( *this )
 165 {
 166     m_xLibListener = new ContainerListenerImpl( this );
 167     Init();
 168     nShellCount++;
 169 }
 170
 171 void Shell::Init()
 172 {
 173     TbxControls::RegisterControl( SID_CHOOSE_CONTROLS );
 174     SvxPosSizeStatusBarControl::RegisterControl();
 175     SvxInsertStatusBarControl::RegisterControl();
 176     XmlSecStatusBarControl::RegisterControl( SID_SIGNATURE );
 177     SvxSimpleUndoRedoController::RegisterControl( SID_UNDO );
 178     SvxSimpleUndoRedoController::RegisterControl( SID_REDO );
 179
 180     SvxSearchDialogWrapper::RegisterChildWindow(false);
 181
 182     GetExtraData()->ShellInCriticalSection() = true;
 183
 184     SetName( OUString( "BasicIDE" ) );
 185     SetHelpId( SVX_INTERFACE_BASIDE_VIEWSH );
 186
 187     LibBoxControl::RegisterControl( SID_BASICIDE_LIBSELECTOR );
 188     LanguageBoxControl::RegisterControl( SID_BASICIDE_CURRENT_LANG );
 189
 190     GetViewFrame()->GetWindow().SetBackground(
 191         GetViewFrame()->GetWindow().GetSettings().GetStyleSettings().GetWindowColor()
 192     );
 193
 194     pCurWin = 0;
 195     m_aCurDocument = ScriptDocument::getApplicationScriptDocument();
 196     bCreatingWindow = false;
 197
 198     pTabBar.reset(new TabBar(&GetViewFrame()->GetWindow()));
 199     pTabBar->SetSplitHdl( LINK( this, Shell, TabBarSplitHdl ) );
 200     bTabBarSplitted = false;
 201
 202     nCurKey = 100;
 203     InitScrollBars();
 204     InitTabBar();
 205
 206     SetCurLib( ScriptDocument::getApplicationScriptDocument(), "Standard", false, false );
 207
 208     ShellCreated(this);
 209
 210     GetExtraData()->ShellInCriticalSection() = false;
 211
 212     // It's enough to create the controller ...
 213     // It will be public by using magic :-)
 214     new Controller(this);
 215
 216     // Force updating the title ! Because it must be set to the controller
 217     // it has to be called directly after creating those controller.
 218     SetMDITitle ();
 219
 220     UpdateWindows();
 221 }
 222
 223 Shell::~Shell()
 224 {
 225     m_aNotifier.dispose();
 226
 227     ShellDestroyed(this);
 228
 229     // so that on a basic saving error, the shell doesn't pop right up again
 230     GetExtraData()->ShellInCriticalSection() = true;
 231
 232     SetWindow( 0 );
 233     SetCurWindow( 0 );
 234
 235     for (WindowTableIt it = aWindowTable.begin(); it != aWindowTable.end(); ++it)
 236     {
 237         // no store; does already happen when the BasicManagers are destroyed
 238         delete it->second;
 239     }
 240
 241     // Destroy all ContainerListeners for Basic Container.
 242     if (ContainerListenerImpl* pListener = static_cast<ContainerListenerImpl*>(m_xLibListener.get()))
 243         pListener->removeContainerListener(m_aCurDocument, m_aCurLibName);
 244
 245     GetExtraData()->ShellInCriticalSection() = false;
 246
 247     nShellCount--;
 248 }
 249
 250 void Shell::onDocumentCreated( const ScriptDocument& /*_rDocument*/ )
 251 {
 252     if (pCurWin)
 253         pCurWin->OnNewDocument();
 254     UpdateWindows();
 255 }
 256
 257 void Shell::onDocumentOpened( const ScriptDocument& /*_rDocument*/ )
 258 {
 259     if (pCurWin)
 260         pCurWin->OnNewDocument();
 261     UpdateWindows();
 262 }
 263
 264 void Shell::onDocumentSave( const ScriptDocument& /*_rDocument*/ )
 265 {
 266     StoreAllWindowData();
 267 }
 268
 269 void Shell::onDocumentSaveDone( const ScriptDocument& /*_rDocument*/ )
 270 {
 271     // #i115671: Update SID_SAVEDOC after saving is completed
 272     if (SfxBindings* pBindings = GetBindingsPtr())
 273         pBindings->Invalidate( SID_SAVEDOC );
 274 }
 275
 276 void Shell::onDocumentSaveAs( const ScriptDocument& /*_rDocument*/ )
 277 {
 278     StoreAllWindowData();
 279 }
 280
 281 void Shell::onDocumentSaveAsDone( const ScriptDocument& /*_rDocument*/ )
 282 {
 283     // not interested in
 284 }
 285
 286 void Shell::onDocumentClosed( const ScriptDocument& _rDocument )
 287 {
 288     if ( !_rDocument.isValid() )
 289         return;
 290
 291     bool bSetCurWindow = false;
 292     bool bSetCurLib = ( _rDocument == m_aCurDocument );
 293     std::vector<BaseWindow*> aDeleteVec;
 294
 295     // remove all windows which belong to this document
 296     for (WindowTableIt it = aWindowTable.begin(); it != aWindowTable.end(); ++it)
 297     {
 298         BaseWindow* pWin = it->second;
 299         if ( pWin->IsDocument( _rDocument ) )
 300         {
 301             if ( pWin->GetStatus() & (BASWIN_RUNNINGBASIC|BASWIN_INRESCHEDULE) )
 302             {
 303                 pWin->AddStatus( BASWIN_TOBEKILLED );
 304                 pWin->Hide();
 305                 StarBASIC::Stop();
 306                 // there's no notify
 307                 pWin->BasicStopped();
 308             }
 309             else
 310                 aDeleteVec.push_back( pWin );
 311         }
 312     }
 313     // delete windows outside main loop so we don't invalidate the original iterator
 314     for (std::vector<BaseWindow*>::const_iterator it = aDeleteVec.begin(); it != aDeleteVec.end(); ++it)
 315     {
 316         BaseWindow* pWin = *it;
 317         pWin->StoreData();
 318         if ( pWin == pCurWin )
 319             bSetCurWindow = true;
 320         RemoveWindow( pWin, true, false );
 321     }
 322
 323     // remove lib info
 324     if (ExtraData* pData = GetExtraData())
 325         pData->GetLibInfos().RemoveInfoFor( _rDocument );
 326
 327     if ( bSetCurLib )
 328         SetCurLib( ScriptDocument::getApplicationScriptDocument(), "Standard", true, false );
 329     else if ( bSetCurWindow )
 330         SetCurWindow( FindApplicationWindow(), true );
 331 }
 332
 333 void Shell::onDocumentTitleChanged( const ScriptDocument& /*_rDocument*/ )
 334 {
 335     if (SfxBindings* pBindings = GetBindingsPtr())
 336         pBindings->Invalidate( SID_BASICIDE_LIBSELECTOR, true, false );
 337     SetMDITitle();
 338 }
 339
 340 void Shell::onDocumentModeChanged( const ScriptDocument& _rDocument )
 341 {
 342     for (WindowTableIt it = aWindowTable.begin(); it != aWindowTable.end(); ++it)
 343     {
 344         BaseWindow* pWin = it->second;
 345         if ( pWin->IsDocument( _rDocument ) && _rDocument.isDocument() )
 346             pWin->SetReadOnly( _rDocument.isReadOnly() );
 347     }
 348 }
 349
 350 void Shell::StoreAllWindowData( bool bPersistent )
 351 {
 352     for (WindowTableIt it = aWindowTable.begin(); it != aWindowTable.end(); ++it)
 353     {
 354         BaseWindow* pWin = it->second;
 355         DBG_ASSERT( pWin, "PrepareClose: NULL-Pointer in Table?" );
 356         if ( !pWin->IsSuspended() )
 357             pWin->StoreData();
 358     }
 359
 360     if ( bPersistent  )
 361     {
 362         SFX_APP()->SaveBasicAndDialogContainer();
 363         SetAppBasicModified(false);
 364
 365         if (SfxBindings* pBindings = GetBindingsPtr())
 366         {
 367             pBindings->Invalidate( SID_SAVEDOC );
 368             pBindings->Update( SID_SAVEDOC );
 369         }
 370     }
 371 }
 372
 373
 374 sal_uInt16 Shell::PrepareClose( sal_Bool bUI, sal_Bool bForBrowsing )
 375 {
 376     (void)bForBrowsing;
 377
 378     // reset here because it's modified after printing etc. (DocInfo)
 379     GetViewFrame()->GetObjectShell()->SetModified(false);
 380
 381     if ( StarBASIC::IsRunning() )
 382     {
 383         if( bUI )
 384         {
 385             Window *pParent = &GetViewFrame()->GetWindow();
 386             InfoBox( pParent, IDE_RESSTR(RID_STR_CANNOTCLOSE)).Execute();
 387         }
 388         return false;
 389     }
 390     else
 391     {
 392         bool bCanClose = true;
 393         for (WindowTableIt it = aWindowTable.begin(); bCanClose && (it != aWindowTable.end()); ++it)
 394         {
 395             BaseWindow* pWin = it->second;
 396             if ( !pWin->CanClose() )
 397             {
 398                 if ( !m_aCurLibName.isEmpty() && ( pWin->IsDocument( m_aCurDocument ) || pWin->GetLibName() != m_aCurLibName ) )
 399                     SetCurLib( ScriptDocument::getApplicationScriptDocument(), OUString(), false );
 400                 SetCurWindow( pWin, true );
 401                 bCanClose = false;
 402             }
 403         }
 404
 405         if ( bCanClose )
 406             StoreAllWindowData( false );    // don't write on the disk, that will be done later automatically
 407
 408         return bCanClose;
 409     }
 410 }
 411
 412 void Shell::InitScrollBars()
 413 {
 414     aVScrollBar.SetLineSize( 300 );
 415     aVScrollBar.SetPageSize( 2000 );
 416     aHScrollBar.SetLineSize( 300 );
 417     aHScrollBar.SetPageSize( 2000 );
 418     aHScrollBar.Enable();
 419     aVScrollBar.Enable();
 420     aVScrollBar.Show();
 421     aHScrollBar.Show();
 422     aScrollBarBox.Show();
 423 }
 424
 425
 426
 427 void Shell::InitTabBar()
 428 {
 429     pTabBar->Enable();
 430     pTabBar->Show();
 431     pTabBar->SetSelectHdl( LINK( this, Shell, TabBarHdl ) );
 432 }
 433
 434
 435
 436 void Shell::OuterResizePixel( const Point &rPos, const Size &rSize )
 437 {
 438     AdjustPosSizePixel( rPos, rSize );
 439 }
 440
 441
 442 IMPL_LINK_INLINE_START( Shell, TabBarSplitHdl, TabBar *, pTBar )
 443 {
 444     (void)pTBar;
 445     bTabBarSplitted = true;
 446     ArrangeTabBar();
 447
 448     return 0;
 449 }
 450 IMPL_LINK_INLINE_END( Shell, TabBarSplitHdl, TabBar *, pTBar )
 451
 452
 453
 454 IMPL_LINK( Shell, TabBarHdl, TabBar *, pCurTabBar )
 455 {
 456     sal_uInt16 nCurId = pCurTabBar->GetCurPageId();
 457     BaseWindow* pWin = aWindowTable[ nCurId ];
 458     DBG_ASSERT( pWin, "Eintrag in TabBar passt zu keinem Fenster!" );
 459     SetCurWindow( pWin );
 460
 461     return 0;
 462 }
 463
 464
 465
 466 bool Shell::NextPage( bool bPrev )
 467 {
 468     bool bRet = false;
 469     sal_uInt16 nPos = pTabBar->GetPagePos( pTabBar->GetCurPageId() );
 470
 471     if ( bPrev )
 472         --nPos;
 473     else
 474         ++nPos;
 475
 476     if ( nPos < pTabBar->GetPageCount() )
 477     {
 478         BaseWindow* pWin = aWindowTable[ pTabBar->GetPageId( nPos ) ];
 479         SetCurWindow( pWin, true );
 480         bRet = true;
 481     }
 482
 483     return bRet;
 484 }
 485
 486
 487
 488 void Shell::ArrangeTabBar()
 489 {
 490     long nBoxPos = aScrollBarBox.GetPosPixel().X() - 1;
 491     long nPos = pTabBar->GetSplitSize();
 492     if ( nPos <= nBoxPos )
 493     {
 494         Point aPnt( pTabBar->GetPosPixel() );
 495         long nH = aHScrollBar.GetSizePixel().Height();
 496         pTabBar->SetPosSizePixel( aPnt, Size( nPos, nH ) );
 497         long nScrlStart = aPnt.X() + nPos;
 498         aHScrollBar.SetPosSizePixel( Point( nScrlStart, aPnt.Y() ), Size( nBoxPos - nScrlStart + 2, nH ) );
 499         aHScrollBar.Update();
 500     }
 501 }
 502
 503
 504
 505 ::svl::IUndoManager* Shell::GetUndoManager()
 506 {
 507     ::svl::IUndoManager* pMgr = NULL;
 508     if( pCurWin )
 509         pMgr = pCurWin->GetUndoManager();
 510
 511     return pMgr;
 512 }
 513
 514
 515
 516 void Shell::SFX_NOTIFY( SfxBroadcaster& rBC, const TypeId&,
 517                                         const SfxHint& rHint, const TypeId& )
 518 {
 519     if (GetShell())
 520     {
 521         if (SfxSimpleHint const* pSimpleHint = dynamic_cast<SfxSimpleHint const*>(&rHint))
 522         {
 523             switch (pSimpleHint->GetId())
 524             {
 525                 case SFX_HINT_DYING:
 526                 {
 527                     EndListening( rBC, true /* log off all */ );
 528                     aObjectCatalog.UpdateEntries();
 529                 }
 530                 break;
 531             }
 532
 533             if (SbxHint const* pSbxHint = dynamic_cast<SbxHint const*>(&rHint))
 534             {
 535                 sal_uLong nHintId = pSbxHint->GetId();
 536                 if (    ( nHintId == SBX_HINT_BASICSTART ) ||
 537                         ( nHintId == SBX_HINT_BASICSTOP ) )
 538                 {
 539                     if (SfxBindings* pBindings = GetBindingsPtr())
 540                     {
 541                         pBindings->Invalidate( SID_BASICRUN );
 542                         pBindings->Update( SID_BASICRUN );
 543                         pBindings->Invalidate( SID_BASICCOMPILE );
 544                         pBindings->Update( SID_BASICCOMPILE );
 545                         pBindings->Invalidate( SID_BASICSTEPOVER );
 546                         pBindings->Update( SID_BASICSTEPOVER );
 547                         pBindings->Invalidate( SID_BASICSTEPINTO );
 548                         pBindings->Update( SID_BASICSTEPINTO );
 549                         pBindings->Invalidate( SID_BASICSTEPOUT );
 550                         pBindings->Update( SID_BASICSTEPOUT );
 551                         pBindings->Invalidate( SID_BASICSTOP );
 552                         pBindings->Update( SID_BASICSTOP );
 553                         pBindings->Invalidate( SID_BASICIDE_TOGGLEBRKPNT );
 554                         pBindings->Update( SID_BASICIDE_TOGGLEBRKPNT );
 555                         pBindings->Invalidate( SID_BASICIDE_MANAGEBRKPNTS );
 556                         pBindings->Update( SID_BASICIDE_MANAGEBRKPNTS );
 557                         pBindings->Invalidate( SID_BASICIDE_MODULEDLG );
 558                         pBindings->Update( SID_BASICIDE_MODULEDLG );
 559                         pBindings->Invalidate( SID_BASICLOAD );
 560                         pBindings->Update( SID_BASICLOAD );
 561                     }
 562
 563                     if ( nHintId == SBX_HINT_BASICSTOP )
 564                     {
 565                         // not only at error/break or explicit stoppage,
 566                         // if the update is turned off due to a programming bug
 567                         BasicStopped();
 568                         if (pLayout)
 569                             pLayout->UpdateDebug(true); // clear...
 570                         if( m_pCurLocalizationMgr )
 571                             m_pCurLocalizationMgr->handleBasicStopped();
 572                     }
 573                     else if( m_pCurLocalizationMgr )
 574                     {
 575                         m_pCurLocalizationMgr->handleBasicStarted();
 576                     }
 577
 578                     for (WindowTableIt it = aWindowTable.begin(); it != aWindowTable.end(); ++it)
 579                     {
 580                         BaseWindow* pWin = it->second;
 581                         if ( nHintId == SBX_HINT_BASICSTART )
 582                             pWin->BasicStarted();
 583                         else
 584                             pWin->BasicStopped();
 585                     }
 586                 }
 587             }
 588         }
 589     }
 590 }
 591
 592
 593
 594 void Shell::CheckWindows()
 595 {
 596     bool bSetCurWindow = false;
 597     std::vector<BaseWindow*> aDeleteVec;
 598     for (WindowTableIt it = aWindowTable.begin(); it != aWindowTable.end(); ++it)
 599     {
 600         BaseWindow* pWin = it->second;
 601         if ( pWin->GetStatus() & BASWIN_TOBEKILLED )
 602             aDeleteVec.push_back( pWin );
 603     }
 604     for ( std::vector<BaseWindow*>::const_iterator it = aDeleteVec.begin(); it != aDeleteVec.end(); ++it )
 605     {
 606         BaseWindow* pWin = *it;
 607         pWin->StoreData();
 608         if ( pWin == pCurWin )
 609             bSetCurWindow = true;
 610         RemoveWindow( pWin, true, false );
 611     }
 612     if ( bSetCurWindow )
 613         SetCurWindow( FindApplicationWindow(), true );
 614 }
 615
 616
 617
 618 void Shell::RemoveWindows( const ScriptDocument& rDocument, const OUString& rLibName, bool bDestroy )
 619 {
 620     bool bChangeCurWindow = pCurWin ? false : true;
 621     std::vector<BaseWindow*> aDeleteVec;
 622     for (WindowTableIt it = aWindowTable.begin(); it != aWindowTable.end(); ++it)
 623     {
 624         BaseWindow* pWin = it->second;
 625         if ( pWin->IsDocument( rDocument ) && pWin->GetLibName() == rLibName )
 626             aDeleteVec.push_back( pWin );
 627     }
 628     for ( std::vector<BaseWindow*>::const_iterator it = aDeleteVec.begin(); it != aDeleteVec.end(); ++it )
 629     {
 630         BaseWindow* pWin = *it;
 631         if ( pWin == pCurWin )
 632             bChangeCurWindow = true;
 633         pWin->StoreData();
 634         RemoveWindow( pWin, bDestroy, false );
 635     }
 636     if ( bChangeCurWindow )
 637         SetCurWindow( FindApplicationWindow(), true );
 638 }
 639
 640
 641
 642 void Shell::UpdateWindows()
 643 {
 644     // remove all windows that may not be displayed
 645     bool bChangeCurWindow = pCurWin ? false : true;
 646     if ( !m_aCurLibName.isEmpty() )
 647     {
 648         std::vector<BaseWindow*> aDeleteVec;
 649         for (WindowTableIt it = aWindowTable.begin(); it != aWindowTable.end(); ++it)
 650         {
 651             BaseWindow* pWin = it->second;
 652             if ( !pWin->IsDocument( m_aCurDocument ) || pWin->GetLibName() != m_aCurLibName )
 653             {
 654                 if ( pWin == pCurWin )
 655                     bChangeCurWindow = true;
 656                 pWin->StoreData();
 657                 // The request of RUNNING prevents the crash when in reschedule.
 658                 // Window is frozen at first, later the windows should be changed
 659                 // anyway to be marked as hidden instead of being deleted.
 660                 if ( !(pWin->GetStatus() & ( BASWIN_TOBEKILLED | BASWIN_RUNNINGBASIC | BASWIN_SUSPENDED ) ) )
 661                     aDeleteVec.push_back( pWin );
 662             }
 663         }
 664         for ( std::vector<BaseWindow*>::const_iterator it = aDeleteVec.begin(); it != aDeleteVec.end(); ++it )
 665         {
 666             RemoveWindow( *it, false, false );
 667         }
 668     }
 669
 670     if ( bCreatingWindow )
 671         return;
 672
 673     BaseWindow* pNextActiveWindow = 0;
 674
 675     // show all windows that are to be shown
 676     ScriptDocuments aDocuments( ScriptDocument::getAllScriptDocuments( ScriptDocument::AllWithApplication ) );
 677     for (   ScriptDocuments::const_iterator doc = aDocuments.begin();
 678             doc != aDocuments.end();
 679             ++doc
 680         )
 681     {
 682         StartListening( *doc->getBasicManager(), true /* log on only once */ );
 683
 684         // libraries
 685         Sequence< OUString > aLibNames( doc->getLibraryNames() );
 686         sal_Int32 nLibCount = aLibNames.getLength();
 687         const OUString* pLibNames = aLibNames.getConstArray();
 688
 689         for ( sal_Int32 i = 0 ; i < nLibCount ; i++ )
 690         {
 691             OUString aLibName = pLibNames[ i ];
 692
 693             if ( m_aCurLibName.isEmpty() || ( *doc == m_aCurDocument && aLibName == m_aCurLibName ) )
 694             {
 695                 // check, if library is password protected and not verified
 696                 bool bProtected = false;
 697                 Reference< script::XLibraryContainer > xModLibContainer( doc->getLibraryContainer( E_SCRIPTS ) );
 698                 if ( xModLibContainer.is() && xModLibContainer->hasByName( aLibName ) )
 699                 {
 700                     Reference< script::XLibraryContainerPassword > xPasswd( xModLibContainer, UNO_QUERY );
 701                     if ( xPasswd.is() && xPasswd->isLibraryPasswordProtected( aLibName ) && !xPasswd->isLibraryPasswordVerified( aLibName ) )
 702                     {
 703                         bProtected = true;
 704                     }
 705                 }
 706
 707                 if ( !bProtected )
 708                 {
 709                     LibInfos::Item const* pLibInfoItem = 0;
 710                     if (ExtraData* pData = GetExtraData())
 711                         pLibInfoItem = pData->GetLibInfos().GetInfo(*doc, aLibName);
 712
 713                     // modules
 714                     if ( xModLibContainer.is() && xModLibContainer->hasByName( aLibName ) )
 715                     {
 716                         StarBASIC* pLib = doc->getBasicManager()->GetLib( aLibName );
 717                         if ( pLib )
 718                             ImplStartListening( pLib );
 719
 720                         try
 721                         {
 722                             Sequence< OUString > aModNames( doc->getObjectNames( E_SCRIPTS, aLibName ) );
 723                             sal_Int32 nModCount = aModNames.getLength();
 724                             const OUString* pModNames = aModNames.getConstArray();
 725
 726                             for ( sal_Int32 j = 0 ; j < nModCount ; j++ )
 727                             {
 728                                 OUString aModName = pModNames[ j ];
 729                                 ModulWindow* pWin = FindBasWin( *doc, aLibName, aModName, false );
 730                                 if ( !pWin )
 731                                     pWin = CreateBasWin( *doc, aLibName, aModName );
 732                                 if ( !pNextActiveWindow && pLibInfoItem && pLibInfoItem->GetCurrentName() == aModName &&
 733                                      pLibInfoItem->GetCurrentType() == TYPE_MODULE )
 734                                 {
 735                                     pNextActiveWindow = (BaseWindow*)pWin;
 736                                 }
 737                             }
 738                         }
 739                         catch (const container::NoSuchElementException& )
 740                         {
 741                             DBG_UNHANDLED_EXCEPTION();
 742                         }
 743                     }
 744
 745                     // dialogs
 746                     Reference< script::XLibraryContainer > xDlgLibContainer( doc->getLibraryContainer( E_DIALOGS ) );
 747                     if ( xDlgLibContainer.is() && xDlgLibContainer->hasByName( aLibName ) )
 748                     {
 749                         try
 750                         {
 751                             Sequence< OUString > aDlgNames = doc->getObjectNames( E_DIALOGS, aLibName );
 752                             sal_Int32 nDlgCount = aDlgNames.getLength();
 753                             const OUString* pDlgNames = aDlgNames.getConstArray();
 754
 755                             for ( sal_Int32 j = 0 ; j < nDlgCount ; j++ )
 756                             {
 757                                 OUString aDlgName = pDlgNames[ j ];
 758                                 // this find only looks for non-suspended windows;
 759                                 // suspended windows are handled in CreateDlgWin
 760                                 DialogWindow* pWin = FindDlgWin( *doc, aLibName, aDlgName, false );
 761                                 if ( !pWin )
 762                                     pWin = CreateDlgWin( *doc, aLibName, aDlgName );
 763                                 if ( !pNextActiveWindow && pLibInfoItem && pLibInfoItem->GetCurrentName() == aDlgName &&
 764                                      pLibInfoItem->GetCurrentType() == TYPE_DIALOG )
 765                                 {
 766                                     pNextActiveWindow = (BaseWindow*)pWin;
 767                                 }
 768                             }
 769                         }
 770                         catch (const container::NoSuchElementException& )
 771                         {
 772                             DBG_UNHANDLED_EXCEPTION();
 773                         }
 774                     }
 775                 }
 776             }
 777         }
 778     }
 779
 780     if ( bChangeCurWindow )
 781     {
 782         if ( !pNextActiveWindow )
 783         {
 784             pNextActiveWindow = FindApplicationWindow();
 785         }
 786         SetCurWindow( pNextActiveWindow, true );
 787     }
 788 }
 789
 790 void Shell::RemoveWindow( BaseWindow* pWindow_, bool bDestroy, bool bAllowChangeCurWindow )
 791 {
 792     DBG_ASSERT( pWindow_, "Kann keinen NULL-Pointer loeschen!" );
 793     sal_uLong nKey = GetWindowId( pWindow_ );
 794     pTabBar->RemovePage( (sal_uInt16)nKey );
 795     aWindowTable.erase( nKey );
 796     if ( pWindow_ == pCurWin )
 797     {
 798         if ( bAllowChangeCurWindow )
 799         {
 800             SetCurWindow( FindApplicationWindow(), true );
 801         }
 802         else
 803         {
 804             SetCurWindow( NULL, false );
 805         }
 806     }
 807     if ( bDestroy )
 808     {
 809         if ( !( pWindow_->GetStatus() & BASWIN_INRESCHEDULE ) )
 810         {
 811             delete pWindow_;
 812         }
 813         else
 814         {
 815             pWindow_->AddStatus( BASWIN_TOBEKILLED );
 816             pWindow_->Hide();
 817             // In normal mode stop basic in windows to be deleted
 818             // In VBA stop basic only if the running script is trying to delete
 819             // its parent module
 820             bool bStop = true;
 821             if ( pWindow_->GetDocument().isInVBAMode() )
 822             {
 823                 SbModule* pMod = StarBASIC::GetActiveModule();
 824                 if ( !pMod || ( pMod && ( !pMod->GetName().equals(pWindow_->GetName()) ) ) )
 825                 {
 826                     bStop = false;
 827                 }
 828             }
 829             if ( bStop )
 830             {
 831                 StarBASIC::Stop();
 832                 // there will be no notify...
 833                 pWindow_->BasicStopped();
 834             }
 835             aWindowTable[ nKey ] = pWindow_;   // jump in again
 836         }
 837     }
 838     else
 839     {
 840         pWindow_->AddStatus( BASWIN_SUSPENDED );
 841         pWindow_->Deactivating();
 842         aWindowTable[ nKey ] = pWindow_;   // jump in again
 843     }
 844
 845 }
 846
 847
 848
 849 sal_uInt16 Shell::InsertWindowInTable( BaseWindow* pNewWin )
 850 {
 851     nCurKey++;
 852     aWindowTable[ nCurKey ] = pNewWin;
 853     return nCurKey;
 854 }
 855
 856
 857
 858 void Shell::InvalidateBasicIDESlots()
 859 {
 860     // only those that have an optic effect...
 861
 862     if (GetShell())
 863     {
 864         if (SfxBindings* pBindings = GetBindingsPtr())
 865         {
 866             pBindings->Invalidate( SID_UNDO );
 867             pBindings->Invalidate( SID_REDO );
 868             pBindings->Invalidate( SID_SAVEDOC );
 869             pBindings->Invalidate( SID_SIGNATURE );
 870             pBindings->Invalidate( SID_BASICIDE_CHOOSEMACRO );
 871             pBindings->Invalidate( SID_BASICIDE_MODULEDLG );
 872             pBindings->Invalidate( SID_BASICIDE_OBJCAT );
 873             pBindings->Invalidate( SID_BASICSTOP );
 874             pBindings->Invalidate( SID_BASICRUN );
 875             pBindings->Invalidate( SID_BASICCOMPILE );
 876             pBindings->Invalidate( SID_BASICLOAD );
 877             pBindings->Invalidate( SID_BASICSAVEAS );
 878             pBindings->Invalidate( SID_BASICIDE_MATCHGROUP );
 879             pBindings->Invalidate( SID_BASICSTEPINTO );
 880             pBindings->Invalidate( SID_BASICSTEPOVER );
 881             pBindings->Invalidate( SID_BASICSTEPOUT );
 882             pBindings->Invalidate( SID_BASICIDE_TOGGLEBRKPNT );
 883             pBindings->Invalidate( SID_BASICIDE_MANAGEBRKPNTS );
 884             pBindings->Invalidate( SID_BASICIDE_ADDWATCH );
 885             pBindings->Invalidate( SID_BASICIDE_REMOVEWATCH );
 886             pBindings->Invalidate( SID_CHOOSE_CONTROLS );
 887             pBindings->Invalidate( SID_PRINTDOC );
 888             pBindings->Invalidate( SID_PRINTDOCDIRECT );
 889             pBindings->Invalidate( SID_SETUPPRINTER );
 890             pBindings->Invalidate( SID_DIALOG_TESTMODE );
 891
 892             pBindings->Invalidate( SID_DOC_MODIFIED );
 893             pBindings->Invalidate( SID_BASICIDE_STAT_TITLE );
 894             pBindings->Invalidate( SID_BASICIDE_STAT_POS );
 895             pBindings->Invalidate( SID_ATTR_INSERT );
 896             pBindings->Invalidate( SID_ATTR_SIZE );
 897         }
 898     }
 899 }
 900
 901 void Shell::EnableScrollbars( bool bEnable )
 902 {
 903     aHScrollBar.Enable(bEnable);
 904     aVScrollBar.Enable(bEnable);
 905 }
 906
 907 void Shell::SetCurLib( const ScriptDocument& rDocument, OUString aLibName, bool bUpdateWindows, bool bCheck )
 908 {
 909     if ( !bCheck || ( rDocument != m_aCurDocument || aLibName != m_aCurLibName ) )
 910     {
 911         ContainerListenerImpl* pListener = static_cast< ContainerListenerImpl* >( m_xLibListener.get() );
 912
 913         m_aCurDocument = rDocument;
 914         m_aCurLibName = aLibName;
 915
 916         if ( pListener )
 917         {
 918             pListener->removeContainerListener( m_aCurDocument, m_aCurLibName );
 919             pListener->addContainerListener( m_aCurDocument, aLibName );
 920         }
 921
 922         if ( bUpdateWindows )
 923             UpdateWindows();
 924
 925         SetMDITitle();
 926
 927         SetCurLibForLocalization( rDocument, aLibName );
 928
 929         if (SfxBindings* pBindings = GetBindingsPtr())
 930         {
 931             pBindings->Invalidate( SID_BASICIDE_LIBSELECTOR );
 932             pBindings->Invalidate( SID_BASICIDE_CURRENT_LANG );
 933             pBindings->Invalidate( SID_BASICIDE_MANAGE_LANG );
 934         }
 935     }
 936 }
 937
 938 void Shell::SetCurLibForLocalization( const ScriptDocument& rDocument, OUString aLibName )
 939 {
 940     // Create LocalizationMgr
 941     Reference< resource::XStringResourceManager > xStringResourceManager;
 942     try
 943     {
 944         if( !aLibName.isEmpty() )
 945         {
 946             Reference< container::XNameContainer > xDialogLib( rDocument.getLibrary( E_DIALOGS, aLibName, true ) );
 947             xStringResourceManager = LocalizationMgr::getStringResourceFromDialogLibrary( xDialogLib );
 948         }
 949     }
 950     catch (const container::NoSuchElementException& )
 951     {}
 952
 953     m_pCurLocalizationMgr = boost::shared_ptr<LocalizationMgr>(new LocalizationMgr(this, rDocument, aLibName, xStringResourceManager));
 954     m_pCurLocalizationMgr->handleTranslationbar();
 955 }
 956
 957 void Shell::ImplStartListening( StarBASIC* pBasic )
 958 {
 959     StartListening( pBasic->GetBroadcaster(), true /* log on only once */ );
 960 }
 961
 962 } // namespace basctl
 963
 964 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */