| /************************************************************** |
| * |
| * 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 <memory> |
| |
| #include <ide_pch.hxx> |
| |
| |
| #include <moduldlg.hrc> |
| #include <moduldlg.hxx> |
| #include <basidesh.hrc> |
| #include <basidesh.hxx> |
| #include <bastypes.hxx> |
| #include <baside3.hxx> |
| #include <basobj.hxx> |
| #include <baside2.hrc> |
| #include <sbxitem.hxx> |
| #include <iderdll.hxx> |
| |
| #ifndef _COM_SUN_STAR_IO_XINPUTSTREAMPROVIDER_HXX_ |
| #include <com/sun/star/io/XInputStreamProvider.hpp> |
| #endif |
| #ifndef _COM_SUN_STAR_SCRIPT_XLIBRYARYCONTAINER2_HPP_ |
| #include <com/sun/star/script/XLibraryContainer2.hpp> |
| #endif |
| #include <com/sun/star/script/XLibraryContainerPassword.hpp> |
| #include <com/sun/star/resource/XStringResourceManager.hpp> |
| #include <com/sun/star/lang/XMultiServiceFactory.hpp> |
| #include <comphelper/processfactory.hxx> |
| #include <xmlscript/xmldlg_imexp.hxx> |
| |
| #include "localizationmgr.hxx" |
| #include <basic/sbx.hxx> |
| #include <tools/diagnose_ex.h> |
| |
| using namespace ::com::sun::star; |
| using namespace ::com::sun::star::uno; |
| using namespace ::com::sun::star::lang; |
| using namespace ::com::sun::star::resource; |
| |
| |
| ExtBasicTreeListBox::ExtBasicTreeListBox( Window* pParent, const ResId& rRes ) |
| : BasicTreeListBox( pParent, rRes ) |
| { |
| } |
| |
| |
| |
| ExtBasicTreeListBox::~ExtBasicTreeListBox() |
| { |
| } |
| |
| sal_Bool __EXPORT ExtBasicTreeListBox::EditingEntry( SvLBoxEntry* pEntry, Selection& ) |
| { |
| sal_Bool bRet = sal_False; |
| |
| if ( pEntry ) |
| { |
| sal_uInt16 nDepth = GetModel()->GetDepth( pEntry ); |
| if ( nDepth >= 2 ) |
| { |
| BasicEntryDescriptor aDesc( GetEntryDescriptor( pEntry ) ); |
| ScriptDocument aDocument( aDesc.GetDocument() ); |
| ::rtl::OUString aOULibName( aDesc.GetLibName() ); |
| Reference< script::XLibraryContainer2 > xModLibContainer( aDocument.getLibraryContainer( E_SCRIPTS ), UNO_QUERY ); |
| Reference< script::XLibraryContainer2 > xDlgLibContainer( aDocument.getLibraryContainer( E_DIALOGS ), UNO_QUERY ); |
| if ( !( ( xModLibContainer.is() && xModLibContainer->hasByName( aOULibName ) && xModLibContainer->isLibraryReadOnly( aOULibName ) ) || |
| ( xDlgLibContainer.is() && xDlgLibContainer->hasByName( aOULibName ) && xDlgLibContainer->isLibraryReadOnly( aOULibName ) ) ) ) |
| { |
| // allow editing only for libraries, which are not readonly |
| bRet = sal_True; |
| } |
| } |
| } |
| |
| return bRet; |
| } |
| |
| sal_Bool __EXPORT ExtBasicTreeListBox::EditedEntry( SvLBoxEntry* pEntry, const String& rNewText ) |
| { |
| sal_Bool bValid = BasicIDE::IsValidSbxName( rNewText ); |
| if ( !bValid ) |
| { |
| ErrorBox( this, WB_OK | WB_DEF_OK, String( IDEResId( RID_STR_BADSBXNAME ) ) ).Execute(); |
| return sal_False; |
| } |
| |
| String aCurText( GetEntryText( pEntry ) ); |
| if ( aCurText == rNewText ) |
| // nothing to do |
| return sal_True; |
| |
| BasicEntryDescriptor aDesc( GetEntryDescriptor( pEntry ) ); |
| ScriptDocument aDocument( aDesc.GetDocument() ); |
| DBG_ASSERT( aDocument.isValid(), "ExtBasicTreeListBox::EditedEntry: no document!" ); |
| if ( !aDocument.isValid() ) |
| return sal_False; |
| String aLibName( aDesc.GetLibName() ); |
| BasicEntryType eType( aDesc.GetType() ); |
| |
| bool bSuccess = ( eType == OBJ_TYPE_MODULE ) |
| ? BasicIDE::RenameModule( this, aDocument, aLibName, aCurText, rNewText ) |
| : BasicIDE::RenameDialog( this, aDocument, aLibName, aCurText, rNewText ); |
| |
| if ( !bSuccess ) |
| return sal_False; |
| |
| BasicIDE::MarkDocumentModified( aDocument ); |
| |
| BasicIDEShell* pIDEShell = IDE_DLL()->GetShell(); |
| SfxViewFrame* pViewFrame = pIDEShell ? pIDEShell->GetViewFrame() : NULL; |
| SfxDispatcher* pDispatcher = pViewFrame ? pViewFrame->GetDispatcher() : NULL; |
| if( pDispatcher ) |
| { |
| SbxItem aSbxItem( SID_BASICIDE_ARG_SBX, aDocument, aLibName, rNewText, ConvertType( eType ) ); |
| pDispatcher->Execute( SID_BASICIDE_SBXRENAMED, |
| SFX_CALLMODE_SYNCHRON, &aSbxItem, 0L ); |
| } |
| |
| // OV-Bug?! |
| SetEntryText( pEntry, rNewText ); |
| SetCurEntry( pEntry ); |
| SetCurEntry( pEntry ); |
| Select( pEntry, sal_False ); |
| Select( pEntry ); // damit Handler gerufen wird => Edit updaten |
| |
| return sal_True; |
| } |
| |
| |
| DragDropMode __EXPORT ExtBasicTreeListBox::NotifyStartDrag( TransferDataContainer&, SvLBoxEntry* pEntry ) |
| { |
| DragDropMode nMode_ = SV_DRAGDROP_NONE; |
| |
| if ( pEntry ) |
| { |
| sal_uInt16 nDepth = GetModel()->GetDepth( pEntry ); |
| if ( nDepth >= 2 ) |
| { |
| nMode_ = SV_DRAGDROP_CTRL_COPY; |
| BasicEntryDescriptor aDesc( GetEntryDescriptor( pEntry ) ); |
| ScriptDocument aDocument( aDesc.GetDocument() ); |
| ::rtl::OUString aOULibName( aDesc.GetLibName() ); |
| // allow MOVE mode only for libraries, which are not readonly |
| Reference< script::XLibraryContainer2 > xModLibContainer( aDocument.getLibraryContainer( E_SCRIPTS ), UNO_QUERY ); |
| Reference< script::XLibraryContainer2 > xDlgLibContainer( aDocument.getLibraryContainer( E_DIALOGS ), UNO_QUERY ); |
| if ( !( ( xModLibContainer.is() && xModLibContainer->hasByName( aOULibName ) && xModLibContainer->isLibraryReadOnly( aOULibName ) ) || |
| ( xDlgLibContainer.is() && xDlgLibContainer->hasByName( aOULibName ) && xDlgLibContainer->isLibraryReadOnly( aOULibName ) ) ) ) |
| { |
| // Only allow copy for localized libraries |
| bool bAllowMove = true; |
| if ( xDlgLibContainer.is() && xDlgLibContainer->hasByName( aOULibName ) ) |
| { |
| // Get StringResourceManager |
| Reference< container::XNameContainer > xDialogLib( aDocument.getLibrary( E_DIALOGS, aOULibName, sal_True ) ); |
| Reference< XStringResourceManager > xSourceMgr = |
| LocalizationMgr::getStringResourceFromDialogLibrary( xDialogLib ); |
| if( xSourceMgr.is() ) |
| bAllowMove = ( xSourceMgr->getLocales().getLength() == 0 ); |
| } |
| if( bAllowMove ) |
| nMode_ |= SV_DRAGDROP_CTRL_MOVE; |
| } |
| } |
| } |
| |
| return nMode_; |
| } |
| |
| |
| sal_Bool __EXPORT ExtBasicTreeListBox::NotifyAcceptDrop( SvLBoxEntry* pEntry ) |
| { |
| // don't drop on a BasicManager (nDepth == 0) |
| sal_uInt16 nDepth = pEntry ? GetModel()->GetDepth( pEntry ) : 0; |
| sal_Bool bValid = nDepth ? sal_True : sal_False; |
| |
| // don't drop in the same library |
| SvLBoxEntry* pSelected = FirstSelected(); |
| if ( ( nDepth == 1 ) && ( pEntry == GetParent( pSelected ) ) ) |
| bValid = sal_False; |
| else if ( ( nDepth == 2 ) && ( GetParent( pEntry ) == GetParent( pSelected ) ) ) |
| bValid = sal_False; |
| |
| // don't drop on a library, which is not loaded, readonly or password protected |
| // or which already has a module/dialog with this name |
| if ( bValid && ( nDepth > 0 ) ) |
| { |
| // get source module/dialog name |
| BasicEntryDescriptor aSourceDesc( GetEntryDescriptor( pSelected ) ); |
| String aSourceName( aSourceDesc.GetName() ); |
| BasicEntryType eSourceType( aSourceDesc.GetType() ); |
| |
| // get target shell and target library name |
| BasicEntryDescriptor aDestDesc( GetEntryDescriptor( pEntry ) ); |
| const ScriptDocument& rDestDoc( aDestDesc.GetDocument() ); |
| String aDestLibName( aDestDesc.GetLibName() ); |
| ::rtl::OUString aOUDestLibName( aDestLibName ); |
| |
| // check if module library is not loaded, readonly or password protected |
| Reference< script::XLibraryContainer2 > xModLibContainer( rDestDoc.getLibraryContainer( E_SCRIPTS ), UNO_QUERY ); |
| if ( xModLibContainer.is() && xModLibContainer->hasByName( aOUDestLibName ) ) |
| { |
| if ( !xModLibContainer->isLibraryLoaded( aOUDestLibName ) ) |
| bValid = sal_False; |
| |
| if ( xModLibContainer->isLibraryReadOnly( aOUDestLibName ) ) |
| bValid = sal_False; |
| |
| Reference< script::XLibraryContainerPassword > xPasswd( xModLibContainer, UNO_QUERY ); |
| if ( xPasswd.is() && xPasswd->isLibraryPasswordProtected( aOUDestLibName ) && !xPasswd->isLibraryPasswordVerified( aOUDestLibName ) ) |
| bValid = sal_False; |
| } |
| |
| // check if dialog library is not loaded or readonly |
| Reference< script::XLibraryContainer2 > xDlgLibContainer( rDestDoc.getLibraryContainer( E_DIALOGS ), UNO_QUERY ); |
| if ( xDlgLibContainer.is() && xDlgLibContainer->hasByName( aOUDestLibName ) ) |
| { |
| if ( !xDlgLibContainer->isLibraryLoaded( aOUDestLibName ) ) |
| bValid = sal_False; |
| |
| if ( xDlgLibContainer->isLibraryReadOnly( aOUDestLibName ) ) |
| bValid = sal_False; |
| } |
| |
| // check, if module/dialog with this name is already existing in target library |
| if ( ( eSourceType == OBJ_TYPE_MODULE && rDestDoc.hasModule( aDestLibName, aSourceName ) ) || |
| ( eSourceType == OBJ_TYPE_DIALOG && rDestDoc.hasDialog( aDestLibName, aSourceName ) ) ) |
| { |
| bValid = sal_False; |
| } |
| } |
| |
| return bValid; |
| } |
| |
| |
| sal_Bool __EXPORT ExtBasicTreeListBox::NotifyMoving( SvLBoxEntry* pTarget, SvLBoxEntry* pEntry, |
| SvLBoxEntry*& rpNewParent, sal_uLong& rNewChildPos ) |
| { |
| return NotifyCopyingMoving( pTarget, pEntry, |
| rpNewParent, rNewChildPos, sal_True ); |
| } |
| |
| |
| sal_Bool __EXPORT ExtBasicTreeListBox::NotifyCopying( SvLBoxEntry* pTarget, SvLBoxEntry* pEntry, |
| SvLBoxEntry*& rpNewParent, sal_uLong& rNewChildPos ) |
| { |
| // return sal_False; // Wie kopiere ich ein SBX ?! |
| return NotifyCopyingMoving( pTarget, pEntry, |
| rpNewParent, rNewChildPos, sal_False ); |
| } |
| |
| |
| void BasicIDEShell::CopyDialogResources( Reference< io::XInputStreamProvider >& io_xISP, |
| const ScriptDocument& rSourceDoc, const String& rSourceLibName, const ScriptDocument& rDestDoc, |
| const String& rDestLibName, const String& rDlgName ) |
| { |
| if ( !io_xISP.is() ) |
| return; |
| |
| // Get StringResourceManager |
| Reference< container::XNameContainer > xSourceDialogLib( rSourceDoc.getLibrary( E_DIALOGS, rSourceLibName, sal_True ) ); |
| Reference< XStringResourceManager > xSourceMgr = |
| LocalizationMgr::getStringResourceFromDialogLibrary( xSourceDialogLib ); |
| if( !xSourceMgr.is() ) |
| return; |
| bool bSourceLocalized = ( xSourceMgr->getLocales().getLength() > 0 ); |
| |
| Reference< container::XNameContainer > xDestDialogLib( rDestDoc.getLibrary( E_DIALOGS, rDestLibName, sal_True ) ); |
| Reference< XStringResourceManager > xDestMgr = |
| LocalizationMgr::getStringResourceFromDialogLibrary( xDestDialogLib ); |
| if( !xDestMgr.is() ) |
| return; |
| bool bDestLocalized = ( xDestMgr->getLocales().getLength() > 0 ); |
| |
| if( !bSourceLocalized && !bDestLocalized ) |
| return; |
| |
| // create dialog model |
| Reference< lang::XMultiServiceFactory > xMSF = ::comphelper::getProcessServiceFactory(); |
| Reference< container::XNameContainer > xDialogModel = Reference< container::XNameContainer >( xMSF->createInstance |
| ( ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.awt.UnoControlDialogModel" ) ) ), UNO_QUERY ); |
| Reference< io::XInputStream > xInput( io_xISP->createInputStream() ); |
| Reference< XComponentContext > xContext; |
| Reference< beans::XPropertySet > xProps( xMSF, UNO_QUERY ); |
| OSL_ASSERT( xProps.is() ); |
| OSL_VERIFY( xProps->getPropertyValue( ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("DefaultContext")) ) >>= xContext ); |
| ::xmlscript::importDialogModel( xInput, xDialogModel, xContext ); |
| |
| if( xDialogModel.is() ) |
| { |
| if( bSourceLocalized && bDestLocalized ) |
| { |
| Reference< resource::XStringResourceResolver > xSourceStringResolver( xSourceMgr, UNO_QUERY ); |
| LocalizationMgr::copyResourceForDroppedDialog( xDialogModel, rDlgName, xDestMgr, xSourceStringResolver ); |
| } |
| else if( bSourceLocalized ) |
| { |
| LocalizationMgr::resetResourceForDialog( xDialogModel, xSourceMgr ); |
| } |
| else if( bDestLocalized ) |
| { |
| LocalizationMgr::setResourceIDsForDialog( xDialogModel, xDestMgr ); |
| } |
| io_xISP = ::xmlscript::exportDialogModel( xDialogModel, xContext ); |
| } |
| } |
| |
| |
| sal_Bool __EXPORT ExtBasicTreeListBox::NotifyCopyingMoving( SvLBoxEntry* pTarget, SvLBoxEntry* pEntry, |
| SvLBoxEntry*& rpNewParent, sal_uLong& rNewChildPos, sal_Bool bMove ) |
| { |
| (void)pEntry; |
| DBG_ASSERT( pEntry, "Kein Eintrag?" ); // Hier ASS ok, sollte nicht mit |
| DBG_ASSERT( pTarget, "Kein Ziel?" ); // NULL (ganz vorne) erreicht werden |
| sal_uInt16 nDepth = GetModel()->GetDepth( pTarget ); |
| DBG_ASSERT( nDepth, "Tiefe?" ); |
| if ( nDepth == 1 ) |
| { |
| // Target = Basic => Modul/Dialog unter das Basic haengen... |
| rpNewParent = pTarget; |
| rNewChildPos = 0; |
| } |
| else if ( nDepth >= 2 ) |
| { |
| // Target = Modul/Dialog => Modul/Dialog unter das uebergeordnete Basic haengen... |
| rpNewParent = GetParent( pTarget ); |
| rNewChildPos = GetModel()->GetRelPos( pTarget ) + 1; |
| } |
| |
| // get target shell and target library name |
| BasicEntryDescriptor aDestDesc( GetEntryDescriptor( rpNewParent ) ); |
| const ScriptDocument& rDestDoc( aDestDesc.GetDocument() ); |
| String aDestLibName( aDestDesc.GetLibName() ); |
| |
| // get source shell, library name and module/dialog name |
| BasicEntryDescriptor aSourceDesc( GetEntryDescriptor( FirstSelected() ) ); |
| const ScriptDocument rSourceDoc( aSourceDesc.GetDocument() ); |
| String aSourceLibName( aSourceDesc.GetLibName() ); |
| String aSourceName( aSourceDesc.GetName() ); |
| BasicEntryType eType( aSourceDesc.GetType() ); |
| |
| // get dispatcher |
| BasicIDEShell* pIDEShell = IDE_DLL()->GetShell(); |
| SfxViewFrame* pViewFrame = pIDEShell ? pIDEShell->GetViewFrame() : NULL; |
| SfxDispatcher* pDispatcher = pViewFrame ? pViewFrame->GetDispatcher() : NULL; |
| |
| if ( bMove ) // move |
| { |
| // remove source module/dialog window |
| if ( rSourceDoc != rDestDoc || aSourceLibName != aDestLibName ) |
| { |
| if( pDispatcher ) |
| { |
| SbxItem aSbxItem( SID_BASICIDE_ARG_SBX, rSourceDoc, aSourceLibName, aSourceName, ConvertType( eType ) ); |
| pDispatcher->Execute( SID_BASICIDE_SBXDELETED, |
| SFX_CALLMODE_SYNCHRON, &aSbxItem, 0L ); |
| } |
| } |
| |
| try |
| { |
| if ( eType == OBJ_TYPE_MODULE ) // module |
| { |
| // get module |
| ::rtl::OUString aModule; |
| if ( rSourceDoc.getModule( aSourceLibName, aSourceName, aModule ) ) |
| { |
| // remove module from source library |
| if ( rSourceDoc.removeModule( aSourceLibName, aSourceName ) ) |
| { |
| BasicIDE::MarkDocumentModified( rSourceDoc ); |
| |
| // insert module into target library |
| if ( rDestDoc.insertModule( aDestLibName, aSourceName, aModule ) ) |
| BasicIDE::MarkDocumentModified( rDestDoc ); |
| } |
| } |
| } |
| else if ( eType == OBJ_TYPE_DIALOG ) // dialog |
| { |
| // get dialog |
| Reference< io::XInputStreamProvider > xISP; |
| if ( rSourceDoc.getDialog( aSourceLibName, aSourceName, xISP ) ) |
| { |
| BasicIDEShell::CopyDialogResources( xISP, rSourceDoc, |
| aSourceLibName, rDestDoc, aDestLibName, aSourceName ); |
| |
| // remove dialog from source library |
| if ( BasicIDE::RemoveDialog( rSourceDoc, aSourceLibName, aSourceName ) ) |
| { |
| BasicIDE::MarkDocumentModified( rSourceDoc ); |
| |
| // insert dialog into target library |
| if ( rDestDoc.insertDialog( aDestLibName, aSourceName, xISP ) ) |
| BasicIDE::MarkDocumentModified( rDestDoc ); |
| } |
| } |
| } |
| } |
| catch ( uno::Exception& ) |
| { |
| DBG_UNHANDLED_EXCEPTION(); |
| } |
| } |
| else // copy |
| { |
| try |
| { |
| if ( eType == OBJ_TYPE_MODULE ) // module |
| { |
| // get module |
| ::rtl::OUString aModule; |
| if ( rSourceDoc.getModule( aSourceLibName, aSourceName, aModule ) ) |
| { |
| // insert module into target library |
| if ( rDestDoc.insertModule( aDestLibName, aSourceName, aModule ) ) |
| BasicIDE::MarkDocumentModified( rDestDoc ); |
| } |
| } |
| else if ( eType == OBJ_TYPE_DIALOG ) // dialog |
| { |
| // get dialog |
| Reference< io::XInputStreamProvider > xISP; |
| if ( rSourceDoc.getDialog( aSourceLibName, aSourceName, xISP ) ) |
| { |
| BasicIDEShell::CopyDialogResources( xISP, rSourceDoc, |
| aSourceLibName, rDestDoc, aDestLibName, aSourceName ); |
| |
| // insert dialog into target library |
| if ( rDestDoc.insertDialog( aDestLibName, aSourceName, xISP ) ) |
| BasicIDE::MarkDocumentModified( rDestDoc ); |
| } |
| } |
| } |
| catch ( const Exception& ) |
| { |
| DBG_UNHANDLED_EXCEPTION(); |
| } |
| } |
| |
| // create target module/dialog window |
| if ( rSourceDoc != rDestDoc || aSourceLibName != aDestLibName ) |
| { |
| if( pDispatcher ) |
| { |
| SbxItem aSbxItem( SID_BASICIDE_ARG_SBX, rDestDoc, aDestLibName, aSourceName, ConvertType( eType ) ); |
| pDispatcher->Execute( SID_BASICIDE_SBXINSERTED, |
| SFX_CALLMODE_SYNCHRON, &aSbxItem, 0L ); |
| } |
| } |
| |
| return 2; // Aufklappen... |
| } |
| |
| OrganizeDialog::OrganizeDialog( Window* pParent, sal_Int16 tabId, BasicEntryDescriptor& rDesc ) |
| :TabDialog( pParent, IDEResId( RID_TD_ORGANIZE ) ) |
| ,aTabCtrl( this, IDEResId( RID_TC_ORGANIZE ) ) |
| ,m_aCurEntry( rDesc ) |
| { |
| FreeResource(); |
| aTabCtrl.SetActivatePageHdl( LINK( this, OrganizeDialog, ActivatePageHdl ) ); |
| if( tabId == 0 ) |
| { |
| aTabCtrl.SetCurPageId( RID_TP_MOD ); |
| } |
| else if ( tabId == 1 ) |
| { |
| aTabCtrl.SetCurPageId( RID_TP_DLG ); |
| } |
| else |
| { |
| aTabCtrl.SetCurPageId( RID_TP_LIB ); |
| } |
| |
| ActivatePageHdl( &aTabCtrl ); |
| |
| BasicIDEShell* pIDEShell = IDE_DLL()->GetShell(); |
| SfxViewFrame* pViewFrame = pIDEShell ? pIDEShell->GetViewFrame() : NULL; |
| SfxDispatcher* pDispatcher = pViewFrame ? pViewFrame->GetDispatcher() : NULL; |
| if( pDispatcher ) |
| { |
| pDispatcher->Execute( SID_BASICIDE_STOREALLMODULESOURCES ); |
| } |
| } |
| |
| __EXPORT OrganizeDialog::~OrganizeDialog() |
| { |
| for ( sal_uInt16 i = 0; i < aTabCtrl.GetPageCount(); i++ ) |
| delete aTabCtrl.GetTabPage( aTabCtrl.GetPageId( i ) ); |
| }; |
| |
| short OrganizeDialog::Execute() |
| { |
| Window* pPrevDlgParent = Application::GetDefDialogParent(); |
| Application::SetDefDialogParent( this ); |
| short nRet = TabDialog::Execute(); |
| Application::SetDefDialogParent( pPrevDlgParent ); |
| return nRet; |
| } |
| |
| |
| IMPL_LINK( OrganizeDialog, ActivatePageHdl, TabControl *, pTabCtrl ) |
| { |
| sal_uInt16 nId = pTabCtrl->GetCurPageId(); |
| // Wenn TabPage noch nicht erzeugt wurde, dann erzeugen |
| if ( !pTabCtrl->GetTabPage( nId ) ) |
| { |
| TabPage* pNewTabPage = 0; |
| switch ( nId ) |
| { |
| case RID_TP_MOD: |
| { |
| pNewTabPage = new ObjectPage( pTabCtrl, IDEResId( RID_TP_MODULS ), BROWSEMODE_MODULES ); |
| ((ObjectPage*)pNewTabPage)->SetTabDlg( this ); |
| ((ObjectPage*)pNewTabPage)->SetCurrentEntry( m_aCurEntry ); |
| } |
| break; |
| case RID_TP_DLG: |
| { |
| pNewTabPage = new ObjectPage( pTabCtrl, IDEResId( RID_TP_DLGS ), BROWSEMODE_DIALOGS ); |
| ((ObjectPage*)pNewTabPage)->SetTabDlg( this ); |
| ((ObjectPage*)pNewTabPage)->SetCurrentEntry( m_aCurEntry ); |
| } |
| break; |
| case RID_TP_LIB: |
| { |
| pNewTabPage = new LibPage( pTabCtrl ); |
| ((LibPage*)pNewTabPage)->SetTabDlg( this ); |
| } |
| break; |
| default: DBG_ERROR( "PageHdl: Unbekannte ID!" ); |
| } |
| DBG_ASSERT( pNewTabPage, "Keine Page!" ); |
| pTabCtrl->SetTabPage( nId, pNewTabPage ); |
| } |
| return 0; |
| } |
| |
| ObjectPage::ObjectPage( Window * pParent, const ResId& rResId, sal_uInt16 nMode ) : |
| TabPage( pParent, rResId ), |
| aLibText( this, IDEResId( RID_STR_LIB ) ), |
| aBasicBox( this, IDEResId( RID_TRLBOX ) ), |
| aEditButton( this, IDEResId( RID_PB_EDIT ) ), |
| aCloseButton( this, IDEResId( RID_PB_CLOSE ) ), |
| aNewModButton( this, IDEResId( RID_PB_NEWMOD ) ), |
| aNewDlgButton( this, IDEResId( RID_PB_NEWDLG ) ), |
| aDelButton( this, IDEResId( RID_PB_DELETE ) ) |
| { |
| FreeResource(); |
| pTabDlg = 0; |
| |
| aEditButton.SetClickHdl( LINK( this, ObjectPage, ButtonHdl ) ); |
| aDelButton.SetClickHdl( LINK( this, ObjectPage, ButtonHdl ) ); |
| aCloseButton.SetClickHdl( LINK( this, ObjectPage, ButtonHdl ) ); |
| aBasicBox.SetSelectHdl( LINK( this, ObjectPage, BasicBoxHighlightHdl ) ); |
| |
| if( nMode & BROWSEMODE_MODULES ) |
| { |
| aNewModButton.SetClickHdl( LINK( this, ObjectPage, ButtonHdl ) ); |
| aNewDlgButton.Hide(); |
| } |
| else if ( nMode & BROWSEMODE_DIALOGS ) |
| { |
| aNewDlgButton.SetClickHdl( LINK( this, ObjectPage, ButtonHdl ) ); |
| aNewModButton.Hide(); |
| } |
| |
| aBasicBox.SetDragDropMode( SV_DRAGDROP_CTRL_MOVE | SV_DRAGDROP_CTRL_COPY ); |
| aBasicBox.EnableInplaceEditing( sal_True ); |
| aBasicBox.SetMode( nMode ); |
| aBasicBox.SetStyle( WB_BORDER | WB_TABSTOP | |
| WB_HASLINES | WB_HASLINESATROOT | |
| WB_HASBUTTONS | WB_HASBUTTONSATROOT | |
| WB_HSCROLL ); |
| aBasicBox.ScanAllEntries(); |
| |
| aEditButton.GrabFocus(); |
| CheckButtons(); |
| } |
| |
| void ObjectPage::SetCurrentEntry( BasicEntryDescriptor& rDesc ) |
| { |
| aBasicBox.SetCurrentEntry( rDesc ); |
| } |
| |
| void __EXPORT ObjectPage::ActivatePage() |
| { |
| aBasicBox.UpdateEntries(); |
| } |
| |
| void __EXPORT ObjectPage::DeactivatePage() |
| { |
| } |
| |
| void ObjectPage::CheckButtons() |
| { |
| // enable/disable edit button |
| SvLBoxEntry* pCurEntry = aBasicBox.GetCurEntry(); |
| BasicEntryDescriptor aDesc( aBasicBox.GetEntryDescriptor( pCurEntry ) ); |
| ScriptDocument aDocument( aDesc.GetDocument() ); |
| ::rtl::OUString aOULibName( aDesc.GetLibName() ); |
| String aLibSubName( aDesc.GetLibSubName() ); |
| sal_Bool bVBAEnabled = aDocument.isInVBAMode(); |
| sal_uInt16 nMode = aBasicBox.GetMode(); |
| |
| sal_uInt16 nDepth = pCurEntry ? aBasicBox.GetModel()->GetDepth( pCurEntry ) : 0; |
| if ( nDepth >= 2 ) |
| { |
| if( bVBAEnabled && ( nMode & BROWSEMODE_MODULES ) && ( nDepth == 2 ) ) |
| aEditButton.Disable(); |
| else |
| aEditButton.Enable(); |
| } |
| else |
| aEditButton.Disable(); |
| |
| // enable/disable new module/dialog buttons |
| LibraryLocation eLocation( aDesc.GetLocation() ); |
| sal_Bool bReadOnly = sal_False; |
| if ( nDepth > 0 ) |
| { |
| Reference< script::XLibraryContainer2 > xModLibContainer( aDocument.getLibraryContainer( E_SCRIPTS ), UNO_QUERY ); |
| Reference< script::XLibraryContainer2 > xDlgLibContainer( aDocument.getLibraryContainer( E_DIALOGS ), UNO_QUERY ); |
| if ( ( xModLibContainer.is() && xModLibContainer->hasByName( aOULibName ) && xModLibContainer->isLibraryReadOnly( aOULibName ) ) || |
| ( xDlgLibContainer.is() && xDlgLibContainer->hasByName( aOULibName ) && xDlgLibContainer->isLibraryReadOnly( aOULibName ) ) ) |
| { |
| bReadOnly = sal_True; |
| } |
| } |
| if ( bReadOnly || eLocation == LIBRARY_LOCATION_SHARE ) |
| { |
| aNewModButton.Disable(); |
| aNewDlgButton.Disable(); |
| } |
| else |
| { |
| aNewModButton.Enable(); |
| aNewDlgButton.Enable(); |
| } |
| |
| // enable/disable delete button |
| if ( nDepth >= 2 && !bReadOnly && eLocation != LIBRARY_LOCATION_SHARE ) |
| { |
| if( bVBAEnabled && ( nMode & BROWSEMODE_MODULES ) && ( ( nDepth == 2 ) || aLibSubName.Equals( String( IDEResId( RID_STR_DOCUMENT_OBJECTS ) ) ) ) ) |
| aDelButton.Disable(); |
| else |
| aDelButton.Enable(); |
| } |
| else |
| aDelButton.Disable(); |
| } |
| |
| IMPL_LINK( ObjectPage, BasicBoxHighlightHdl, BasicTreeListBox *, pBox ) |
| { |
| if ( !pBox->IsSelected( pBox->GetHdlEntry() ) ) |
| return 0; |
| |
| CheckButtons(); |
| return 0; |
| } |
| |
| IMPL_LINK( ObjectPage, ButtonHdl, Button *, pButton ) |
| { |
| if ( pButton == &aEditButton ) |
| { |
| SfxAllItemSet aArgs( SFX_APP()->GetPool() ); |
| SfxRequest aRequest( SID_BASICIDE_APPEAR, SFX_CALLMODE_SYNCHRON, aArgs ); |
| SFX_APP()->ExecuteSlot( aRequest ); |
| |
| BasicIDEShell* pIDEShell = IDE_DLL()->GetShell(); |
| SfxViewFrame* pViewFrame = pIDEShell ? pIDEShell->GetViewFrame() : NULL; |
| SfxDispatcher* pDispatcher = pViewFrame ? pViewFrame->GetDispatcher() : NULL; |
| SvLBoxEntry* pCurEntry = aBasicBox.GetCurEntry(); |
| DBG_ASSERT( pCurEntry, "Entry?!" ); |
| if ( aBasicBox.GetModel()->GetDepth( pCurEntry ) >= 2 ) |
| { |
| BasicEntryDescriptor aDesc( aBasicBox.GetEntryDescriptor( pCurEntry ) ); |
| if ( pDispatcher ) |
| { |
| String aModName( aDesc.GetName() ); |
| // extract the module name from the string like "Sheet1 (Example1)" |
| if( aDesc.GetLibSubName().Equals( String( IDEResId( RID_STR_DOCUMENT_OBJECTS ) ) ) ) |
| { |
| sal_uInt16 nIndex = 0; |
| aModName = aModName.GetToken( 0, ' ', nIndex ); |
| } |
| SbxItem aSbxItem( SID_BASICIDE_ARG_SBX, aDesc.GetDocument(), aDesc.GetLibName(), |
| aModName, aBasicBox.ConvertType( aDesc.GetType() ) ); |
| pDispatcher->Execute( SID_BASICIDE_SHOWSBX, SFX_CALLMODE_SYNCHRON, &aSbxItem, 0L ); |
| } |
| } |
| else // Nur Lib selektiert |
| { |
| DBG_ASSERT( aBasicBox.GetModel()->GetDepth( pCurEntry ) == 1, "Kein LibEntry?!" ); |
| ScriptDocument aDocument( ScriptDocument::getApplicationScriptDocument() ); |
| SvLBoxEntry* pParentEntry = aBasicBox.GetParent( pCurEntry ); |
| if ( pParentEntry ) |
| { |
| BasicDocumentEntry* pBasicDocumentEntry = (BasicDocumentEntry*)pParentEntry->GetUserData(); |
| if ( pBasicDocumentEntry ) |
| aDocument = pBasicDocumentEntry->GetDocument(); |
| } |
| SfxUsrAnyItem aDocItem( SID_BASICIDE_ARG_DOCUMENT_MODEL, makeAny( aDocument.getDocumentOrNull() ) ); |
| String aLibName( aBasicBox.GetEntryText( pCurEntry ) ); |
| SfxStringItem aLibNameItem( SID_BASICIDE_ARG_LIBNAME, aLibName ); |
| if ( pDispatcher ) |
| { |
| pDispatcher->Execute( SID_BASICIDE_LIBSELECTED, SFX_CALLMODE_ASYNCHRON, &aDocItem, &aLibNameItem, 0L ); |
| } |
| } |
| EndTabDialog( 1 ); |
| } |
| else if ( pButton == &aNewModButton ) |
| NewModule(); |
| else if ( pButton == &aNewDlgButton ) |
| NewDialog(); |
| else if ( pButton == &aDelButton ) |
| DeleteCurrent(); |
| else if ( pButton == &aCloseButton ) |
| EndTabDialog( 0 ); |
| |
| return 0; |
| } |
| |
| bool ObjectPage::GetSelection( ScriptDocument& rDocument, String& rLibName ) |
| { |
| bool bRet = false; |
| |
| SvLBoxEntry* pCurEntry = aBasicBox.GetCurEntry(); |
| BasicEntryDescriptor aDesc( aBasicBox.GetEntryDescriptor( pCurEntry ) ); |
| rDocument = aDesc.GetDocument(); |
| rLibName = aDesc.GetLibName(); |
| if ( !rLibName.Len() ) |
| rLibName = String::CreateFromAscii( "Standard" ); |
| |
| DBG_ASSERT( rDocument.isAlive(), "ObjectPage::GetSelection: no or dead ScriptDocument in the selection!" ); |
| if ( !rDocument.isAlive() ) |
| return false; |
| |
| // check if the module library is loaded |
| sal_Bool bOK = sal_True; |
| ::rtl::OUString aOULibName( rLibName ); |
| Reference< script::XLibraryContainer > xModLibContainer( rDocument.getLibraryContainer( E_SCRIPTS ) ); |
| if ( xModLibContainer.is() && xModLibContainer->hasByName( aOULibName ) && !xModLibContainer->isLibraryLoaded( aOULibName ) ) |
| { |
| // check password |
| Reference< script::XLibraryContainerPassword > xPasswd( xModLibContainer, UNO_QUERY ); |
| if ( xPasswd.is() && xPasswd->isLibraryPasswordProtected( aOULibName ) && !xPasswd->isLibraryPasswordVerified( aOULibName ) ) |
| { |
| String aPassword; |
| bOK = QueryPassword( xModLibContainer, rLibName, aPassword ); |
| } |
| |
| // load library |
| if ( bOK ) |
| xModLibContainer->loadLibrary( aOULibName ); |
| } |
| |
| // check if the dialog library is loaded |
| Reference< script::XLibraryContainer > xDlgLibContainer( rDocument.getLibraryContainer( E_DIALOGS ) ); |
| if ( xDlgLibContainer.is() && xDlgLibContainer->hasByName( aOULibName ) && !xDlgLibContainer->isLibraryLoaded( aOULibName ) ) |
| { |
| // load library |
| if ( bOK ) |
| xDlgLibContainer->loadLibrary( aOULibName ); |
| } |
| |
| if ( bOK ) |
| bRet = true; |
| |
| return bRet; |
| } |
| |
| void ObjectPage::NewModule() |
| { |
| ScriptDocument aDocument( ScriptDocument::getApplicationScriptDocument() ); |
| String aLibName; |
| |
| if ( GetSelection( aDocument, aLibName ) ) |
| { |
| String aModName; |
| createModImpl( static_cast<Window*>( this ), aDocument, |
| aBasicBox, aLibName, aModName, true ); |
| } |
| } |
| |
| void ObjectPage::NewDialog() |
| { |
| ScriptDocument aDocument( ScriptDocument::getApplicationScriptDocument() ); |
| String aLibName; |
| |
| if ( GetSelection( aDocument, aLibName ) ) |
| { |
| aDocument.getOrCreateLibrary( E_DIALOGS, aLibName ); |
| |
| std::auto_ptr< NewObjectDialog > xNewDlg( |
| new NewObjectDialog(this, NEWOBJECTMODE_DLG, true)); |
| xNewDlg->SetObjectName( aDocument.createObjectName( E_DIALOGS, aLibName ) ); |
| |
| if (xNewDlg->Execute() != 0) |
| { |
| String aDlgName( xNewDlg->GetObjectName() ); |
| if (aDlgName.Len() == 0) |
| aDlgName = aDocument.createObjectName( E_DIALOGS, aLibName); |
| |
| if ( aDocument.hasDialog( aLibName, aDlgName ) ) |
| { |
| ErrorBox( this, WB_OK | WB_DEF_OK, |
| String( IDEResId( RID_STR_SBXNAMEALLREADYUSED2 ) ) ).Execute(); |
| } |
| else |
| { |
| Reference< io::XInputStreamProvider > xISP; |
| if ( !aDocument.createDialog( aLibName, aDlgName, xISP ) ) |
| return; |
| |
| SbxItem aSbxItem( SID_BASICIDE_ARG_SBX, aDocument, aLibName, aDlgName, BASICIDE_TYPE_DIALOG ); |
| BasicIDEShell* pIDEShell = IDE_DLL()->GetShell(); |
| SfxViewFrame* pViewFrame = pIDEShell ? pIDEShell->GetViewFrame() : NULL; |
| SfxDispatcher* pDispatcher = pViewFrame ? pViewFrame->GetDispatcher() : NULL; |
| if( pDispatcher ) |
| { |
| pDispatcher->Execute( SID_BASICIDE_SBXINSERTED, |
| SFX_CALLMODE_SYNCHRON, &aSbxItem, 0L ); |
| } |
| LibraryLocation eLocation = aDocument.getLibraryLocation( aLibName ); |
| SvLBoxEntry* pRootEntry = aBasicBox.FindRootEntry( aDocument, eLocation ); |
| if ( pRootEntry ) |
| { |
| if ( !aBasicBox.IsExpanded( pRootEntry ) ) |
| aBasicBox.Expand( pRootEntry ); |
| SvLBoxEntry* pLibEntry = aBasicBox.FindEntry( pRootEntry, aLibName, OBJ_TYPE_LIBRARY ); |
| DBG_ASSERT( pLibEntry, "Libeintrag nicht gefunden!" ); |
| if ( pLibEntry ) |
| { |
| if ( !aBasicBox.IsExpanded( pLibEntry ) ) |
| aBasicBox.Expand( pLibEntry ); |
| SvLBoxEntry* pEntry = aBasicBox.FindEntry( pLibEntry, aDlgName, OBJ_TYPE_DIALOG ); |
| if ( !pEntry ) |
| { |
| pEntry = aBasicBox.AddEntry( |
| aDlgName, |
| Image( IDEResId( RID_IMG_DIALOG ) ), |
| Image( IDEResId( RID_IMG_DIALOG_HC ) ), |
| pLibEntry, false, |
| std::auto_ptr< BasicEntry >( new BasicEntry( OBJ_TYPE_DIALOG ) ) ); |
| DBG_ASSERT( pEntry, "InsertEntry fehlgeschlagen!" ); |
| } |
| aBasicBox.SetCurEntry( pEntry ); |
| aBasicBox.Select( aBasicBox.GetCurEntry() ); // OV-Bug?! |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| void ObjectPage::DeleteCurrent() |
| { |
| SvLBoxEntry* pCurEntry = aBasicBox.GetCurEntry(); |
| DBG_ASSERT( pCurEntry, "Kein aktueller Eintrag!" ); |
| BasicEntryDescriptor aDesc( aBasicBox.GetEntryDescriptor( pCurEntry ) ); |
| ScriptDocument aDocument( aDesc.GetDocument() ); |
| DBG_ASSERT( aDocument.isAlive(), "ObjectPage::DeleteCurrent: no document!" ); |
| if ( !aDocument.isAlive() ) |
| return; |
| String aLibName( aDesc.GetLibName() ); |
| String aName( aDesc.GetName() ); |
| BasicEntryType eType( aDesc.GetType() ); |
| |
| if ( ( eType == OBJ_TYPE_MODULE && QueryDelModule( aName, this ) ) || |
| ( eType == OBJ_TYPE_DIALOG && QueryDelDialog( aName, this ) ) ) |
| { |
| aBasicBox.GetModel()->Remove( pCurEntry ); |
| if ( aBasicBox.GetCurEntry() ) // OV-Bug ? |
| aBasicBox.Select( aBasicBox.GetCurEntry() ); |
| BasicIDEShell* pIDEShell = IDE_DLL()->GetShell(); |
| SfxViewFrame* pViewFrame = pIDEShell ? pIDEShell->GetViewFrame() : NULL; |
| SfxDispatcher* pDispatcher = pViewFrame ? pViewFrame->GetDispatcher() : NULL; |
| if( pDispatcher ) |
| { |
| SbxItem aSbxItem( SID_BASICIDE_ARG_SBX, aDocument, aLibName, aName, aBasicBox.ConvertType( eType ) ); |
| pDispatcher->Execute( SID_BASICIDE_SBXDELETED, |
| SFX_CALLMODE_SYNCHRON, &aSbxItem, 0L ); |
| } |
| |
| try |
| { |
| bool bSuccess = false; |
| if ( eType == OBJ_TYPE_MODULE ) |
| bSuccess = aDocument.removeModule( aLibName, aName ); |
| else if ( eType == OBJ_TYPE_DIALOG ) |
| bSuccess = BasicIDE::RemoveDialog( aDocument, aLibName, aName ); |
| |
| if ( bSuccess ) |
| BasicIDE::MarkDocumentModified( aDocument ); |
| } |
| catch ( container::NoSuchElementException& ) |
| { |
| DBG_UNHANDLED_EXCEPTION(); |
| } |
| } |
| } |
| |
| |
| |
| void ObjectPage::EndTabDialog( sal_uInt16 nRet ) |
| { |
| DBG_ASSERT( pTabDlg, "TabDlg nicht gesetzt!" ); |
| if ( pTabDlg ) |
| pTabDlg->EndDialog( nRet ); |
| } |
| |
| |
| LibDialog::LibDialog( Window* pParent ) |
| : ModalDialog( pParent, IDEResId( RID_DLG_LIBS ) ), |
| aOKButton( this, IDEResId( RID_PB_OK ) ), |
| aCancelButton( this, IDEResId( RID_PB_CANCEL ) ), |
| aStorageName( this, IDEResId( RID_FT_STORAGENAME ) ), |
| aLibBox( this, IDEResId( RID_CTRL_LIBS ) ), |
| aFixedLine( this, IDEResId( RID_FL_OPTIONS ) ), |
| aReferenceBox( this, IDEResId( RID_CB_REF ) ), |
| aReplaceBox( this, IDEResId( RID_CB_REPL ) ) |
| { |
| SetText( String( IDEResId( RID_STR_APPENDLIBS ) ) ); |
| FreeResource(); |
| } |
| |
| |
| LibDialog::~LibDialog() |
| { |
| } |
| |
| void LibDialog::SetStorageName( const String& rName ) |
| { |
| String aName( IDEResId( RID_STR_FILENAME ) ); |
| aName += rName; |
| aStorageName.SetText( aName ); |
| } |
| |
| // Helper function |
| SbModule* createModImpl( Window* pWin, const ScriptDocument& rDocument, |
| BasicTreeListBox& rBasicBox, const String& rLibName, String aModName, bool bMain ) |
| { |
| OSL_ENSURE( rDocument.isAlive(), "createModImpl: invalid document!" ); |
| if ( !rDocument.isAlive() ) |
| return NULL; |
| |
| SbModule* pModule = NULL; |
| |
| String aLibName( rLibName ); |
| if ( !aLibName.Len() ) |
| aLibName = String::CreateFromAscii( "Standard" ); |
| rDocument.getOrCreateLibrary( E_SCRIPTS, aLibName ); |
| if ( !aModName.Len() ) |
| aModName = rDocument.createObjectName( E_SCRIPTS, aLibName ); |
| |
| std::auto_ptr< NewObjectDialog > xNewDlg( |
| new NewObjectDialog( pWin, NEWOBJECTMODE_MOD, true ) ); |
| xNewDlg->SetObjectName( aModName ); |
| |
| if (xNewDlg->Execute() != 0) |
| { |
| if ( xNewDlg->GetObjectName().Len() ) |
| aModName = xNewDlg->GetObjectName(); |
| |
| try |
| { |
| ::rtl::OUString sModuleCode; |
| // the module has existed |
| if( rDocument.hasModule( aLibName, aModName ) ) |
| return NULL; |
| rDocument.createModule( aLibName, aModName, bMain, sModuleCode ); |
| BasicManager* pBasMgr = rDocument.getBasicManager(); |
| StarBASIC* pBasic = pBasMgr? pBasMgr->GetLib( aLibName ) : 0; |
| if ( pBasic ) |
| pModule = pBasic->FindModule( aModName ); |
| SbxItem aSbxItem( SID_BASICIDE_ARG_SBX, rDocument, aLibName, aModName, BASICIDE_TYPE_MODULE ); |
| BasicIDEShell* pIDEShell = IDE_DLL()->GetShell(); |
| SfxViewFrame* pViewFrame = pIDEShell ? pIDEShell->GetViewFrame() : NULL; |
| SfxDispatcher* pDispatcher = pViewFrame ? pViewFrame->GetDispatcher() : NULL; |
| if( pDispatcher ) |
| { |
| pDispatcher->Execute( SID_BASICIDE_SBXINSERTED, |
| SFX_CALLMODE_SYNCHRON, &aSbxItem, 0L ); |
| } |
| LibraryLocation eLocation = rDocument.getLibraryLocation( aLibName ); |
| SvLBoxEntry* pRootEntry = rBasicBox.FindRootEntry( rDocument, eLocation ); |
| if ( pRootEntry ) |
| { |
| if ( !rBasicBox.IsExpanded( pRootEntry ) ) |
| rBasicBox.Expand( pRootEntry ); |
| SvLBoxEntry* pLibEntry = rBasicBox.FindEntry( pRootEntry, aLibName, OBJ_TYPE_LIBRARY ); |
| DBG_ASSERT( pLibEntry, "Libeintrag nicht gefunden!" ); |
| if ( pLibEntry ) |
| { |
| if ( !rBasicBox.IsExpanded( pLibEntry ) ) |
| rBasicBox.Expand( pLibEntry ); |
| SvLBoxEntry* pSubRootEntry = pLibEntry; |
| if( pBasic && rDocument.isInVBAMode() ) |
| { |
| // add the new module in the "Modules" entry |
| SvLBoxEntry* pLibSubEntry = rBasicBox.FindEntry( pLibEntry, String( IDEResId( RID_STR_NORMAL_MODULES ) ) , OBJ_TYPE_NORMAL_MODULES ); |
| if( pLibSubEntry ) |
| { |
| if( !rBasicBox.IsExpanded( pLibSubEntry ) ) |
| rBasicBox.Expand( pLibSubEntry ); |
| pSubRootEntry = pLibSubEntry; |
| } |
| } |
| |
| SvLBoxEntry* pEntry = rBasicBox.FindEntry( pSubRootEntry, aModName, OBJ_TYPE_MODULE ); |
| if ( !pEntry ) |
| { |
| pEntry = rBasicBox.AddEntry( |
| aModName, |
| Image( IDEResId( RID_IMG_MODULE ) ), |
| Image( IDEResId( RID_IMG_MODULE_HC ) ), |
| pSubRootEntry, false, |
| std::auto_ptr< BasicEntry >( new BasicEntry( OBJ_TYPE_MODULE ) ) ); |
| DBG_ASSERT( pEntry, "InsertEntry fehlgeschlagen!" ); |
| } |
| rBasicBox.SetCurEntry( pEntry ); |
| rBasicBox.Select( rBasicBox.GetCurEntry() ); // OV-Bug?! |
| } |
| } |
| } |
| catch ( container::ElementExistException& ) |
| { |
| ErrorBox( pWin, WB_OK | WB_DEF_OK, |
| String( IDEResId( RID_STR_SBXNAMEALLREADYUSED2 ) ) ).Execute(); |
| } |
| catch ( container::NoSuchElementException& ) |
| { |
| DBG_UNHANDLED_EXCEPTION(); |
| } |
| } |
| return pModule; |
| } |
| |
| |
| |
| |
