1 /**************************************************************
2  *
3  * Licensed to the Apache Software Foundation (ASF) under one
4  * or more contributor license agreements.  See the NOTICE file
5  * distributed with this work for additional information
6  * regarding copyright ownership.  The ASF licenses this file
7  * to you under the Apache License, Version 2.0 (the
8  * "License"); you may not use this file except in compliance
9  * with the License.  You may obtain a copy of the License at
10  *
11  *   http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing,
14  * software distributed under the License is distributed on an
15  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16  * KIND, either express or implied.  See the License for the
17  * specific language governing permissions and limitations
18  * under the License.
19  *
20  *************************************************************/
21 
22 
23 
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_basctl.hxx"
26 
27 // CLOOKS:
28 //#define _MENUBTN_HXX
29 #define _SPIN_HXX
30 #define _PRVWIN_HXX
31 //#define _FIELD_HXX ***
32 //#define _TAB_HXX ***
33 #define _DIALOGS_HXX
34 #define _SVRTF_HXX
35 #define _ISETBRW_HXX
36 #define _VCTRLS_HXX
37 #define SI_NOCONTROL
38 #define SI_NOSBXCONTROLS
39 
40 #define ITEMID_SIZE	0
41 
42 // Falls ohne PCH's:
43 #include <ide_pch.hxx>
44 
45 
46 #define _SOLAR__PRIVATE 1
47 #include <basic/sbx.hxx>
48 #include <svl/hint.hxx>
49 #include <tools/diagnose_ex.h>
50 #include <basidesh.hrc>
51 #include <basidesh.hxx>
52 #include <basdoc.hxx>
53 #include <basobj.hxx>
54 #include <bastypes.hxx>
55 #include <basicbox.hxx>
56 #include <objdlg.hxx>
57 #include <sbxitem.hxx>
58 #include <tbxctl.hxx>
59 #include <iderdll2.hxx>
60 #include <basidectrlr.hxx>
61 #include <localizationmgr.hxx>
62 
63 #define BasicIDEShell
64 #define SFX_TYPEMAP
65 #include <idetemp.hxx>
66 #include <basslots.hxx>
67 #include <iderdll.hxx>
68 #include <svx/pszctrl.hxx>
69 #include <svx/insctrl.hxx>
70 #include <svx/srchdlg.hxx>
71 #include <svx/lboxctrl.hxx>
72 #include <svx/tbcontrl.hxx>
73 #include <com/sun/star/script/XLibraryContainer.hpp>
74 #include <com/sun/star/script/XLibraryContainerPassword.hpp>
75 #include <com/sun/star/container/XNameContainer.hpp>
76 #include <com/sun/star/container/XContainer.hpp>
77 #include <com/sun/star/container/XContainerListener.hpp>
78 #include <com/sun/star/script/XLibraryContainer.hpp>
79 
80 #include <svx/xmlsecctrl.hxx>
81 
82 using namespace ::com::sun::star::uno;
83 using namespace ::com::sun::star;
84 using ::rtl::OUString;
85 
86 static const rtl::OUString sStandardLibName(  rtl::OUString::createFromAscii("Standard") );
87 
88 typedef ::cppu::WeakImplHelper1< container::XContainerListener > ContainerListenerBASE;
89 
90 class ContainerListenerImpl : public ContainerListenerBASE
91 {
92     BasicIDEShell* mpShell;
93 public:
94 
95     ContainerListenerImpl( BasicIDEShell* pShell ) : mpShell( pShell ) {}
96 
97     ~ContainerListenerImpl()
98     {
99     }
100 
101     void addContainerListener( const ScriptDocument& rScriptDocument, const String& aLibName )
102     {
103         try
104         {
105             uno::Reference< container::XContainer > xContainer( rScriptDocument.getLibrary( E_SCRIPTS, aLibName, sal_False ), uno::UNO_QUERY );
106             if ( xContainer.is() )
107             {
108                 uno::Reference< container::XContainerListener > xContainerListener( this );
109                 xContainer->addContainerListener( xContainerListener );
110             }
111         }
112         catch( uno::Exception& ) {}
113     }
114     void removeContainerListener( const ScriptDocument& rScriptDocument, const String& aLibName )
115     {
116         try
117         {
118             uno::Reference< container::XContainer > xContainer( rScriptDocument.getLibrary( E_SCRIPTS, aLibName, sal_False ), uno::UNO_QUERY );
119             if ( xContainer.is() )
120             {
121                 uno::Reference< container::XContainerListener > xContainerListener( this );
122                 xContainer->removeContainerListener( xContainerListener );
123             }
124         }
125         catch( uno::Exception& ) {}
126     }
127 
128     // XEventListener
129     virtual void SAL_CALL disposing( const lang::EventObject& ) throw( uno::RuntimeException ) {}
130 
131     // XContainerListener
132     virtual void SAL_CALL elementInserted( const container::ContainerEvent& Event ) throw( uno::RuntimeException )
133     {
134         rtl::OUString sModuleName;
135         if( mpShell && ( Event.Accessor >>= sModuleName ) )
136             mpShell->FindBasWin( mpShell->m_aCurDocument, mpShell->m_aCurLibName, sModuleName, sal_True, sal_False );
137     }
138     virtual void SAL_CALL elementReplaced( const container::ContainerEvent& ) throw( com::sun::star::uno::RuntimeException ) { }
139     virtual void SAL_CALL elementRemoved( const container::ContainerEvent& Event ) throw( com::sun::star::uno::RuntimeException )
140     {
141         rtl::OUString sModuleName;
142         if( mpShell  && ( Event.Accessor >>= sModuleName ) )
143         {
144             IDEBaseWindow* pWin = mpShell->FindWindow( mpShell->m_aCurDocument, mpShell->m_aCurLibName, sModuleName, BASICIDE_TYPE_MODULE, sal_True );
145             if( pWin )
146                 mpShell->RemoveWindow( pWin, sal_True, sal_True );
147         }
148     }
149 
150 };
151 
152 TYPEINIT1( BasicIDEShell, SfxViewShell );
153 
154 SFX_IMPL_NAMED_VIEWFACTORY( BasicIDEShell, "Default" )
155 {
156 	SFX_VIEW_REGISTRATION( BasicDocShell );
157 }
158 
159 
160 SFX_IMPL_INTERFACE( BasicIDEShell, SfxViewShell, IDEResId( RID_STR_IDENAME ) )
161 {
162 	SFX_CHILDWINDOW_REGISTRATION( SID_SEARCH_DLG );
163     SFX_FEATURED_CHILDWINDOW_REGISTRATION(SID_SHOW_PROPERTYBROWSER, BASICIDE_UI_FEATURE_SHOW_BROWSER);
164     SFX_POPUPMENU_REGISTRATION( IDEResId( RID_POPUP_DLGED ) );
165 }
166 
167 
168 
169 #define IDE_VIEWSHELL_FLAGS		SFX_VIEW_CAN_PRINT|SFX_VIEW_NO_NEWWINDOW
170 
171 
172 // Hack for #101048
173 static sal_Int32 GnBasicIDEShellCount;
174 sal_Int32 getBasicIDEShellCount( void )
175     { return GnBasicIDEShellCount; }
176 
177 BasicIDEShell::BasicIDEShell( SfxViewFrame* pFrame_, SfxViewShell* /* pOldShell */ ) :
178 		SfxViewShell( pFrame_, IDE_VIEWSHELL_FLAGS ),
179         m_aCurDocument( ScriptDocument::getApplicationScriptDocument() ),
180 		aHScrollBar( &GetViewFrame()->GetWindow(), WinBits( WB_HSCROLL | WB_DRAG ) ),
181 		aVScrollBar( &GetViewFrame()->GetWindow(), WinBits( WB_VSCROLL | WB_DRAG ) ),
182 		aScrollBarBox( &GetViewFrame()->GetWindow(), WinBits( WB_SIZEABLE ) ),
183         m_bAppBasicModified( sal_False ),
184         m_aNotifier( *this )
185 {
186     m_xLibListener = new ContainerListenerImpl( this );
187 	Init();
188     GnBasicIDEShellCount++;
189 }
190 
191 
192 
193 void BasicIDEShell::Init()
194 {
195 	TbxControls::RegisterControl( SID_CHOOSE_CONTROLS );
196 	SvxPosSizeStatusBarControl::RegisterControl();
197 	SvxInsertStatusBarControl::RegisterControl();
198 	XmlSecStatusBarControl::RegisterControl( SID_SIGNATURE );
199     SvxSimpleUndoRedoController::RegisterControl( SID_UNDO );
200     SvxSimpleUndoRedoController::RegisterControl( SID_REDO );
201 
202 	SvxSearchDialogWrapper::RegisterChildWindow( sal_False );
203 
204 	IDE_DLL()->GetExtraData()->ShellInCriticalSection() = sal_True;
205 
206 	SetName( String( RTL_CONSTASCII_USTRINGPARAM( "BasicIDE" ) ) );
207 	SetHelpId( SVX_INTERFACE_BASIDE_VIEWSH );
208 
209 	LibBoxControl::RegisterControl( SID_BASICIDE_LIBSELECTOR );
210 	LanguageBoxControl::RegisterControl( SID_BASICIDE_CURRENT_LANG );
211 
212 	CreateModulWindowLayout();
213 
214     GetViewFrame()->GetWindow().SetBackground();
215 
216 	pCurWin = 0;
217     m_aCurDocument = ScriptDocument::getApplicationScriptDocument();
218 	pObjectCatalog = 0;
219 	bCreatingWindow = sal_False;
220 
221 	m_pCurLocalizationMgr = NULL;
222 
223 	pTabBar = new BasicIDETabBar( &GetViewFrame()->GetWindow() );
224 	pTabBar->SetSplitHdl( LINK( this, BasicIDEShell, TabBarSplitHdl ) );
225 	bTabBarSplitted = sal_False;
226 
227 	nCurKey = 100;
228 	InitScrollBars();
229 	InitTabBar();
230 
231     SetCurLib( ScriptDocument::getApplicationScriptDocument(), String::CreateFromAscii( "Standard" ), false, false );
232 
233     if ( IDE_DLL() && IDE_DLL()->pShell == NULL )
234         IDE_DLL()->pShell = this;
235 
236     IDE_DLL()->GetExtraData()->ShellInCriticalSection() = sal_False;
237 
238     // It's enough to create the controller ...
239     // It will be public by using magic :-)
240     new BasicIDEController( this );
241 
242     // Force updating the title ! Because it must be set to the controller
243     // it has to be called directly after creating those controller.
244     SetMDITitle ();
245 
246 	UpdateWindows();
247 }
248 
249 __EXPORT BasicIDEShell::~BasicIDEShell()
250 {
251     m_aNotifier.dispose();
252 
253     if ( IDE_DLL() && IDE_DLL()->pShell == this )
254         IDE_DLL()->pShell = NULL;
255 
256 	// Damit bei einem Basic-Fehler beim Speichern die Shell nicht sofort
257 	// wieder hoch kommt:
258 	IDE_DLL()->GetExtraData()->ShellInCriticalSection() = sal_True;
259 
260 	SetWindow( 0 );
261 	SetCurWindow( 0 );
262 
263 	// Alle Fenster zerstoeren:
264 	IDEBaseWindow* pWin = aIDEWindowTable.First();
265 	while ( pWin )
266 	{
267 		// Kein Store, passiert bereits, wenn die BasicManager zerstoert werden.
268 		delete pWin;
269 		pWin = aIDEWindowTable.Next();
270 	}
271 
272 	aIDEWindowTable.Clear();
273 	delete pTabBar;
274 	delete pObjectCatalog;
275 	DestroyModulWindowLayout();
276 
277         ContainerListenerImpl* pListener = static_cast< ContainerListenerImpl* >( m_xLibListener.get() );
278         // Destroy all ContainerListeners for Basic Container.
279         if ( pListener )
280             pListener->removeContainerListener( m_aCurDocument, m_aCurLibName );
281 
282 	// MI: Das gab einen GPF im SDT beim Schliessen da dann der ViewFrame die
283 	// ObjSh loslaesst. Es wusste auch keiner mehr wozu das gut war.
284 	// GetViewFrame()->GetObjectShell()->Broadcast( SfxSimpleHint( SFX_HINT_DYING ) );
285 
286 	IDE_DLL()->GetExtraData()->ShellInCriticalSection() = sal_False;
287 
288     GnBasicIDEShellCount--;
289 }
290 
291 void BasicIDEShell::onDocumentCreated( const ScriptDocument& /*_rDocument*/ )
292 {
293     UpdateWindows();
294 }
295 
296 void BasicIDEShell::onDocumentOpened( const ScriptDocument& /*_rDocument*/ )
297 {
298     UpdateWindows();
299 }
300 
301 void BasicIDEShell::onDocumentSave( const ScriptDocument& /*_rDocument*/ )
302 {
303     StoreAllWindowData();
304 }
305 
306 void BasicIDEShell::onDocumentSaveDone( const ScriptDocument& /*_rDocument*/ )
307 {
308     // #i115671: Update SID_SAVEDOC after saving is completed
309     SfxBindings* pBindings = BasicIDE::GetBindingsPtr();
310     if ( pBindings )
311         pBindings->Invalidate( SID_SAVEDOC );
312 }
313 
314 void BasicIDEShell::onDocumentSaveAs( const ScriptDocument& /*_rDocument*/ )
315 {
316     StoreAllWindowData();
317 }
318 
319 void BasicIDEShell::onDocumentSaveAsDone( const ScriptDocument& /*_rDocument*/ )
320 {
321     // not interested in
322 }
323 
324 void BasicIDEShell::onDocumentClosed( const ScriptDocument& _rDocument )
325 {
326     if ( !_rDocument.isValid() )
327         return;
328 
329     bool bSetCurWindow = false;
330     bool bSetCurLib = ( _rDocument == m_aCurDocument );
331 
332     // remove all windows which belong to this document
333     for ( sal_uLong nWin = aIDEWindowTable.Count(); nWin; )
334     {
335         IDEBaseWindow* pWin = aIDEWindowTable.GetObject( --nWin );
336         if ( pWin->IsDocument( _rDocument ) )
337         {
338             if ( pWin->GetStatus() & (BASWIN_RUNNINGBASIC|BASWIN_INRESCHEDULE) )
339             {
340                 pWin->AddStatus( BASWIN_TOBEKILLED );
341                 pWin->Hide();
342                 StarBASIC::Stop();
343                 // there's no notify
344                 pWin->BasicStopped();
345             }
346             else
347             {
348                 pWin->StoreData();
349                 if ( pWin == pCurWin )
350                     bSetCurWindow = true;
351                 RemoveWindow( pWin, sal_True, sal_False );
352             }
353         }
354     }
355 
356     // remove lib info
357     BasicIDEData* pData = IDE_DLL()->GetExtraData();
358     if ( pData )
359         pData->GetLibInfos().RemoveInfoFor( _rDocument );
360 
361     if ( bSetCurLib )
362         SetCurLib( ScriptDocument::getApplicationScriptDocument(), String::CreateFromAscii( "Standard" ), true, false );
363     else if ( bSetCurWindow )
364         SetCurWindow( FindApplicationWindow(), sal_True );
365 }
366 
367 void BasicIDEShell::onDocumentTitleChanged( const ScriptDocument& /*_rDocument*/ )
368 {
369     SfxBindings* pBindings = BasicIDE::GetBindingsPtr();
370     if ( pBindings )
371         pBindings->Invalidate( SID_BASICIDE_LIBSELECTOR, sal_True, sal_False );
372     SetMDITitle();
373 }
374 
375 void BasicIDEShell::onDocumentModeChanged( const ScriptDocument& _rDocument )
376 {
377     for ( sal_uLong nWin = aIDEWindowTable.Count(); nWin; )
378     {
379         IDEBaseWindow* pWin = aIDEWindowTable.GetObject( --nWin );
380         if ( pWin->IsDocument( _rDocument ) && _rDocument.isDocument() )
381             pWin->SetReadOnly( _rDocument.isReadOnly() );
382     }
383 }
384 
385 void BasicIDEShell::StoreAllWindowData( sal_Bool bPersistent )
386 {
387 	for ( sal_uLong nWin = 0; nWin < aIDEWindowTable.Count(); nWin++ )
388 	{
389 		IDEBaseWindow* pWin = aIDEWindowTable.GetObject( nWin );
390 		DBG_ASSERT( pWin, "PrepareClose: NULL-Pointer in Table?" );
391 		if ( !pWin->IsSuspended() )
392 			pWin->StoreData();
393 	}
394 
395 	if ( bPersistent  )
396 	{
397 		SFX_APP()->SaveBasicAndDialogContainer();
398         SetAppBasicModified( sal_False );
399 
400         SfxBindings* pBindings = BasicIDE::GetBindingsPtr();
401         if ( pBindings )
402         {
403             pBindings->Invalidate( SID_SAVEDOC );
404             pBindings->Update( SID_SAVEDOC );
405         }
406 	}
407 }
408 
409 
410 sal_uInt16 __EXPORT BasicIDEShell::PrepareClose( sal_Bool bUI, sal_Bool bForBrowsing )
411 {
412 	(void)bForBrowsing;
413 
414 	// da es nach Drucken etc. (DocInfo) modifiziert ist, hier resetten
415 	GetViewFrame()->GetObjectShell()->SetModified(sal_False);
416 
417 	if ( StarBASIC::IsRunning() )
418 	{
419         if( bUI )
420         {
421 		    String aErrorStr( IDEResId( RID_STR_CANNOTCLOSE ) );
422 		    Window *pParent = &GetViewFrame()->GetWindow();
423 		    InfoBox( pParent, aErrorStr ).Execute();
424         }
425 		return sal_False;
426 	}
427 	else
428 	{
429 		// Hier unguenstig, wird zweimal gerufen...
430 //		StoreAllWindowData();
431 
432 		sal_Bool bCanClose = sal_True;
433 		for ( sal_uLong nWin = 0; bCanClose && ( nWin < aIDEWindowTable.Count() ); nWin++ )
434 		{
435 			IDEBaseWindow* pWin = aIDEWindowTable.GetObject( nWin );
436 			if ( /* !pWin->IsSuspended() && */ !pWin->CanClose() )
437 			{
438                 if ( m_aCurLibName.Len() && ( pWin->IsDocument( m_aCurDocument ) || pWin->GetLibName() != m_aCurLibName ) )
439                     SetCurLib( ScriptDocument::getApplicationScriptDocument(), String(), false );
440 				SetCurWindow( pWin, sal_True );
441 				bCanClose = sal_False;
442 			}
443 		}
444 
445 		if ( bCanClose )
446 			StoreAllWindowData( sal_False );	// Nicht auf Platte schreiben, das passiert am Ende automatisch
447 
448 		return bCanClose;
449 	}
450 }
451 
452 void BasicIDEShell::InitScrollBars()
453 {
454 	aVScrollBar.SetLineSize( 300 );
455 	aVScrollBar.SetPageSize( 2000 );
456 	aHScrollBar.SetLineSize( 300 );
457 	aHScrollBar.SetPageSize( 2000 );
458 	aHScrollBar.Enable();
459 	aVScrollBar.Enable();
460 	aVScrollBar.Show();
461 	aHScrollBar.Show();
462 	aScrollBarBox.Show();
463 }
464 
465 
466 
467 void BasicIDEShell::InitTabBar()
468 {
469 	pTabBar->Enable();
470 	pTabBar->Show();
471 	pTabBar->SetSelectHdl( LINK( this, BasicIDEShell, TabBarHdl ) );
472 }
473 
474 
475 Size __EXPORT BasicIDEShell::GetOptimalSizePixel() const
476 {
477 	return Size( 400, 300 );
478 }
479 
480 
481 
482 void __EXPORT BasicIDEShell::OuterResizePixel( const Point &rPos, const Size &rSize )
483 {
484 	// Adjust fliegt irgendwann raus...
485 	AdjustPosSizePixel( rPos, rSize );
486 }
487 
488 
489 IMPL_LINK_INLINE_START( BasicIDEShell, TabBarSplitHdl, TabBar *, pTBar )
490 {
491 	(void)pTBar;
492 	bTabBarSplitted = sal_True;
493 	ArrangeTabBar();
494 
495 	return 0;
496 }
497 IMPL_LINK_INLINE_END( BasicIDEShell, TabBarSplitHdl, TabBar *, pTBar )
498 
499 
500 
501 IMPL_LINK( BasicIDEShell, TabBarHdl, TabBar *, pCurTabBar )
502 {
503 	sal_uInt16 nCurId = pCurTabBar->GetCurPageId();
504 	IDEBaseWindow* pWin = aIDEWindowTable.Get( nCurId );
505 	DBG_ASSERT( pWin, "Eintrag in TabBar passt zu keinem Fenster!" );
506 	SetCurWindow( pWin );
507 
508 	return 0;
509 }
510 
511 
512 
513 sal_Bool BasicIDEShell::NextPage( sal_Bool bPrev )
514 {
515 	sal_Bool bRet = sal_False;
516 	sal_uInt16 nPos = pTabBar->GetPagePos( pTabBar->GetCurPageId() );
517 
518 	if ( bPrev )
519 		--nPos;
520 	else
521 		++nPos;
522 
523 	if ( nPos < pTabBar->GetPageCount() )
524 	{
525 		IDEBaseWindow* pWin = aIDEWindowTable.Get( pTabBar->GetPageId( nPos ) );
526 		SetCurWindow( pWin, sal_True );
527 		bRet = sal_True;
528 	}
529 
530 	return bRet;
531 }
532 
533 
534 
535 void BasicIDEShell::ArrangeTabBar()
536 {
537 	Size aSz( GetViewFrame()->GetWindow().GetOutputSizePixel() );
538 	long nBoxPos = aScrollBarBox.GetPosPixel().X() - 1;
539 	long nPos = pTabBar->GetSplitSize();
540 	if ( nPos <= nBoxPos )
541 	{
542 		Point aPnt( pTabBar->GetPosPixel() );
543 		long nH = aHScrollBar.GetSizePixel().Height();
544 		pTabBar->SetPosSizePixel( aPnt, Size( nPos, nH ) );
545 		long nScrlStart = aPnt.X() + nPos;
546 		aHScrollBar.SetPosSizePixel( Point( nScrlStart, aPnt.Y() ), Size( nBoxPos - nScrlStart + 2, nH ) );
547 		aHScrollBar.Update();
548 	}
549 }
550 
551 
552 
553 ::svl::IUndoManager* BasicIDEShell::GetUndoManager()
554 {
555 	::svl::IUndoManager* pMgr = NULL;
556 	if( pCurWin )
557 		pMgr = pCurWin->GetUndoManager();
558 
559 	return pMgr;
560 }
561 
562 
563 
564 void BasicIDEShell::ShowObjectDialog( sal_Bool bShow, sal_Bool bCreateOrDestroy )
565 {
566 	if ( bShow )
567 	{
568 		if ( !pObjectCatalog && bCreateOrDestroy )
569 		{
570 			pObjectCatalog = new ObjectCatalog( &GetViewFrame()->GetWindow() );
571 			// Position wird in BasicIDEData gemerkt und vom Dlg eingestellt
572             if ( pObjectCatalog )
573             {
574                 pObjectCatalog->SetCancelHdl( LINK( this, BasicIDEShell, ObjectDialogCancelHdl ) );
575                 BasicEntryDescriptor aDesc;
576                 IDEBaseWindow* pCurWin_ = GetCurWindow();
577                 if ( pCurWin_ )
578                     aDesc = pCurWin_->CreateEntryDescriptor();
579                 pObjectCatalog->SetCurrentEntry( aDesc );
580             }
581 		}
582 
583 		// Die allerletzten Aenderungen...
584 		if ( pCurWin )
585 			pCurWin->StoreData();
586 
587 		if ( pObjectCatalog )
588 		{
589 			pObjectCatalog->UpdateEntries();
590 			pObjectCatalog->Show();
591 		}
592 	}
593 	else if ( pObjectCatalog )
594 	{
595 		pObjectCatalog->Hide();
596 		if ( bCreateOrDestroy )
597 		{
598 			// Wegen OS/2-Focus-Problem pObjectCatalog vorm delete auf NULL
599 			ObjectCatalog* pTemp = pObjectCatalog;
600 			pObjectCatalog = 0;
601 			delete pTemp;
602 		}
603 	}
604 }
605 
606 
607 
608 void __EXPORT BasicIDEShell::SFX_NOTIFY( SfxBroadcaster& rBC, const TypeId&,
609 										const SfxHint& rHint, const TypeId& )
610 {
611     if ( IDE_DLL()->GetShell() )
612     {
613         if ( rHint.IsA( TYPE( SfxSimpleHint ) ) )
614         {
615             switch ( ((SfxSimpleHint&)rHint).GetId() )
616             {
617                 case SFX_HINT_DYING:
618                 {
619                     EndListening( rBC, sal_True /* Alle abmelden */ );
620                     if ( pObjectCatalog )
621                         pObjectCatalog->UpdateEntries();
622                 }
623                 break;
624             }
625 
626             if ( rHint.IsA( TYPE( SbxHint ) ) )
627             {
628                 SbxHint& rSbxHint = (SbxHint&)rHint;
629                 sal_uLong nHintId = rSbxHint.GetId();
630                 if (	( nHintId == SBX_HINT_BASICSTART ) ||
631                         ( nHintId == SBX_HINT_BASICSTOP ) )
632                 {
633                     SfxBindings* pBindings = BasicIDE::GetBindingsPtr();
634                     if ( pBindings )
635                     {
636                         pBindings->Invalidate( SID_BASICRUN );
637                         pBindings->Update( SID_BASICRUN );
638                         pBindings->Invalidate( SID_BASICCOMPILE );
639                         pBindings->Update( SID_BASICCOMPILE );
640                         pBindings->Invalidate( SID_BASICSTEPOVER );
641                         pBindings->Update( SID_BASICSTEPOVER );
642                         pBindings->Invalidate( SID_BASICSTEPINTO );
643                         pBindings->Update( SID_BASICSTEPINTO );
644                         pBindings->Invalidate( SID_BASICSTEPOUT );
645                         pBindings->Update( SID_BASICSTEPOUT );
646                         pBindings->Invalidate( SID_BASICSTOP );
647                         pBindings->Update( SID_BASICSTOP );
648                         pBindings->Invalidate( SID_BASICIDE_TOGGLEBRKPNT );
649                         pBindings->Update( SID_BASICIDE_TOGGLEBRKPNT );
650                         pBindings->Invalidate( SID_BASICIDE_MANAGEBRKPNTS );
651                         pBindings->Update( SID_BASICIDE_MANAGEBRKPNTS );
652                         pBindings->Invalidate( SID_BASICIDE_MODULEDLG );
653                         pBindings->Update( SID_BASICIDE_MODULEDLG );
654                         pBindings->Invalidate( SID_BASICLOAD );
655                         pBindings->Update( SID_BASICLOAD );
656                     }
657 
658                     if ( nHintId == SBX_HINT_BASICSTOP )
659                     {
660                         // Nicht nur bei Error/Break oder explizitem anhalten,
661                         // falls durch einen Programmierfehler das Update abgeschaltet ist.
662                         BasicIDE::BasicStopped();
663                         UpdateModulWindowLayout( true );    // Leer machen...
664 						if( m_pCurLocalizationMgr )
665 							m_pCurLocalizationMgr->handleBasicStopped();
666                     }
667 					else if( m_pCurLocalizationMgr )
668                     {
669 						m_pCurLocalizationMgr->handleBasicStarted();
670                     }
671 
672                     IDEBaseWindow* pWin = aIDEWindowTable.First();
673                     while ( pWin )
674                     {
675                         if ( nHintId == SBX_HINT_BASICSTART )
676                             pWin->BasicStarted();
677                         else
678                             pWin->BasicStopped();
679                         pWin = aIDEWindowTable.Next();
680                     }
681                 }
682             }
683         }
684     }
685 }
686 
687 
688 
689 void BasicIDEShell::CheckWindows()
690 {
691 	sal_Bool bSetCurWindow = sal_False;
692 	for ( sal_uLong nWin = 0; nWin < aIDEWindowTable.Count(); nWin++ )
693 	{
694 		IDEBaseWindow* pWin = aIDEWindowTable.GetObject( nWin );
695 		if ( pWin->GetStatus() & BASWIN_TOBEKILLED )
696 		{
697 			pWin->StoreData();
698 			if ( pWin == pCurWin )
699 				bSetCurWindow = sal_True;
700 			RemoveWindow( pWin, sal_True, sal_False );
701 			nWin--;
702 		}
703 	}
704 	if ( bSetCurWindow )
705 		SetCurWindow( FindApplicationWindow(), sal_True );
706 }
707 
708 
709 
710 void BasicIDEShell::RemoveWindows( const ScriptDocument& rDocument, const String& rLibName, sal_Bool bDestroy )
711 {
712 	sal_Bool bChangeCurWindow = pCurWin ? sal_False : sal_True;
713 	for ( sal_uLong nWin = 0; nWin < aIDEWindowTable.Count(); nWin++ )
714 	{
715 		IDEBaseWindow* pWin = aIDEWindowTable.GetObject( nWin );
716         if ( pWin->IsDocument( rDocument ) && pWin->GetLibName() == rLibName )
717 		{
718 			if ( pWin == pCurWin )
719 				bChangeCurWindow = sal_True;
720 			pWin->StoreData();
721 			RemoveWindow( pWin, bDestroy, sal_False );
722 			nWin--;
723 		}
724 	}
725 	if ( bChangeCurWindow )
726 		SetCurWindow( FindApplicationWindow(), sal_True );
727 }
728 
729 
730 
731 void BasicIDEShell::UpdateWindows()
732 {
733 	// Alle Fenster, die nicht angezeigt werden duerfen, entfernen
734 	sal_Bool bChangeCurWindow = pCurWin ? sal_False : sal_True;
735     if ( m_aCurLibName.Len() )
736 	{
737 		for ( sal_uLong nWin = 0; nWin < aIDEWindowTable.Count(); nWin++ )
738 		{
739 			IDEBaseWindow* pWin = aIDEWindowTable.GetObject( nWin );
740             if ( !pWin->IsDocument( m_aCurDocument ) || pWin->GetLibName() != m_aCurLibName )
741 			{
742 				if ( pWin == pCurWin )
743 					bChangeCurWindow = sal_True;
744 				pWin->StoreData();
745 				// Die Abfrage auf RUNNING verhindert den Absturz, wenn in Reschedule.
746 				// Fenster bleibt erstmal stehen, spaeter sowieso mal umstellen,
747 				// dass Fenster nur als Hidden markiert werden und nicht
748 				// geloescht.
749 				if ( !(pWin->GetStatus() & ( BASWIN_TOBEKILLED | BASWIN_RUNNINGBASIC | BASWIN_SUSPENDED ) ) )
750 				{
751 					RemoveWindow( pWin, sal_False, sal_False );
752 					nWin--;
753 				}
754 			}
755 		}
756 	}
757 
758 	if ( bCreatingWindow )
759 		return;
760 
761     IDEBaseWindow* pNextActiveWindow = 0;
762 
763 	// Alle anzuzeigenden Fenster anzeigen
764     ScriptDocuments aDocuments( ScriptDocument::getAllScriptDocuments( ScriptDocument::AllWithApplication ) );
765     for (   ScriptDocuments::const_iterator doc = aDocuments.begin();
766             doc != aDocuments.end();
767             ++doc
768         )
769 	{
770 		StartListening( *doc->getBasicManager(), sal_True /* Nur einmal anmelden */ );
771 
772         // libraries
773         Sequence< ::rtl::OUString > aLibNames( doc->getLibraryNames() );
774         sal_Int32 nLibCount = aLibNames.getLength();
775 	    const ::rtl::OUString* pLibNames = aLibNames.getConstArray();
776 
777         for ( sal_Int32 i = 0 ; i < nLibCount ; i++ )
778 	    {
779             String aLibName = pLibNames[ i ];
780 
781             if ( !m_aCurLibName.Len() || ( *doc == m_aCurDocument && aLibName == m_aCurLibName ) )
782             {
783                 // check, if library is password protected and not verified
784                 sal_Bool bProtected = sal_False;
785                 Reference< script::XLibraryContainer > xModLibContainer( doc->getLibraryContainer( E_SCRIPTS ) );
786                 if ( xModLibContainer.is() && xModLibContainer->hasByName( aLibName ) )
787                 {
788                     Reference< script::XLibraryContainerPassword > xPasswd( xModLibContainer, UNO_QUERY );
789                     if ( xPasswd.is() && xPasswd->isLibraryPasswordProtected( aLibName ) && !xPasswd->isLibraryPasswordVerified( aLibName ) )
790                     {
791                         bProtected = sal_True;
792                     }
793                 }
794 
795                 if ( !bProtected )
796                 {
797                     LibInfoItem* pLibInfoItem = 0;
798                     BasicIDEData* pData = IDE_DLL()->GetExtraData();
799                     if ( pData )
800                         pLibInfoItem = pData->GetLibInfos().GetInfo( LibInfoKey( *doc, aLibName ) );
801 
802                     // modules
803                     if ( xModLibContainer.is() && xModLibContainer->hasByName( aLibName ) )
804                     {
805                         StarBASIC* pLib = doc->getBasicManager()->GetLib( aLibName );
806                         if ( pLib )
807                             ImplStartListening( pLib );
808 
809                         try
810 					    {
811                             Sequence< ::rtl::OUString > aModNames( doc->getObjectNames( E_SCRIPTS, aLibName ) );
812                             sal_Int32 nModCount = aModNames.getLength();
813 	                        const ::rtl::OUString* pModNames = aModNames.getConstArray();
814 
815                             for ( sal_Int32 j = 0 ; j < nModCount ; j++ )
816 				            {
817 					            String aModName = pModNames[ j ];
818 						        ModulWindow* pWin = FindBasWin( *doc, aLibName, aModName, sal_False );
819                                 if ( !pWin )
820 							        pWin = CreateBasWin( *doc, aLibName, aModName );
821                                 if ( !pNextActiveWindow && pLibInfoItem && pLibInfoItem->GetCurrentName() == aModName &&
822                                         pLibInfoItem->GetCurrentType() == BASICIDE_TYPE_MODULE )
823                                 {
824                                     pNextActiveWindow = (IDEBaseWindow*)pWin;
825                                 }
826                             }
827                         }
828 					    catch ( container::NoSuchElementException& )
829 					    {
830                             DBG_UNHANDLED_EXCEPTION();
831 					    }
832                     }
833 
834                     // dialogs
835                     Reference< script::XLibraryContainer > xDlgLibContainer( doc->getLibraryContainer( E_DIALOGS ) );
836                     if ( xDlgLibContainer.is() && xDlgLibContainer->hasByName( aLibName ) )
837                     {
838                         try
839                         {
840                             Sequence< ::rtl::OUString > aDlgNames = doc->getObjectNames( E_DIALOGS, aLibName );
841                             sal_Int32 nDlgCount = aDlgNames.getLength();
842 	                        const ::rtl::OUString* pDlgNames = aDlgNames.getConstArray();
843 
844                             for ( sal_Int32 j = 0 ; j < nDlgCount ; j++ )
845 				            {
846 					            String aDlgName = pDlgNames[ j ];
847                                 // this find only looks for non-suspended windows;
848                                 // suspended windows are handled in CreateDlgWin
849                                 DialogWindow* pWin = FindDlgWin( *doc, aLibName, aDlgName, sal_False );
850                                 if ( !pWin )
851 								    pWin = CreateDlgWin( *doc, aLibName, aDlgName );
852                                 if ( !pNextActiveWindow && pLibInfoItem && pLibInfoItem->GetCurrentName() == aDlgName &&
853                                         pLibInfoItem->GetCurrentType() == BASICIDE_TYPE_DIALOG )
854                                 {
855                                     pNextActiveWindow = (IDEBaseWindow*)pWin;
856                                 }
857                             }
858                         }
859 					    catch ( container::NoSuchElementException& )
860 					    {
861 						    DBG_UNHANDLED_EXCEPTION();
862 					    }
863                     }
864 				}
865             }
866         }
867 	}
868 
869 	if ( bChangeCurWindow )
870     {
871         if ( !pNextActiveWindow )
872             pNextActiveWindow = FindApplicationWindow();
873         SetCurWindow( pNextActiveWindow, sal_True );
874     }
875 }
876 
877 void BasicIDEShell::RemoveWindow( IDEBaseWindow* pWindow_, sal_Bool bDestroy, sal_Bool bAllowChangeCurWindow )
878 {
879 	DBG_ASSERT( pWindow_, "Kann keinen NULL-Pointer loeschen!" );
880 	sal_uLong nKey = aIDEWindowTable.GetKey( pWindow_ );
881 	pTabBar->RemovePage( (sal_uInt16)nKey );
882 	aIDEWindowTable.Remove( nKey );
883 	if ( pWindow_ == pCurWin )
884 	{
885 		if ( bAllowChangeCurWindow )
886 			SetCurWindow( FindApplicationWindow(), sal_True );
887 		else
888 			SetCurWindow( NULL, sal_False );
889 	}
890 	if ( bDestroy )
891 	{
892 		if ( !( pWindow_->GetStatus() & BASWIN_INRESCHEDULE ) )
893 		{
894 			delete pWindow_;
895 		}
896 		else
897 		{
898 			pWindow_->AddStatus( BASWIN_TOBEKILLED );
899 			pWindow_->Hide();
900             // In normal mode stop basic in windows to be deleted
901             // In VBA stop basic only if the running script is trying to delete
902             // its parent module
903             bool bStop = true;
904             if ( pWindow_->GetDocument().isInVBAMode() )
905             {
906                 SbModule* pMod = StarBASIC::GetActiveModule();
907                 if ( !pMod || ( pMod && ( pMod->GetName() != pWindow_->GetName() ) ) )
908                     bStop = false;
909             }
910             if ( bStop )
911             {
912                 StarBASIC::Stop();
913                 // Es kommt kein Notify...
914                 pWindow_->BasicStopped();
915             }
916 			aIDEWindowTable.Insert( nKey, pWindow_ );	// wieder einhaegen
917 		}
918 	}
919 	else
920 	{
921 		pWindow_->Hide();
922 		pWindow_->AddStatus( BASWIN_SUSPENDED );
923 		pWindow_->Deactivating();
924 		aIDEWindowTable.Insert( nKey, pWindow_ );	// wieder einhaegen
925 	}
926 
927 }
928 
929 
930 
931 sal_uInt16 BasicIDEShell::InsertWindowInTable( IDEBaseWindow* pNewWin )
932 {
933 	// Eigentlich prueffen,
934 	nCurKey++;
935 	aIDEWindowTable.Insert( nCurKey, pNewWin );
936 	return nCurKey;
937 }
938 
939 
940 
941 void BasicIDEShell::InvalidateBasicIDESlots()
942 {
943 	// Nur die, die eine optische Auswirkung haben...
944 
945 	if ( IDE_DLL()->GetShell() )
946 	{
947         SfxBindings* pBindings = BasicIDE::GetBindingsPtr();
948         if ( pBindings )
949         {
950             pBindings->Invalidate( SID_UNDO );
951             pBindings->Invalidate( SID_REDO );
952             pBindings->Invalidate( SID_SAVEDOC );
953             pBindings->Invalidate( SID_SIGNATURE );
954             pBindings->Invalidate( SID_BASICIDE_CHOOSEMACRO );
955             pBindings->Invalidate( SID_BASICIDE_MODULEDLG );
956             pBindings->Invalidate( SID_BASICIDE_OBJCAT );
957             pBindings->Invalidate( SID_BASICSTOP );
958             pBindings->Invalidate( SID_BASICRUN );
959             pBindings->Invalidate( SID_BASICCOMPILE );
960             pBindings->Invalidate( SID_BASICLOAD );
961             pBindings->Invalidate( SID_BASICSAVEAS );
962             pBindings->Invalidate( SID_BASICIDE_MATCHGROUP );
963             pBindings->Invalidate( SID_BASICSTEPINTO );
964             pBindings->Invalidate( SID_BASICSTEPOVER );
965             pBindings->Invalidate( SID_BASICSTEPOUT );
966             pBindings->Invalidate( SID_BASICIDE_TOGGLEBRKPNT );
967             pBindings->Invalidate( SID_BASICIDE_MANAGEBRKPNTS );
968             pBindings->Invalidate( SID_BASICIDE_ADDWATCH );
969             pBindings->Invalidate( SID_BASICIDE_REMOVEWATCH );
970             pBindings->Invalidate( SID_CHOOSE_CONTROLS );
971             pBindings->Invalidate( SID_PRINTDOC );
972             pBindings->Invalidate( SID_PRINTDOCDIRECT );
973             pBindings->Invalidate( SID_SETUPPRINTER );
974             pBindings->Invalidate( SID_DIALOG_TESTMODE );
975 
976             pBindings->Invalidate( SID_DOC_MODIFIED );
977             pBindings->Invalidate( SID_BASICIDE_STAT_TITLE );
978             pBindings->Invalidate( SID_BASICIDE_STAT_POS );
979             pBindings->Invalidate( SID_ATTR_INSERT );
980             pBindings->Invalidate( SID_ATTR_SIZE );
981         }
982 	}
983 }
984 
985 void BasicIDEShell::EnableScrollbars( sal_Bool bEnable )
986 {
987 	if ( bEnable )
988 	{
989 		aHScrollBar.Enable();
990 		aVScrollBar.Enable();
991 	}
992 	else
993 	{
994 		aHScrollBar.Disable();
995 		aVScrollBar.Disable();
996 	}
997 }
998 
999 void BasicIDEShell::SetCurLib( const ScriptDocument& rDocument, String aLibName, bool bUpdateWindows, bool bCheck )
1000 {
1001     if ( !bCheck || ( rDocument != m_aCurDocument || aLibName != m_aCurLibName ) )
1002     {
1003         ContainerListenerImpl* pListener = static_cast< ContainerListenerImpl* >( m_xLibListener.get() );
1004 
1005         if ( pListener )
1006         	pListener->removeContainerListener( m_aCurDocument, m_aCurLibName );
1007 
1008         m_aCurDocument = rDocument;
1009 
1010         pListener->addContainerListener( m_aCurDocument, aLibName );
1011 
1012         m_aCurLibName = aLibName;
1013 
1014         if ( bUpdateWindows )
1015             UpdateWindows();
1016 
1017 		SetMDITitle();
1018 
1019 		SetCurLibForLocalization( rDocument, aLibName );
1020 
1021         SfxBindings* pBindings = BasicIDE::GetBindingsPtr();
1022         if ( pBindings )
1023 		{
1024             pBindings->Invalidate( SID_BASICIDE_LIBSELECTOR );
1025 			pBindings->Invalidate( SID_BASICIDE_CURRENT_LANG );
1026 			pBindings->Invalidate( SID_BASICIDE_MANAGE_LANG );
1027 		}
1028     }
1029 }
1030 
1031 void BasicIDEShell::SetCurLibForLocalization( const ScriptDocument& rDocument, String aLibName )
1032 {
1033     // Create LocalizationMgr
1034 	delete m_pCurLocalizationMgr;
1035 	Reference< resource::XStringResourceManager > xStringResourceManager;
1036 	try
1037 	{
1038 		if( aLibName.Len() )
1039 		{
1040 			Reference< container::XNameContainer > xDialogLib( rDocument.getLibrary( E_DIALOGS, aLibName, sal_True ) );
1041 			xStringResourceManager = LocalizationMgr::getStringResourceFromDialogLibrary( xDialogLib );
1042 	    }
1043 	}
1044     catch ( container::NoSuchElementException& )
1045 	{}
1046 	m_pCurLocalizationMgr = new LocalizationMgr
1047 		( this, rDocument, aLibName, xStringResourceManager );
1048 
1049 	m_pCurLocalizationMgr->handleTranslationbar();
1050 }
1051 
1052 void BasicIDEShell::ImplStartListening( StarBASIC* pBasic )
1053 {
1054 	StartListening( pBasic->GetBroadcaster(), sal_True /* Nur einmal anmelden */ );
1055 }
1056 
1057 
1058