| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_basctl.hxx" |
| |
| #include "docsignature.hxx" |
| |
| #define GLOBALOVERFLOW2 |
| #include <basic/sbx.hxx> |
| #define _SVSTDARR_STRINGS |
| #include <svl/svstdarr.hxx> |
| #include <ide_pch.hxx> |
| |
| #define _SOLAR__PRIVATE 1 |
| |
| // #define _SVX_NOIDERESIDS |
| |
| #define SI_NOCONTROL |
| #define SI_NOSBXCONTROLS |
| #define SI_NOITEMS |
| #define SI_NODRW |
| #define _VCTRLS_HXX |
| |
| #include <basidesh.hrc> |
| #include <basidesh.hxx> |
| #include <baside2.hxx> |
| #include <baside3.hxx> |
| #include <basobj.hxx> |
| #include <iderdll.hxx> |
| #include <iderdll2.hxx> |
| #include <sbxitem.hxx> |
| #include <managelang.hxx> |
| #include <localizationmgr.hxx> |
| #include <helpid.hrc> |
| |
| #include <svtools/texteng.hxx> |
| #include <svtools/textview.hxx> |
| #include <svtools/xtextedt.hxx> |
| #include <tools/urlobj.hxx> |
| #include <tools/diagnose_ex.h> |
| #include <sfx2/minfitem.hxx> |
| #include <sfx2/docfile.hxx> |
| #include <com/sun/star/task/XStatusIndicator.hpp> |
| #include <com/sun/star/task/XStatusIndicatorFactory.hpp> |
| #include <com/sun/star/script/XLibraryContainer.hpp> |
| #include <com/sun/star/script/XLibraryContainerPassword.hpp> |
| #include <com/sun/star/frame/XDispatchProvider.hpp> |
| #include <com/sun/star/frame/XLayoutManager.hpp> |
| |
| #include <algorithm> |
| #include <memory> |
| |
| |
| using namespace ::com::sun::star; |
| using namespace ::com::sun::star::uno; |
| using namespace ::com::sun::star::frame; |
| |
| class SvxSearchItem; |
| |
| // Egal was, einfach ans aktuelle Fenster: |
| void __EXPORT BasicIDEShell::ExecuteCurrent( SfxRequest& rReq ) |
| { |
| if ( !pCurWin ) |
| return; |
| |
| switch ( rReq.GetSlot() ) |
| { |
| case SID_BASICIDE_HIDECURPAGE: |
| { |
| pCurWin->StoreData(); |
| RemoveWindow( pCurWin, sal_False ); |
| } |
| break; |
| case SID_BASICIDE_DELETECURRENT: |
| { |
| ScriptDocument aDocument( pCurWin->GetDocument() ); |
| String aLibName = pCurWin->GetLibName(); |
| String aName = pCurWin->GetName(); |
| |
| if ( pCurWin->ISA( ModulWindow ) ) |
| { |
| // module |
| if ( QueryDelModule( aName, pCurWin ) ) |
| { |
| if ( aDocument.removeModule( aLibName, aName ) ) |
| { |
| BasicIDE::MarkDocumentModified( aDocument ); |
| } |
| } |
| } |
| else |
| { |
| // dialog |
| if ( QueryDelDialog( aName, pCurWin ) ) |
| { |
| if ( BasicIDE::RemoveDialog( aDocument, aLibName, aName ) ) |
| { |
| RemoveWindow( pCurWin, sal_True ); |
| BasicIDE::MarkDocumentModified( aDocument ); |
| } |
| } |
| } |
| } |
| break; |
| case SID_BASICIDE_RENAMECURRENT: |
| { |
| pTabBar->StartEditMode( pTabBar->GetCurPageId() ); |
| } |
| break; |
| case FID_SEARCH_NOW: |
| { |
| if ( pCurWin->ISA( ModulWindow ) ) |
| { |
| DBG_ASSERT( rReq.GetArgs(), "arguments expected" ); |
| const SfxItemSet* pArgs = rReq.GetArgs(); |
| // Leider kenne ich die ID nicht: |
| sal_uInt16 nWhich = pArgs->GetWhichByPos( 0 ); |
| DBG_ASSERT( nWhich, "Wich fuer SearchItem ?" ); |
| const SfxPoolItem& rItem = pArgs->Get( nWhich ); |
| DBG_ASSERT( rItem.ISA( SvxSearchItem ), "Kein Searchitem!" ); |
| if ( rItem.ISA( SvxSearchItem ) ) |
| { |
| // Item wegen der Einstellungen merken... |
| IDE_DLL()->GetExtraData()->SetSearchItem( (const SvxSearchItem&)rItem ); |
| sal_uInt16 nFound = 0; |
| sal_Bool bCanceled = sal_False; |
| if ( ((const SvxSearchItem&)rItem).GetCommand() == SVX_SEARCHCMD_REPLACE_ALL ) |
| { |
| sal_uInt16 nActModWindows = 0; |
| IDEBaseWindow* pWin = aIDEWindowTable.First(); |
| while ( pWin ) |
| { |
| if ( !pWin->IsSuspended() && pWin->IsA( TYPE( ModulWindow ) ) ) |
| nActModWindows++; |
| pWin = aIDEWindowTable.Next(); |
| } |
| |
| if ( ( nActModWindows <= 1 ) || ( !((const SvxSearchItem&)rItem).GetSelection() && QueryBox( pCurWin, WB_YES_NO|WB_DEF_YES, String( IDEResId( RID_STR_SEARCHALLMODULES ) ) ).Execute() == RET_YES ) ) |
| { |
| pWin = aIDEWindowTable.First(); |
| while ( pWin ) |
| { |
| if ( !pWin->IsSuspended() && pWin->IsA( TYPE( ModulWindow ) ) ) |
| nFound = nFound + ((ModulWindow*)pWin)->StartSearchAndReplace( (const SvxSearchItem&)rItem ); |
| pWin = aIDEWindowTable.Next(); |
| } |
| } |
| else |
| nFound = ((ModulWindow*)pCurWin)->StartSearchAndReplace( (const SvxSearchItem&)rItem ); |
| |
| IDEResId nId( RID_STR_SEARCHREPLACES ); |
| String aReplStr( nId ); |
| aReplStr.SearchAndReplace( String( RTL_CONSTASCII_USTRINGPARAM( "XX" ) ), String::CreateFromInt32( nFound ) ); |
| InfoBox( pCurWin, aReplStr ).Execute(); |
| } |
| else |
| { |
| nFound = ((ModulWindow*)pCurWin)->StartSearchAndReplace( (const SvxSearchItem&)rItem ); |
| if ( !nFound && !((const SvxSearchItem&)rItem).GetSelection() ) |
| { |
| // Andere Module durchsuchen... |
| sal_Bool bChangeCurWindow = sal_False; |
| aIDEWindowTable.Seek( pCurWin ); |
| // Erstmal beim naechsten Anfangen, ggf. spaeter von vorne |
| IDEBaseWindow* pWin = aIDEWindowTable.Next(); |
| sal_Bool bSearchedFromStart = sal_False; |
| while ( !nFound && !bCanceled && ( pWin || !bSearchedFromStart ) ) |
| { |
| if ( !pWin ) |
| { |
| SfxViewFrame* pViewFrame = GetViewFrame(); |
| SfxChildWindow* pChildWin = pViewFrame ? pViewFrame->GetChildWindow( SID_SEARCH_DLG ) : NULL; |
| Window* pParent = pChildWin ? pChildWin->GetWindow() : NULL; |
| QueryBox aQuery( pParent, WB_YES_NO|WB_DEF_YES, String( IDEResId( RID_STR_SEARCHFROMSTART ) ) ); |
| if ( aQuery.Execute() == RET_YES ) |
| { |
| pWin = aIDEWindowTable.First(); |
| bSearchedFromStart = sal_True; |
| } |
| else |
| bCanceled = sal_True; |
| } |
| |
| if ( pWin && !pWin->IsSuspended() && pWin->IsA( TYPE( ModulWindow ) ) ) |
| { |
| if ( pWin != pCurWin ) |
| { |
| // Groesse einstellen, damit die View |
| // gleich richtig justiert werden kann. |
| if ( pCurWin ) |
| pWin->SetSizePixel( pCurWin->GetSizePixel() ); |
| nFound = ((ModulWindow*)pWin)->StartSearchAndReplace( (const SvxSearchItem&)rItem, sal_True ); |
| } |
| if ( nFound ) |
| { |
| bChangeCurWindow = sal_True; |
| break; |
| } |
| } |
| if ( pWin && ( pWin != pCurWin ) ) |
| pWin = aIDEWindowTable.Next(); |
| else |
| pWin = 0; // Dann sind wir durch... |
| } |
| if ( !nFound && bSearchedFromStart ) // Aktuelles von vorne... |
| nFound = ((ModulWindow*)pCurWin)->StartSearchAndReplace( (const SvxSearchItem&)rItem, sal_True ); |
| if ( bChangeCurWindow ) |
| SetCurWindow( pWin, sal_True ); |
| } |
| if ( !nFound && !bCanceled ) |
| InfoBox( pCurWin, String( IDEResId( RID_STR_SEARCHNOTFOUND ) ) ).Execute(); |
| } |
| |
| rReq.Done(); |
| } |
| } |
| } |
| break; |
| case FID_SEARCH_OFF: |
| { |
| if ( pCurWin && pCurWin->ISA( ModulWindow ) ) |
| pCurWin->GrabFocus(); |
| } |
| break; |
| case SID_UNDO: |
| case SID_REDO: |
| { |
| if ( GetUndoManager() && pCurWin->AllowUndo() ) |
| { |
| GetViewFrame()->ExecuteSlot( rReq ); |
| } |
| } |
| break; |
| default: |
| { |
| pCurWin->ExecuteCommand( rReq ); |
| } |
| } |
| } |
| |
| // Egal, wer oben, Einfluss auf die Shell: |
| void __EXPORT BasicIDEShell::ExecuteGlobal( SfxRequest& rReq ) |
| { |
| sal_uInt16 nSlot = rReq.GetSlot(); |
| switch ( nSlot ) |
| { |
| case SID_BASICSTOP: |
| { |
| // Evtl. nicht einfach anhalten, falls auf Brechpunkt! |
| if ( pCurWin && pCurWin->IsA( TYPE( ModulWindow ) ) ) |
| ((ModulWindow*)pCurWin)->BasicStop(); |
| BasicIDE::StopBasic(); |
| } |
| break; |
| |
| case SID_SAVEDOC: |
| { |
| if ( pCurWin ) |
| { |
| // Daten ins BASIC zurueckschreiben |
| StoreAllWindowData(); |
| |
| // document basic |
| ScriptDocument aDocument( pCurWin->GetDocument() ); |
| if ( aDocument.isDocument() ) |
| { |
| uno::Reference< task::XStatusIndicator > xStatusIndicator; |
| |
| SFX_REQUEST_ARG( rReq, pStatusIndicatorItem, SfxUnoAnyItem, SID_PROGRESS_STATUSBAR_CONTROL, sal_False ); |
| if ( pStatusIndicatorItem ) |
| OSL_VERIFY( pStatusIndicatorItem->GetValue() >>= xStatusIndicator ); |
| else |
| { |
| // get statusindicator |
| SfxViewFrame *pFrame_ = GetFrame(); |
| if ( pFrame_ ) |
| { |
| uno::Reference< task::XStatusIndicatorFactory > xStatFactory( |
| pFrame_->GetFrame().GetFrameInterface(), |
| uno::UNO_QUERY ); |
| if( xStatFactory.is() ) |
| xStatusIndicator = xStatFactory->createStatusIndicator(); |
| } |
| |
| if ( xStatusIndicator.is() ) |
| rReq.AppendItem( SfxUnoAnyItem( SID_PROGRESS_STATUSBAR_CONTROL, uno::makeAny( xStatusIndicator ) ) ); |
| } |
| |
| aDocument.saveDocument( xStatusIndicator ); |
| } |
| |
| SfxBindings* pBindings = BasicIDE::GetBindingsPtr(); |
| if ( pBindings ) |
| { |
| pBindings->Invalidate( SID_DOC_MODIFIED ); |
| pBindings->Invalidate( SID_SAVEDOC ); |
| pBindings->Invalidate( SID_SIGNATURE ); |
| } |
| } |
| } |
| break; |
| case SID_SIGNATURE: |
| { |
| if ( pCurWin ) |
| { |
| ::basctl::DocumentSignature aSignature( pCurWin->GetDocument() ); |
| if ( aSignature.supportsSignatures() ) |
| { |
| aSignature.signScriptingContent(); |
| SfxBindings* pBindings = BasicIDE::GetBindingsPtr(); |
| if ( pBindings ) |
| pBindings->Invalidate( SID_SIGNATURE ); |
| } |
| } |
| } |
| break; |
| |
| case SID_BASICIDE_MODULEDLG: |
| { |
| if ( rReq.GetArgs() ) |
| { |
| const SfxUInt16Item &rTabId = (const SfxUInt16Item&)rReq.GetArgs()->Get(SID_BASICIDE_ARG_TABID ); |
| BasicIDE::Organize( rTabId.GetValue() ); |
| } |
| else |
| BasicIDE::Organize( 0 ); |
| } |
| break; |
| case SID_BASICIDE_CHOOSEMACRO: |
| { |
| BasicIDE::ChooseMacro( NULL, sal_False, ::rtl::OUString() ); |
| } |
| break; |
| case SID_BASICIDE_CREATEMACRO: |
| case SID_BASICIDE_EDITMACRO: |
| { |
| DBG_ASSERT( rReq.GetArgs(), "arguments expected" ); |
| const SfxMacroInfoItem& rInfo = (const SfxMacroInfoItem&)rReq.GetArgs()->Get(SID_BASICIDE_ARG_MACROINFO ); |
| BasicManager* pBasMgr = (BasicManager*)rInfo.GetBasicManager(); |
| DBG_ASSERT( pBasMgr, "Nichts selektiert im Basic-Baum ?" ); |
| |
| ScriptDocument aDocument( ScriptDocument::getDocumentForBasicManager( pBasMgr ) ); |
| |
| StartListening( *pBasMgr, sal_True /* Nur einmal anmelden */ ); |
| String aLibName( rInfo.GetLib() ); |
| if ( !aLibName.Len() ) |
| aLibName = String::CreateFromAscii( "Standard" ); |
| StarBASIC* pBasic = pBasMgr->GetLib( aLibName ); |
| if ( !pBasic ) |
| { |
| // load module and dialog library (if not loaded) |
| aDocument.loadLibraryIfExists( E_SCRIPTS, aLibName ); |
| aDocument.loadLibraryIfExists( E_DIALOGS, aLibName ); |
| |
| // get Basic |
| pBasic = pBasMgr->GetLib( aLibName ); |
| } |
| DBG_ASSERT( pBasic, "Kein Basic!" ); |
| |
| SetCurLib( aDocument, aLibName ); |
| |
| if ( rReq.GetSlot() == SID_BASICIDE_CREATEMACRO ) |
| { |
| SbModule* pModule = pBasic->FindModule( rInfo.GetModule() ); |
| if ( !pModule ) |
| { |
| if ( rInfo.GetModule().Len() || !pBasic->GetModules()->Count() ) |
| { |
| String aModName = rInfo.GetModule(); |
| |
| ::rtl::OUString sModuleCode; |
| if ( aDocument.createModule( aLibName, aModName, sal_False, sModuleCode ) ) |
| pModule = pBasic->FindModule( aModName ); |
| } |
| else |
| pModule = (SbModule*) pBasic->GetModules()->Get(0); |
| } |
| DBG_ASSERT( pModule, "Kein Modul!" ); |
| if ( !pModule->GetMethods()->Find( rInfo.GetMethod(), SbxCLASS_METHOD ) ) |
| BasicIDE::CreateMacro( pModule, rInfo.GetMethod() ); |
| } |
| SfxViewFrame* pViewFrame = GetViewFrame(); |
| if ( pViewFrame ) |
| pViewFrame->ToTop(); |
| ModulWindow* pWin = FindBasWin( aDocument, aLibName, rInfo.GetModule(), sal_True ); |
| DBG_ASSERT( pWin, "Edit/Create Macro: Fenster wurde nicht erzeugt/gefunden!" ); |
| SetCurWindow( pWin, sal_True ); |
| pWin->EditMacro( rInfo.GetMethod() ); |
| } |
| break; |
| case SID_BASICIDE_OBJCAT: |
| { |
| ShowObjectDialog( sal_True, sal_True ); |
| } |
| break; |
| case SID_BASICIDE_NAMECHANGEDONTAB: |
| { |
| DBG_ASSERT( rReq.GetArgs(), "arguments expected" ); |
| const SfxUInt16Item &rTabId = (const SfxUInt16Item&)rReq.GetArgs()->Get(SID_BASICIDE_ARG_TABID ); |
| const SfxStringItem &rModName = (const SfxStringItem&)rReq.GetArgs()->Get(SID_BASICIDE_ARG_MODULENAME ); |
| IDEBaseWindow* pWin = aIDEWindowTable.Get( rTabId.GetValue() ); |
| DBG_ASSERT( pWin, "Window nicht im Liste, aber in TabBar ?" ); |
| if ( pWin ) |
| { |
| String aNewName( rModName.GetValue() ); |
| String aOldName( pWin->GetName() ); |
| if ( aNewName != aOldName ) |
| { |
| bool bRenameOk = false; |
| if ( pWin->IsA( TYPE( ModulWindow ) ) ) |
| { |
| ModulWindow* pModWin = (ModulWindow*)pWin; |
| String aLibName = ( pModWin->GetLibName() ); |
| ScriptDocument aDocument( pWin->GetDocument() ); |
| |
| if ( BasicIDE::RenameModule( pModWin, aDocument, aLibName, aOldName, aNewName ) ) |
| { |
| bRenameOk = true; |
| // Because we listen for container events for script |
| // modules, rename will delete the 'old' window |
| // pWin has been invalidated, restore now |
| pWin = FindBasWin( aDocument, aLibName, aNewName, sal_True ); |
| } |
| |
| } |
| else if ( pWin->IsA( TYPE( DialogWindow ) ) ) |
| { |
| DialogWindow* pDlgWin = (DialogWindow*)pWin; |
| bRenameOk = pDlgWin->RenameDialog( aNewName ); |
| } |
| if ( bRenameOk ) |
| { |
| BasicIDE::MarkDocumentModified( pWin->GetDocument() ); |
| } |
| else |
| { |
| // set old name in TabWriter |
| sal_uInt16 nId = (sal_uInt16)aIDEWindowTable.GetKey( pWin ); |
| DBG_ASSERT( nId, "No entry in Tabbar!" ); |
| if ( nId ) |
| pTabBar->SetPageText( nId, aOldName ); |
| } |
| } |
| |
| // set focus to current window |
| pWin->GrabFocus(); |
| } |
| } |
| break; |
| case SID_BASICIDE_STOREMODULESOURCE: |
| case SID_BASICIDE_UPDATEMODULESOURCE: |
| { |
| DBG_ASSERT( rReq.GetArgs(), "arguments expected" ); |
| const SfxMacroInfoItem& rInfo = (const SfxMacroInfoItem&)rReq.GetArgs()->Get(SID_BASICIDE_ARG_MACROINFO ); |
| BasicManager* pBasMgr = (BasicManager*)rInfo.GetBasicManager(); |
| DBG_ASSERT( pBasMgr, "Store source: Kein BasMgr?" ); |
| ScriptDocument aDocument( ScriptDocument::getDocumentForBasicManager( pBasMgr ) ); |
| ModulWindow* pWin = FindBasWin( aDocument, rInfo.GetLib(), rInfo.GetModule(), sal_False, sal_True ); |
| if ( pWin ) |
| { |
| if ( rReq.GetSlot() == SID_BASICIDE_STOREMODULESOURCE ) |
| pWin->StoreData(); |
| else |
| pWin->UpdateData(); |
| } |
| } |
| break; |
| case SID_BASICIDE_STOREALLMODULESOURCES: |
| case SID_BASICIDE_UPDATEALLMODULESOURCES: |
| { |
| IDEBaseWindow* pWin = aIDEWindowTable.First(); |
| while ( pWin ) |
| { |
| if ( !pWin->IsSuspended() && pWin->IsA( TYPE( ModulWindow ) ) ) |
| { |
| if ( rReq.GetSlot() == SID_BASICIDE_STOREALLMODULESOURCES ) |
| pWin->StoreData(); |
| else |
| pWin->UpdateData(); |
| } |
| pWin = aIDEWindowTable.Next(); |
| } |
| } |
| break; |
| case SID_BASICIDE_LIBSELECTED: |
| case SID_BASICIDE_LIBREMOVED: |
| case SID_BASICIDE_LIBLOADED: |
| { |
| DBG_ASSERT( rReq.GetArgs(), "arguments expected" ); |
| const SfxUsrAnyItem& rShellItem = (const SfxUsrAnyItem&)rReq.GetArgs()->Get( SID_BASICIDE_ARG_DOCUMENT_MODEL ); |
| uno::Reference< frame::XModel > xModel( rShellItem.GetValue(), UNO_QUERY ); |
| ScriptDocument aDocument( xModel.is() ? ScriptDocument( xModel ) : ScriptDocument::getApplicationScriptDocument() ); |
| const SfxStringItem& rLibNameItem = (const SfxStringItem&)rReq.GetArgs()->Get( SID_BASICIDE_ARG_LIBNAME ); |
| String aLibName( rLibNameItem.GetValue() ); |
| |
| if ( nSlot == SID_BASICIDE_LIBSELECTED ) |
| { |
| // load module and dialog library (if not loaded) |
| aDocument.loadLibraryIfExists( E_SCRIPTS, aLibName ); |
| aDocument.loadLibraryIfExists( E_DIALOGS, aLibName ); |
| |
| // check password, if library is password protected and not verified |
| sal_Bool bOK = sal_True; |
| Reference< script::XLibraryContainer > xModLibContainer( aDocument.getLibraryContainer( E_SCRIPTS ) ); |
| if ( xModLibContainer.is() && xModLibContainer->hasByName( aLibName ) ) |
| { |
| Reference< script::XLibraryContainerPassword > xPasswd( xModLibContainer, UNO_QUERY ); |
| if ( xPasswd.is() && xPasswd->isLibraryPasswordProtected( aLibName ) && !xPasswd->isLibraryPasswordVerified( aLibName ) ) |
| { |
| String aPassword; |
| bOK = QueryPassword( xModLibContainer, aLibName, aPassword ); |
| } |
| } |
| |
| if ( bOK ) |
| { |
| SetCurLib( aDocument, aLibName, true, false ); |
| } |
| else |
| { |
| // alten Wert einstellen... |
| SfxBindings* pBindings = BasicIDE::GetBindingsPtr(); |
| if ( pBindings ) |
| pBindings->Invalidate( SID_BASICIDE_LIBSELECTOR, sal_True, sal_False ); |
| } |
| } |
| else if ( nSlot == SID_BASICIDE_LIBREMOVED ) |
| { |
| if ( !m_aCurLibName.Len() || ( aDocument == m_aCurDocument && aLibName == m_aCurLibName ) ) |
| { |
| RemoveWindows( aDocument, aLibName, sal_True ); |
| if ( aDocument == m_aCurDocument && aLibName == m_aCurLibName ) |
| { |
| m_aCurDocument = ScriptDocument::getApplicationScriptDocument(); |
| m_aCurLibName = String(); |
| // Kein UpdateWindows! |
| SfxBindings* pBindings = BasicIDE::GetBindingsPtr(); |
| if ( pBindings ) |
| pBindings->Invalidate( SID_BASICIDE_LIBSELECTOR ); |
| } |
| } |
| } |
| else // Loaded... |
| UpdateWindows(); |
| } |
| break; |
| case SID_BASICIDE_NEWMODULE: |
| { |
| ModulWindow* pWin = CreateBasWin( m_aCurDocument, m_aCurLibName, String() ); |
| DBG_ASSERT( pWin, "New Module: Konnte Fenster nicht erzeugen!" ); |
| SetCurWindow( pWin, sal_True ); |
| } |
| break; |
| case SID_BASICIDE_NEWDIALOG: |
| { |
| DialogWindow* pWin = CreateDlgWin( m_aCurDocument, m_aCurLibName, String() ); |
| DBG_ASSERT( pWin, "New Module: Konnte Fenster nicht erzeugen!" ); |
| SetCurWindow( pWin, sal_True ); |
| } |
| break; |
| case SID_BASICIDE_SBXRENAMED: |
| { |
| DBG_ASSERT( rReq.GetArgs(), "arguments expected" ); |
| } |
| break; |
| case SID_BASICIDE_SBXINSERTED: |
| { |
| DBG_ASSERT( rReq.GetArgs(), "arguments expected" ); |
| const SbxItem& rSbxItem = (const SbxItem&)rReq.GetArgs()->Get(SID_BASICIDE_ARG_SBX ); |
| ScriptDocument aDocument( rSbxItem.GetDocument() ); |
| String aLibName( rSbxItem.GetLibName() ); |
| String aName( rSbxItem.GetName() ); |
| if ( !m_aCurLibName.Len() || ( aDocument == m_aCurDocument && aLibName == m_aCurLibName ) ) |
| { |
| IDEBaseWindow* pWin = 0; |
| if ( rSbxItem.GetType() == BASICIDE_TYPE_MODULE ) |
| pWin = FindBasWin( aDocument, aLibName, aName, sal_True ); |
| else if ( rSbxItem.GetType() == BASICIDE_TYPE_DIALOG ) |
| pWin = FindDlgWin( aDocument, aLibName, aName, sal_True ); |
| } |
| } |
| break; |
| case SID_BASICIDE_SBXDELETED: |
| { |
| DBG_ASSERT( rReq.GetArgs(), "arguments expected" ); |
| const SbxItem& rSbxItem = (const SbxItem&)rReq.GetArgs()->Get(SID_BASICIDE_ARG_SBX ); |
| ScriptDocument aDocument( rSbxItem.GetDocument() ); |
| IDEBaseWindow* pWin = FindWindow( aDocument, rSbxItem.GetLibName(), rSbxItem.GetName(), rSbxItem.GetType(), sal_True ); |
| if ( pWin ) |
| RemoveWindow( pWin, sal_True ); |
| } |
| break; |
| case SID_BASICIDE_SHOWSBX: |
| { |
| DBG_ASSERT( rReq.GetArgs(), "arguments expected" ); |
| const SbxItem& rSbxItem = (const SbxItem&)rReq.GetArgs()->Get(SID_BASICIDE_ARG_SBX ); |
| ScriptDocument aDocument( rSbxItem.GetDocument() ); |
| String aLibName( rSbxItem.GetLibName() ); |
| String aName( rSbxItem.GetName() ); |
| SetCurLib( aDocument, aLibName ); |
| IDEBaseWindow* pWin = 0; |
| if ( rSbxItem.GetType() == BASICIDE_TYPE_DIALOG ) |
| { |
| pWin = FindDlgWin( aDocument, aLibName, aName, sal_True ); |
| } |
| else if ( rSbxItem.GetType() == BASICIDE_TYPE_MODULE ) |
| { |
| pWin = FindBasWin( aDocument, aLibName, aName, sal_True ); |
| } |
| else if ( rSbxItem.GetType() == BASICIDE_TYPE_METHOD ) |
| { |
| pWin = FindBasWin( aDocument, aLibName, aName, sal_True ); |
| ((ModulWindow*)pWin)->EditMacro( rSbxItem.GetMethodName() ); |
| } |
| DBG_ASSERT( pWin, "Fenster wurde nicht erzeugt!" ); |
| SetCurWindow( pWin, sal_True ); |
| pTabBar->MakeVisible( pTabBar->GetCurPageId() ); |
| } |
| break; |
| case SID_SHOW_PROPERTYBROWSER: |
| { |
| GetViewFrame()->ChildWindowExecute( rReq ); |
| rReq.Done(); |
| } |
| break; |
| case SID_BASICIDE_SHOWWINDOW: |
| { |
| ::std::auto_ptr< ScriptDocument > pDocument; |
| |
| SFX_REQUEST_ARG( rReq, pDocumentItem, SfxStringItem, SID_BASICIDE_ARG_DOCUMENT, sal_False ); |
| if ( pDocumentItem ) |
| { |
| String sDocumentCaption = pDocumentItem->GetValue(); |
| if ( sDocumentCaption.Len() ) |
| pDocument.reset( new ScriptDocument( ScriptDocument::getDocumentWithURLOrCaption( sDocumentCaption ) ) ); |
| } |
| |
| SFX_REQUEST_ARG( rReq, pDocModelItem, SfxUsrAnyItem, SID_BASICIDE_ARG_DOCUMENT_MODEL, sal_False ); |
| if ( !pDocument.get() && pDocModelItem ) |
| { |
| uno::Reference< frame::XModel > xModel( pDocModelItem->GetValue(), UNO_QUERY ); |
| if ( xModel.is() ) |
| pDocument.reset( new ScriptDocument( xModel ) ); |
| } |
| |
| if ( !pDocument.get() ) |
| break; |
| |
| SFX_REQUEST_ARG( rReq, pLibNameItem, SfxStringItem, SID_BASICIDE_ARG_LIBNAME, sal_False ); |
| if ( !pLibNameItem ) |
| break; |
| |
| String aLibName( pLibNameItem->GetValue() ); |
| pDocument->loadLibraryIfExists( E_SCRIPTS, aLibName ); |
| SetCurLib( *pDocument, aLibName ); |
| SFX_REQUEST_ARG( rReq, pNameItem, SfxStringItem, SID_BASICIDE_ARG_NAME, sal_False ); |
| if ( pNameItem ) |
| { |
| String aName( pNameItem->GetValue() ); |
| String aModType( String::CreateFromAscii( "Module" ) ); |
| String aDlgType( String::CreateFromAscii( "Dialog" ) ); |
| String aType( aModType ); |
| SFX_REQUEST_ARG( rReq, pTypeItem, SfxStringItem, SID_BASICIDE_ARG_TYPE, sal_False ); |
| if ( pTypeItem ) |
| aType = pTypeItem->GetValue(); |
| |
| IDEBaseWindow* pWin = 0; |
| if ( aType == aModType ) |
| pWin = FindBasWin( *pDocument, aLibName, aName, sal_False ); |
| else if ( aType == aDlgType ) |
| pWin = FindDlgWin( *pDocument, aLibName, aName, sal_False ); |
| |
| if ( pWin ) |
| { |
| SetCurWindow( pWin, sal_True ); |
| if ( pTabBar ) |
| pTabBar->MakeVisible( pTabBar->GetCurPageId() ); |
| |
| if ( pWin->ISA( ModulWindow ) ) |
| { |
| ModulWindow* pModWin = (ModulWindow*)pWin; |
| SFX_REQUEST_ARG( rReq, pLineItem, SfxUInt32Item, SID_BASICIDE_ARG_LINE, sal_False ); |
| if ( pLineItem ) |
| { |
| pModWin->AssertValidEditEngine(); |
| TextView* pTextView = pModWin->GetEditView(); |
| if ( pTextView ) |
| { |
| TextEngine* pTextEngine = pTextView->GetTextEngine(); |
| if ( pTextEngine ) |
| { |
| sal_uInt32 nLine = pLineItem->GetValue(); |
| sal_uInt32 nLineCount = 0; |
| for ( sal_uInt32 i = 0, nCount = pTextEngine->GetParagraphCount(); i < nCount; ++i ) |
| nLineCount += pTextEngine->GetLineCount( i ); |
| if ( nLine > nLineCount ) |
| nLine = nLineCount; |
| if ( nLine > 0 ) |
| --nLine; |
| |
| // scroll window and set selection |
| long nVisHeight = pModWin->GetOutputSizePixel().Height(); |
| long nTextHeight = pTextEngine->GetTextHeight(); |
| if ( nTextHeight > nVisHeight ) |
| { |
| long nMaxY = nTextHeight - nVisHeight; |
| long nOldY = pTextView->GetStartDocPos().Y(); |
| long nNewY = nLine * pTextEngine->GetCharHeight() - nVisHeight / 2; |
| nNewY = ::std::min( nNewY, nMaxY ); |
| pTextView->Scroll( 0, -( nNewY - nOldY ) ); |
| pTextView->ShowCursor( sal_False, sal_True ); |
| pModWin->GetEditVScrollBar().SetThumbPos( pTextView->GetStartDocPos().Y() ); |
| } |
| sal_uInt16 nCol1 = 0, nCol2 = 0; |
| SFX_REQUEST_ARG( rReq, pCol1Item, SfxUInt16Item, SID_BASICIDE_ARG_COLUMN1, sal_False ); |
| if ( pCol1Item ) |
| { |
| nCol1 = pCol1Item->GetValue(); |
| if ( nCol1 > 0 ) |
| --nCol1; |
| nCol2 = nCol1; |
| } |
| SFX_REQUEST_ARG( rReq, pCol2Item, SfxUInt16Item, SID_BASICIDE_ARG_COLUMN2, sal_False ); |
| if ( pCol2Item ) |
| { |
| nCol2 = pCol2Item->GetValue(); |
| if ( nCol2 > 0 ) |
| --nCol2; |
| } |
| TextSelection aSel( TextPaM( nLine, nCol1 ), TextPaM( nLine, nCol2 ) ); |
| pTextView->SetSelection( aSel ); |
| pTextView->ShowCursor(); |
| Window* pWindow_ = pTextView->GetWindow(); |
| if ( pWindow_ ) |
| pWindow_->GrabFocus(); |
| } |
| } |
| } |
| } |
| } |
| } |
| rReq.Done(); |
| } |
| break; |
| |
| case SID_BASICIDE_MANAGE_LANG: |
| { |
| ManageLanguageDialog aDlg( GetCurWindow(), GetCurLocalizationMgr() ); |
| aDlg.Execute(); |
| rReq.Done(); |
| } |
| break; |
| } |
| } |
| |
| void __EXPORT BasicIDEShell::GetState(SfxItemSet &rSet) |
| { |
| SfxWhichIter aIter(rSet); |
| for ( sal_uInt16 nWh = aIter.FirstWhich(); 0 != nWh; nWh = aIter.NextWhich() ) |
| { |
| switch ( nWh ) |
| { |
| case SID_DOCINFO: |
| { |
| rSet.DisableItem( nWh ); |
| } |
| break; |
| case SID_SAVEDOC: |
| { |
| sal_Bool bDisable = sal_False; |
| |
| if ( pCurWin ) |
| { |
| if ( !pCurWin->IsModified() ) |
| { |
| ScriptDocument aDocument( pCurWin->GetDocument() ); |
| bDisable = ( !aDocument.isAlive() ) |
| || ( aDocument.isDocument() ? !aDocument.isDocumentModified() : !IsAppBasicModified() ); |
| } |
| } |
| else |
| { |
| bDisable = sal_True; |
| } |
| |
| if ( bDisable ) |
| rSet.DisableItem( nWh ); |
| } |
| break; |
| case SID_NEWWINDOW: |
| case SID_SAVEASDOC: |
| { |
| rSet.DisableItem( nWh ); |
| } |
| break; |
| case SID_SIGNATURE: |
| { |
| sal_uInt16 nState = 0; |
| if ( pCurWin ) |
| { |
| ::basctl::DocumentSignature aSignature( pCurWin->GetDocument() ); |
| nState = aSignature.getScriptingSignatureState(); |
| } |
| rSet.Put( SfxUInt16Item( SID_SIGNATURE, nState ) ); |
| } |
| break; |
| case SID_BASICIDE_MODULEDLG: |
| { |
| if ( StarBASIC::IsRunning() ) |
| rSet.DisableItem( nWh ); |
| } |
| break; |
| case SID_BASICIDE_CHOOSEMACRO: |
| case SID_BASICIDE_OBJCAT: |
| case SID_BASICIDE_SHOWSBX: |
| case SID_BASICIDE_CREATEMACRO: |
| case SID_BASICIDE_EDITMACRO: |
| case SID_BASICIDE_NAMECHANGEDONTAB: |
| { |
| ; |
| } |
| break; |
| |
| case SID_BASICIDE_ADDWATCH: |
| case SID_BASICIDE_REMOVEWATCH: |
| case SID_BASICLOAD: |
| case SID_BASICSAVEAS: |
| case SID_BASICIDE_MATCHGROUP: |
| { |
| if ( !pCurWin || !pCurWin->IsA( TYPE( ModulWindow ) ) ) |
| rSet.DisableItem( nWh ); |
| else if ( ( nWh == SID_BASICLOAD ) && ( StarBASIC::IsRunning() || ( pCurWin && pCurWin->IsReadOnly() ) ) ) |
| rSet.DisableItem( nWh ); |
| } |
| break; |
| case SID_BASICRUN: |
| case SID_BASICSTEPINTO: |
| case SID_BASICSTEPOVER: |
| case SID_BASICSTEPOUT: |
| case SID_BASICIDE_TOGGLEBRKPNT: |
| case SID_BASICIDE_MANAGEBRKPNTS: |
| { |
| if ( !pCurWin || !pCurWin->IsA( TYPE( ModulWindow ) ) ) |
| rSet.DisableItem( nWh ); |
| else if ( StarBASIC::IsRunning() && !((ModulWindow*)pCurWin)->GetBasicStatus().bIsInReschedule ) |
| rSet.DisableItem( nWh ); |
| } |
| break; |
| case SID_BASICCOMPILE: |
| { |
| if ( !pCurWin || !pCurWin->IsA( TYPE( ModulWindow ) ) || StarBASIC::IsRunning() ) |
| rSet.DisableItem( nWh ); |
| } |
| break; |
| case SID_BASICSTOP: |
| { |
| // Stop immermoeglich, wenn irgendein Basic lauft... |
| if ( !StarBASIC::IsRunning() ) |
| rSet.DisableItem( nWh ); |
| } |
| break; |
| case SID_CHOOSE_CONTROLS: |
| case SID_DIALOG_TESTMODE: |
| { |
| if( !pCurWin || !pCurWin->IsA( TYPE( DialogWindow ) ) ) |
| rSet.DisableItem( nWh ); |
| } |
| break; |
| case SID_SHOW_FORMS: |
| case SID_SHOW_HIDDEN: |
| { |
| rSet.DisableItem( nWh ); |
| } |
| break; |
| case SID_SEARCH_OPTIONS: |
| { |
| sal_uInt16 nOptions = 0; |
| if( pCurWin ) |
| nOptions = pCurWin->GetSearchOptions(); |
| rSet.Put( SfxUInt16Item( SID_SEARCH_OPTIONS, nOptions ) ); |
| } |
| break; |
| case SID_BASICIDE_LIBSELECTOR: |
| { |
| String aName; |
| if ( m_aCurLibName.Len() ) |
| { |
| LibraryLocation eLocation = m_aCurDocument.getLibraryLocation( m_aCurLibName ); |
| aName = CreateMgrAndLibStr( m_aCurDocument.getTitle( eLocation ), m_aCurLibName ); |
| } |
| SfxStringItem aItem( SID_BASICIDE_LIBSELECTOR, aName ); |
| rSet.Put( aItem ); |
| } |
| break; |
| case SID_SEARCH_ITEM: |
| { |
| String aSelected = GetSelectionText( sal_True ); |
| SvxSearchItem& rItem = IDE_DLL()->GetExtraData()->GetSearchItem(); |
| rItem.SetSearchString( aSelected ); |
| rSet.Put( rItem ); |
| } |
| break; |
| case SID_BASICIDE_STAT_DATE: |
| { |
| String aDate; |
| aDate = String( RTL_CONSTASCII_USTRINGPARAM( "Datum?!" ) ); |
| SfxStringItem aItem( SID_BASICIDE_STAT_DATE, aDate ); |
| rSet.Put( aItem ); |
| } |
| break; |
| case SID_DOC_MODIFIED: |
| { |
| String aModifiedMarker; |
| sal_Bool bModified = sal_False; |
| |
| if ( pCurWin ) |
| { |
| if ( pCurWin->IsModified() ) |
| bModified = sal_True; |
| else |
| { |
| ScriptDocument aDocument( pCurWin->GetDocument() ); |
| bModified = aDocument.isDocument() ? aDocument.isDocumentModified() : IsAppBasicModified(); |
| } |
| } |
| |
| if ( bModified ) |
| aModifiedMarker = '*'; |
| |
| SfxStringItem aItem( SID_DOC_MODIFIED, aModifiedMarker ); |
| rSet.Put( aItem ); |
| } |
| break; |
| case SID_BASICIDE_STAT_TITLE: |
| { |
| if ( pCurWin ) |
| { |
| String aTitle = pCurWin->CreateQualifiedName(); |
| SfxStringItem aItem( SID_BASICIDE_STAT_TITLE, aTitle ); |
| rSet.Put( aItem ); |
| } |
| } |
| break; |
| // Werden vom Controller ausgewertet: |
| case SID_ATTR_SIZE: |
| case SID_ATTR_INSERT: |
| break; |
| case SID_UNDO: |
| case SID_REDO: |
| { |
| if( GetUndoManager() ) // sonst rekursives GetState |
| GetViewFrame()->GetSlotState( nWh, NULL, &rSet ); |
| } |
| break; |
| case SID_SHOW_PROPERTYBROWSER: |
| { |
| if ( GetViewFrame()->KnowsChildWindow( nWh ) ) |
| rSet.Put( SfxBoolItem( nWh, GetViewFrame()->HasChildWindow( nWh ) ) ); |
| else |
| rSet.DisableItem( nWh ); |
| } |
| break; |
| |
| case SID_BASICIDE_CURRENT_LANG: |
| { |
| if( (pCurWin && pCurWin->IsReadOnly()) || GetCurLibName().Len() == 0 ) |
| rSet.DisableItem( nWh ); |
| else |
| { |
| String aItemStr; |
| LocalizationMgr* pCurMgr = GetCurLocalizationMgr(); |
| if ( pCurMgr->isLibraryLocalized() ) |
| { |
| Sequence< lang::Locale > aLocaleSeq = pCurMgr->getStringResourceManager()->getLocales(); |
| const lang::Locale* pLocale = aLocaleSeq.getConstArray(); |
| sal_Int32 i, nCount = aLocaleSeq.getLength(); |
| |
| // Force different results for any combination of locales and default locale |
| ::rtl::OUString aLangStr; |
| for ( i = 0; i <= nCount; ++i ) |
| { |
| lang::Locale aLocale; |
| if( i < nCount ) |
| aLocale = pLocale[i]; |
| else |
| aLocale = pCurMgr->getStringResourceManager()->getDefaultLocale(); |
| |
| aLangStr += aLocale.Language; |
| aLangStr += aLocale.Country; |
| aLangStr += aLocale.Variant; |
| } |
| aItemStr = aLangStr; |
| } |
| rSet.Put( SfxStringItem( nWh, aItemStr ) ); |
| } |
| } |
| break; |
| |
| case SID_BASICIDE_MANAGE_LANG: |
| { |
| if( (pCurWin && pCurWin->IsReadOnly()) || GetCurLibName().Len() == 0 ) |
| rSet.DisableItem( nWh ); |
| } |
| break; |
| } |
| } |
| if ( pCurWin ) |
| pCurWin->GetState( rSet ); |
| } |
| |
| sal_Bool BasicIDEShell::HasUIFeature( sal_uInt32 nFeature ) |
| { |
| sal_Bool bResult = sal_False; |
| |
| if ( (nFeature & BASICIDE_UI_FEATURE_SHOW_BROWSER) == BASICIDE_UI_FEATURE_SHOW_BROWSER ) |
| { |
| // fade out (in) property browser in module (dialog) windows |
| if ( pCurWin && pCurWin->IsA( TYPE( DialogWindow ) ) && !pCurWin->IsReadOnly() ) |
| bResult = sal_True; |
| } |
| |
| return bResult; |
| } |
| |
| void BasicIDEShell::SetCurWindow( IDEBaseWindow* pNewWin, sal_Bool bUpdateTabBar, sal_Bool bRememberAsCurrent ) |
| { |
| // Es muss ein EditWindow am Sfx gesetzt sein, sonst kommt kein |
| // Resize, also stehen die Controls auf den Wiese... |
| // Sieht dann sowieso besser aus, wenn das Modul-Layout angezeigt wird... |
| if ( !pNewWin && ( GetWindow() != pModulLayout ) ) |
| { |
| pModulLayout->Show(); |
| AdjustPosSizePixel( Point( 0, 0 ), GetViewFrame()->GetWindow().GetOutputSizePixel() ); |
| SetWindow( pModulLayout ); |
| EnableScrollbars( sal_False ); |
| aVScrollBar.Hide(); |
| } |
| |
| if ( pNewWin != pCurWin ) |
| { |
| IDEBaseWindow* pPrevCurWin = pCurWin; |
| pCurWin = pNewWin; |
| if ( pPrevCurWin ) |
| { |
| pPrevCurWin->Hide(); |
| pPrevCurWin->Deactivating(); |
| // pPrevCurWin->GetLayoutWindow()->Hide(); |
| if( pPrevCurWin->IsA( TYPE( DialogWindow ) ) ) |
| { |
| ((DialogWindow*)pPrevCurWin)->DisableBrowser(); |
| } |
| else |
| { |
| pModulLayout->SetModulWindow( NULL ); |
| } |
| } |
| if ( pCurWin ) |
| { |
| AdjustPosSizePixel( Point( 0, 0 ), GetViewFrame()->GetWindow().GetOutputSizePixel() ); |
| if( pCurWin->IsA( TYPE( ModulWindow ) ) ) |
| { |
| GetViewFrame()->GetWindow().SetHelpId( HID_BASICIDE_MODULWINDOW ); |
| pModulLayout->SetModulWindow( (ModulWindow*)pCurWin ); |
| pModulLayout->Show(); |
| } |
| else |
| { |
| pModulLayout->Hide(); |
| GetViewFrame()->GetWindow().SetHelpId( HID_BASICIDE_DIALOGWINDOW ); |
| } |
| |
| if ( bRememberAsCurrent ) |
| { |
| BasicIDEData* pData = IDE_DLL()->GetExtraData(); |
| if ( pData ) |
| { |
| sal_uInt16 nCurrentType = pCurWin->IsA( TYPE( ModulWindow ) ) ? BASICIDE_TYPE_MODULE : BASICIDE_TYPE_DIALOG; |
| LibInfoItem* pLibInfoItem = new LibInfoItem( pCurWin->GetDocument(), pCurWin->GetLibName(), pCurWin->GetName(), nCurrentType ); |
| pData->GetLibInfos().InsertInfo( pLibInfoItem ); |
| } |
| } |
| |
| if ( GetViewFrame()->GetWindow().IsVisible() ) // sonst macht es spaeter der SFX |
| pCurWin->Show(); |
| |
| pCurWin->Init(); |
| |
| if ( !IDE_DLL()->GetExtraData()->ShellInCriticalSection() ) |
| { |
| Window* pFrameWindow = &GetViewFrame()->GetWindow(); |
| Window* pFocusWindow = Application::GetFocusWindow(); |
| while ( pFocusWindow && ( pFocusWindow != pFrameWindow ) ) |
| pFocusWindow = pFocusWindow->GetParent(); |
| if ( pFocusWindow ) // Focus in BasicIDE |
| pNewWin->GrabFocus(); |
| } |
| if( pCurWin->IsA( TYPE( DialogWindow ) ) ) |
| ((DialogWindow*)pCurWin)->UpdateBrowser(); |
| } |
| if ( bUpdateTabBar ) |
| { |
| sal_uLong nKey = aIDEWindowTable.GetKey( pCurWin ); |
| if ( pCurWin && ( pTabBar->GetPagePos( (sal_uInt16)nKey ) == TAB_PAGE_NOTFOUND ) ) |
| pTabBar->InsertPage( (sal_uInt16)nKey, pCurWin->GetTitle() ); // wurde neu eingeblendet |
| pTabBar->SetCurPageId( (sal_uInt16)nKey ); |
| } |
| if ( pCurWin && pCurWin->IsSuspended() ) // Wenn das Fenster im Fehlerfall angezeigt wird... |
| pCurWin->SetStatus( pCurWin->GetStatus() & ~BASWIN_SUSPENDED ); |
| if ( pCurWin ) |
| { |
| SetWindow( pCurWin ); |
| if ( pCurWin->GetDocument().isDocument() ) |
| SfxObjectShell::SetCurrentComponent( pCurWin->GetDocument().getDocument() ); |
| } |
| else |
| { |
| SetWindow( pModulLayout ); |
| GetViewFrame()->GetWindow().SetHelpId( HID_BASICIDE_MODULWINDOW ); |
| SfxObjectShell::SetCurrentComponent( NULL ); |
| } |
| SetUndoManager( pCurWin ? pCurWin->GetUndoManager() : 0 ); |
| InvalidateBasicIDESlots(); |
| EnableScrollbars( pCurWin ? sal_True : sal_False ); |
| |
| if ( m_pCurLocalizationMgr ) |
| m_pCurLocalizationMgr->handleTranslationbar(); |
| |
| ManageToolbars(); |
| |
| // fade out (in) property browser in module (dialog) windows |
| UIFeatureChanged(); |
| } |
| } |
| |
| void BasicIDEShell::ManageToolbars() |
| { |
| static ::rtl::OUString aLayoutManagerName = ::rtl::OUString::createFromAscii( "LayoutManager" ); |
| static ::rtl::OUString aMacroBarResName = |
| ::rtl::OUString::createFromAscii( "private:resource/toolbar/macrobar" ); |
| static ::rtl::OUString aDialogBarResName = |
| ::rtl::OUString::createFromAscii( "private:resource/toolbar/dialogbar" ); |
| static ::rtl::OUString aInsertControlsBarResName = |
| ::rtl::OUString::createFromAscii( "private:resource/toolbar/insertcontrolsbar" ); |
| (void)aInsertControlsBarResName; |
| |
| if( !pCurWin ) |
| return; |
| |
| Reference< beans::XPropertySet > xFrameProps |
| ( GetViewFrame()->GetFrame().GetFrameInterface(), uno::UNO_QUERY ); |
| if ( xFrameProps.is() ) |
| { |
| Reference< ::com::sun::star::frame::XLayoutManager > xLayoutManager; |
| uno::Any a = xFrameProps->getPropertyValue( aLayoutManagerName ); |
| a >>= xLayoutManager; |
| if ( xLayoutManager.is() ) |
| { |
| xLayoutManager->lock(); |
| if( pCurWin->IsA( TYPE( DialogWindow ) ) ) |
| { |
| xLayoutManager->destroyElement( aMacroBarResName ); |
| |
| xLayoutManager->requestElement( aDialogBarResName ); |
| xLayoutManager->requestElement( aInsertControlsBarResName ); |
| } |
| else |
| { |
| xLayoutManager->destroyElement( aDialogBarResName ); |
| xLayoutManager->destroyElement( aInsertControlsBarResName ); |
| |
| xLayoutManager->requestElement( aMacroBarResName ); |
| } |
| xLayoutManager->unlock(); |
| } |
| } |
| } |
| |
| IDEBaseWindow* BasicIDEShell::FindApplicationWindow() |
| { |
| return FindWindow( ScriptDocument::getApplicationScriptDocument() ); |
| } |
| |
| IDEBaseWindow* BasicIDEShell::FindWindow( const ScriptDocument& rDocument, const String& rLibName, const String& rName, sal_uInt16 nType, sal_Bool bFindSuspended ) |
| { |
| IDEBaseWindow* pWin = aIDEWindowTable.First(); |
| while ( pWin ) |
| { |
| if ( !pWin->IsSuspended() || bFindSuspended ) |
| { |
| if ( !rLibName.Len() || !rName.Len() || nType == BASICIDE_TYPE_UNKNOWN ) |
| { |
| // return any non-suspended window |
| return pWin; |
| } |
| else if ( pWin->IsDocument( rDocument ) && pWin->GetLibName() == rLibName && pWin->GetName() == rName && |
| ( ( pWin->IsA( TYPE( ModulWindow ) ) && nType == BASICIDE_TYPE_MODULE ) || |
| ( pWin->IsA( TYPE( DialogWindow ) ) && nType == BASICIDE_TYPE_DIALOG ) ) ) |
| { |
| return pWin; |
| } |
| } |
| pWin = aIDEWindowTable.Next(); |
| } |
| return 0; |
| } |
| |
| long BasicIDEShell::CallBasicErrorHdl( StarBASIC* pBasic ) |
| { |
| long nRet = 0; |
| ModulWindow* pModWin = ShowActiveModuleWindow( pBasic ); |
| if ( pModWin ) |
| nRet = pModWin->BasicErrorHdl( pBasic ); |
| return nRet; |
| } |
| |
| long BasicIDEShell::CallBasicBreakHdl( StarBASIC* pBasic ) |
| { |
| long nRet = 0; |
| ModulWindow* pModWin = ShowActiveModuleWindow( pBasic ); |
| if ( pModWin ) |
| { |
| sal_Bool bAppWindowDisabled, bDispatcherLocked; |
| sal_uInt16 nWaitCount; |
| SfxUInt16Item *pSWActionCount, *pSWLockViewCount; |
| BasicIDE::BasicStopped( &bAppWindowDisabled, &bDispatcherLocked, |
| &nWaitCount, &pSWActionCount, &pSWLockViewCount ); |
| |
| nRet = pModWin->BasicBreakHdl( pBasic ); |
| |
| if ( StarBASIC::IsRunning() ) // Falls abgebrochen... |
| { |
| if ( bAppWindowDisabled ) |
| Application::GetDefDialogParent()->Enable( sal_False ); |
| /* |
| if ( bDispatcherLocked ) |
| SFX_APP()->LockDispatcher( sal_True ); |
| */ |
| if ( nWaitCount ) |
| { |
| BasicIDEShell* pIDEShell = IDE_DLL()->GetShell(); |
| for ( sal_uInt16 n = 0; n < nWaitCount; n++ ) |
| pIDEShell->GetViewFrame()->GetWindow().EnterWait(); |
| } |
| } |
| } |
| return nRet; |
| } |
| |
| ModulWindow* BasicIDEShell::ShowActiveModuleWindow( StarBASIC* pBasic ) |
| { |
| SetCurLib( ScriptDocument::getApplicationScriptDocument(), String(), false ); |
| |
| SbModule* pActiveModule = StarBASIC::GetActiveModule(); |
| SbClassModuleObject* pClassModuleObject = PTR_CAST(SbClassModuleObject,pActiveModule); |
| if( pClassModuleObject != NULL ) |
| pActiveModule = pClassModuleObject->getClassModule(); |
| |
| DBG_ASSERT( pActiveModule, "Kein aktives Modul im ErrorHdl?!" ); |
| if ( pActiveModule ) |
| { |
| ModulWindow* pWin = 0; |
| SbxObject* pParent = pActiveModule->GetParent(); |
| DBG_ASSERT( pParent && pParent->ISA( StarBASIC ), "Kein BASIC!" ); |
| StarBASIC* pLib = static_cast< StarBASIC* >( pParent ); |
| if ( pLib ) |
| { |
| BasicManager* pBasMgr = BasicIDE::FindBasicManager( pLib ); |
| if ( pBasMgr ) |
| { |
| ScriptDocument aDocument( ScriptDocument::getDocumentForBasicManager( pBasMgr ) ); |
| String aLibName = pLib->GetName(); |
| pWin = FindBasWin( aDocument, aLibName, pActiveModule->GetName(), sal_True ); |
| DBG_ASSERT( pWin, "Error/Step-Hdl: Fenster wurde nicht erzeugt/gefunden!" ); |
| SetCurLib( aDocument, aLibName ); |
| SetCurWindow( pWin, sal_True ); |
| } |
| } |
| BasicManager* pBasicMgr = BasicIDE::FindBasicManager( pBasic ); |
| if ( pBasicMgr ) |
| StartListening( *pBasicMgr, sal_True /* Nur einmal anmelden */ ); |
| return pWin; |
| } |
| return 0; |
| } |
| |
| void __EXPORT BasicIDEShell::AdjustPosSizePixel( const Point &rPos, const Size &rSize ) |
| { |
| // Nicht wenn minimiert, weil dann bei Restore der Text verschoben ist. |
| if ( GetViewFrame()->GetWindow().GetOutputSizePixel().Height() == 0 ) |
| return; |
| |
| Size aSz( rSize ); |
| // long nScrollbarWidthPixel = aVScrollBar.GetSizePixel().Width(); |
| Size aScrollBarBoxSz( aScrollBarBox.GetSizePixel() ); |
| aSz.Height() -= aScrollBarBoxSz.Height(); |
| |
| Size aOutSz( aSz ); |
| aSz.Width() -= aScrollBarBoxSz.Width(); |
| aScrollBarBox.SetPosPixel( Point( rSize.Width() - aScrollBarBoxSz.Width(), rSize.Height() - aScrollBarBoxSz.Height() ) ); |
| aVScrollBar.SetPosSizePixel( Point( rPos.X()+aSz.Width(), rPos.Y() ), Size( aScrollBarBoxSz.Width(), aSz.Height() ) ); |
| if ( bTabBarSplitted ) |
| { |
| // SplitSize ist beim Resize 0 ! |
| long nSplitPos = pTabBar->GetSizePixel().Width(); |
| if ( nSplitPos > aSz.Width() ) |
| nSplitPos = aSz.Width(); |
| pTabBar->SetPosSizePixel( Point( rPos.X(), rPos.Y()+aSz.Height() ), Size( nSplitPos, aScrollBarBoxSz.Height() ) ); |
| long nScrlStart = rPos.X() + nSplitPos; |
| aHScrollBar.SetPosSizePixel( Point( nScrlStart, rPos.Y()+aSz.Height() ), Size( aSz.Width() - nScrlStart + 1, aScrollBarBoxSz.Height() ) ); |
| aHScrollBar.Update(); |
| } |
| else |
| { |
| aHScrollBar.SetPosSizePixel( Point( rPos.X()+ aSz.Width()/2 - 1, rPos.Y()+aSz.Height() ), Size( aSz.Width()/2 + 2, aScrollBarBoxSz.Height() ) ); |
| pTabBar->SetPosSizePixel( Point( rPos.X(), rPos.Y()+aSz.Height() ), Size( aSz.Width()/2, aScrollBarBoxSz.Height() ) ); |
| } |
| |
| Window* pEdtWin = pCurWin ? pCurWin->GetLayoutWindow() : pModulLayout; |
| if ( pEdtWin ) |
| { |
| if( pCurWin && pCurWin->IsA( TYPE( DialogWindow ) ) ) |
| pEdtWin->SetPosSizePixel( rPos, aSz ); // Ohne ScrollBar |
| else |
| pEdtWin->SetPosSizePixel( rPos, aOutSz ); |
| } |
| } |
| |
| Reference< XModel > BasicIDEShell::GetCurrentDocument() const |
| { |
| Reference< XModel > xDocument; |
| if ( pCurWin && pCurWin->GetDocument().isDocument() ) |
| xDocument = pCurWin->GetDocument().getDocument(); |
| return xDocument; |
| } |
| |
| void __EXPORT BasicIDEShell::Activate( sal_Bool bMDI ) |
| { |
| SfxViewShell::Activate( bMDI ); |
| |
| if ( bMDI ) |
| { |
| if( pCurWin && pCurWin->IsA( TYPE( DialogWindow ) ) ) |
| ((DialogWindow*)pCurWin)->UpdateBrowser(); |
| |
| ShowObjectDialog( sal_True, sal_False ); |
| } |
| } |
| |
| void __EXPORT BasicIDEShell::Deactivate( sal_Bool bMDI ) |
| { |
| // bMDI sal_True heisst, dass ein anderes MDI aktiviert wurde, bei einem |
| // Deactivate durch eine MessageBox ist bMDI FALSE |
| if ( bMDI ) |
| { |
| if( pCurWin && pCurWin->IsA( TYPE( DialogWindow ) ) ) |
| { |
| DialogWindow* pXDlgWin = (DialogWindow*)pCurWin; |
| pXDlgWin->DisableBrowser(); |
| if( pXDlgWin->IsModified() ) |
| BasicIDE::MarkDocumentModified( pXDlgWin->GetDocument() ); |
| } |
| |
| // CanClose pruefen, damit auch beim deaktivieren der BasicIDE geprueft wird, |
| // ob in einem Modul der Sourcecode zu gross ist... |
| for ( sal_uLong nWin = 0; nWin < aIDEWindowTable.Count(); nWin++ ) |
| { |
| IDEBaseWindow* pWin = aIDEWindowTable.GetObject( nWin ); |
| if ( /* !pWin->IsSuspended() && */ !pWin->CanClose() ) |
| { |
| if ( m_aCurLibName.Len() && ( pWin->IsDocument( m_aCurDocument ) || pWin->GetLibName() != m_aCurLibName ) ) |
| SetCurLib( ScriptDocument::getApplicationScriptDocument(), String(), false ); |
| SetCurWindow( pWin, sal_True ); |
| break; |
| } |
| } |
| |
| ShowObjectDialog( sal_False, sal_False ); |
| } |
| } |
| |
| |
| IMPL_LINK( BasicIDEShell, AccelSelectHdl, Accelerator*, pAccel ) |
| { |
| sal_Bool bDone = sal_True; |
| SfxViewFrame* pViewFrame = GetViewFrame(); |
| SfxDispatcher* pDispatcher = pViewFrame ? pViewFrame->GetDispatcher() : NULL; |
| if( !pDispatcher ) |
| return sal_False; |
| switch ( pAccel->GetCurKeyCode().GetCode() ) |
| { |
| case KEY_F5: |
| if ( pAccel->GetCurKeyCode().IsShift() ) |
| pDispatcher->Execute( SID_BASICSTOP, SFX_CALLMODE_SYNCHRON ); |
| else |
| pDispatcher->Execute( SID_BASICRUN, SFX_CALLMODE_SYNCHRON ); |
| break; |
| case KEY_F7: |
| pDispatcher->Execute( SID_BASICIDE_ADDWATCH, SFX_CALLMODE_SYNCHRON ); |
| break; |
| case KEY_F8: |
| if ( pAccel->GetCurKeyCode().IsShift() ) |
| pDispatcher->Execute( SID_BASICSTEPOVER, SFX_CALLMODE_SYNCHRON ); |
| else |
| pDispatcher->Execute( SID_BASICSTEPINTO, SFX_CALLMODE_SYNCHRON ); |
| break; |
| case KEY_F9: |
| if ( pAccel->GetCurKeyCode().IsShift() ) |
| pDispatcher->Execute( SID_BASICIDE_TOGGLEBRKPNTENABLED, SFX_CALLMODE_SYNCHRON ); |
| else |
| pDispatcher->Execute( SID_BASICIDE_TOGGLEBRKPNT, SFX_CALLMODE_SYNCHRON ); |
| break; |
| default: bDone = sal_False; |
| } |
| return bDone; |
| } |
| |
