diff options
Diffstat (limited to 'basctl/source/basicide/bastypes.cxx')
-rw-r--r-- | basctl/source/basicide/bastypes.cxx | 1022 |
1 files changed, 1022 insertions, 0 deletions
diff --git a/basctl/source/basicide/bastypes.cxx b/basctl/source/basicide/bastypes.cxx new file mode 100644 index 000000000000..4b0d7564e247 --- /dev/null +++ b/basctl/source/basicide/bastypes.cxx @@ -0,0 +1,1022 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +// MARKER(update_precomp.py): autogen include statement, do not remove +#include "precompiled_basctl.hxx" + + +#include <vector> +#include <algorithm> + +#include <ide_pch.hxx> + + +#include <basic/sbx.hxx> +#include <helpid.hrc> +#include <basidesh.hrc> +#include <bastypes.hxx> +#include <bastype2.hxx> +#include <baside2.hxx> // Leider brauche ich teilweise pModulWindow... +#include <baside3.hxx> +#include <baside2.hrc> +#include <svtools/textview.hxx> +#include <svtools/texteng.hxx> +#include <basobj.hxx> +#include <sbxitem.hxx> +#include <iderdll.hxx> + +#include <sfx2/passwd.hxx> + +#include <com/sun/star/script/XLibraryContainer2.hpp> +#include <com/sun/star/script/XLibraryContainerPassword.hpp> +#include <com/sun/star/script/ModuleType.hpp> + +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star; + + +DBG_NAME( IDEBaseWindow ) + +const char* pRegName = "BasicIDETabBar"; + +TYPEINIT0( IDEBaseWindow ) +TYPEINIT1( SbxItem, SfxPoolItem ); + +IDEBaseWindow::IDEBaseWindow( Window* pParent, const ScriptDocument& rDocument, String aLibName, String aName ) + :Window( pParent, WinBits( WB_3DLOOK ) ) + ,m_aDocument( rDocument ) + ,m_aLibName( aLibName ) + ,m_aName( aName ) +{ + DBG_CTOR( IDEBaseWindow, 0 ); + pShellHScrollBar = 0; + pShellVScrollBar = 0; + nStatus = 0; +} + + + +__EXPORT IDEBaseWindow::~IDEBaseWindow() +{ + DBG_DTOR( IDEBaseWindow, 0 ); + if ( pShellVScrollBar ) + pShellVScrollBar->SetScrollHdl( Link() ); + if ( pShellHScrollBar ) + pShellHScrollBar->SetScrollHdl( Link() ); +} + + + +void IDEBaseWindow::Init() +{ + DBG_CHKTHIS( IDEBaseWindow, 0 ); + if ( pShellVScrollBar ) + pShellVScrollBar->SetScrollHdl( LINK( this, IDEBaseWindow, ScrollHdl ) ); + if ( pShellHScrollBar ) + pShellHScrollBar->SetScrollHdl( LINK( this, IDEBaseWindow, ScrollHdl ) ); + DoInit(); // virtuell... +} + + + +void __EXPORT IDEBaseWindow::DoInit() +{ +} + + + +void IDEBaseWindow::GrabScrollBars( ScrollBar* pHScroll, ScrollBar* pVScroll ) +{ + DBG_CHKTHIS( IDEBaseWindow, 0 ); + pShellHScrollBar = pHScroll; + pShellVScrollBar = pVScroll; +// Init(); // macht kein Sinn, fuehrt zu flackern, fuehr zu Fehlern... +} + + + +IMPL_LINK_INLINE_START( IDEBaseWindow, ScrollHdl, ScrollBar *, pCurScrollBar ) +{ + DBG_CHKTHIS( IDEBaseWindow, 0 ); + DoScroll( pCurScrollBar ); + return 0; +} +IMPL_LINK_INLINE_END( IDEBaseWindow, ScrollHdl, ScrollBar *, pCurScrollBar ) + + + +void __EXPORT IDEBaseWindow::ExecuteCommand( SfxRequest& ) +{ + DBG_CHKTHIS( IDEBaseWindow, 0 ); +} + + + +void __EXPORT IDEBaseWindow::GetState( SfxItemSet& ) +{ + DBG_CHKTHIS( IDEBaseWindow, 0 ); +} + + +long IDEBaseWindow::Notify( NotifyEvent& rNEvt ) +{ + long nDone = 0; + + if ( rNEvt.GetType() == EVENT_KEYINPUT ) + { + KeyEvent aKEvt = *rNEvt.GetKeyEvent(); + KeyCode aCode = aKEvt.GetKeyCode(); + USHORT nCode = aCode.GetCode(); + + switch ( nCode ) + { + case KEY_PAGEUP: + case KEY_PAGEDOWN: + { + if ( aCode.IsMod1() ) + { + BasicIDEShell* pIDEShell = IDE_DLL()->GetShell(); + if ( pIDEShell ) + pIDEShell->NextPage( nCode == KEY_PAGEUP ); + + nDone = 1; + } + } + break; + } + } + + return nDone ? nDone : Window::Notify( rNEvt ); +} + + +void __EXPORT IDEBaseWindow::DoScroll( ScrollBar* ) +{ + DBG_CHKTHIS( IDEBaseWindow, 0 ); +} + + +void __EXPORT IDEBaseWindow::StoreData() +{ +} + +BOOL __EXPORT IDEBaseWindow::CanClose() +{ + return TRUE; +} + +BOOL __EXPORT IDEBaseWindow::AllowUndo() +{ + return TRUE; +} + + + +void __EXPORT IDEBaseWindow::UpdateData() +{ +} + + +String __EXPORT IDEBaseWindow::GetTitle() +{ + return String(); +} + + + +String IDEBaseWindow::CreateQualifiedName() +{ + String aName; + if ( m_aLibName.Len() ) + { + LibraryLocation eLocation = m_aDocument.getLibraryLocation( m_aLibName ); + aName = m_aDocument.getTitle( eLocation ); + aName += '.'; + aName += m_aLibName; + aName += '.'; + aName += GetTitle(); + } + + return aName; +} + +void IDEBaseWindow::SetReadOnly( BOOL ) +{ +} + +BOOL IDEBaseWindow::IsReadOnly() +{ + return FALSE; +} + +void __EXPORT IDEBaseWindow::BasicStarted() +{ +} + +void __EXPORT IDEBaseWindow::BasicStopped() +{ +} + +BOOL __EXPORT IDEBaseWindow::IsModified() +{ + return TRUE; +} + +BOOL __EXPORT IDEBaseWindow::IsPasteAllowed() +{ + return FALSE; +} + +Window* __EXPORT IDEBaseWindow::GetLayoutWindow() +{ + return this; +} + +SfxUndoManager* __EXPORT IDEBaseWindow::GetUndoManager() +{ + return NULL; +} + +BreakPointList::BreakPointList() +{} + +BreakPointList::BreakPointList(BreakPointList const & rList): + BreakPL( sal::static_int_cast<USHORT>( rList.Count() )) +{ + for (ULONG i = 0; i < rList.Count(); ++i) + Insert(new BreakPoint(*rList.GetObject(i)), i); +} + +BreakPointList::~BreakPointList() +{ + reset(); +} + +void BreakPointList::reset() +{ + while (Count() > 0) + delete Remove(Count() - 1); +} + +void BreakPointList::transfer(BreakPointList & rList) +{ + reset(); + for (ULONG i = 0; i < rList.Count(); ++i) + Insert(rList.GetObject(i), i); + rList.Clear(); +} + +void BreakPointList::InsertSorted( BreakPoint* pNewBrk ) +{ + BreakPoint* pBrk = First(); + while ( pBrk ) + { + if ( pNewBrk->nLine <= pBrk->nLine ) + { + DBG_ASSERT( ( pBrk->nLine != pNewBrk->nLine ) || pNewBrk->bTemp, "BreakPoint existiert schon!" ); + Insert( pNewBrk ); + return; + } + pBrk = Next(); + } + // Keine Einfuegeposition gefunden => LIST_APPEND + Insert( pNewBrk, LIST_APPEND ); +} + +void BreakPointList::SetBreakPointsInBasic( SbModule* pModule ) +{ + pModule->ClearAllBP(); + + BreakPoint* pBrk = First(); + while ( pBrk ) + { + if ( pBrk->bEnabled ) + pModule->SetBP( (USHORT)pBrk->nLine ); + pBrk = Next(); + } +} + +BreakPoint* BreakPointList::FindBreakPoint( ULONG nLine ) +{ + BreakPoint* pBrk = First(); + while ( pBrk ) + { + if ( pBrk->nLine == nLine ) + return pBrk; + + pBrk = Next(); + } + + return (BreakPoint*)0; +} + + + +void BreakPointList::AdjustBreakPoints( ULONG nLine, BOOL bInserted ) +{ + BreakPoint* pBrk = First(); + while ( pBrk ) + { + BOOL bDelBrk = FALSE; + if ( pBrk->nLine == nLine ) + { + if ( bInserted ) + pBrk->nLine++; + else + bDelBrk = TRUE; + } + else if ( pBrk->nLine > nLine ) + { + if ( bInserted ) + pBrk->nLine++; + else + pBrk->nLine--; + } + + if ( bDelBrk ) + { + ULONG n = GetCurPos(); + delete Remove( pBrk ); + pBrk = Seek( n ); + } + else + { + pBrk = Next(); + } + } +} + +void BreakPointList::ResetHitCount() +{ + BreakPoint* pBrk = First(); + while ( pBrk ) + { + pBrk->nHitCount = 0; + pBrk = Next(); + } +} + +void IDEBaseWindow::Deactivating() +{ +} + +USHORT __EXPORT IDEBaseWindow::GetSearchOptions() +{ + return 0; +} + + +BasicDockingWindow::BasicDockingWindow( Window* pParent ) : + DockingWindow( pParent, WB_BORDER | WB_3DLOOK | WB_DOCKABLE | WB_MOVEABLE | + WB_SIZEABLE | WB_ROLLABLE | + WB_DOCKABLE | WB_CLIPCHILDREN ) +{ +} + + + +BOOL __EXPORT BasicDockingWindow::Docking( const Point& rPos, Rectangle& rRect ) +{ + ModulWindowLayout* pLayout = (ModulWindowLayout*)GetParent(); + Rectangle aTmpRec( rRect ); + BOOL bDock = IsDockingPrevented() ? FALSE : pLayout->IsToBeDocked( this, rPos, aTmpRec ); + if ( bDock ) + { + rRect.SetSize( aTmpRec.GetSize() ); + } + else // Alte Groesse einstellen + { + if ( !aFloatingPosAndSize.IsEmpty() ) + rRect.SetSize( aFloatingPosAndSize.GetSize() ); + } + return !bDock; // bFloat +} + + + +void __EXPORT BasicDockingWindow::EndDocking( const Rectangle& rRect, BOOL bFloatMode ) +{ + if ( bFloatMode ) + DockingWindow::EndDocking( rRect, bFloatMode ); + else + { + SetFloatingMode( FALSE ); + ModulWindowLayout* pLayout = (ModulWindowLayout*)GetParent(); + pLayout->DockaWindow( this ); + } +} + + + +void __EXPORT BasicDockingWindow::ToggleFloatingMode() +{ + ModulWindowLayout* pLayout = (ModulWindowLayout*)GetParent(); + if ( IsFloatingMode() ) + { + if ( !aFloatingPosAndSize.IsEmpty() ) + SetPosSizePixel( GetParent()->ScreenToOutputPixel( aFloatingPosAndSize.TopLeft() ), + aFloatingPosAndSize.GetSize() ); + } + pLayout->DockaWindow( this ); +} + + + +BOOL __EXPORT BasicDockingWindow::PrepareToggleFloatingMode() +{ + if ( IsFloatingMode() ) + { + // Position und Groesse auf dem Desktop merken... + aFloatingPosAndSize.SetPos( GetParent()->OutputToScreenPixel( GetPosPixel() ) ); + aFloatingPosAndSize.SetSize( GetSizePixel() ); + } + return TRUE; +} + + + +void __EXPORT BasicDockingWindow::StartDocking() +{ + // Position und Groesse auf dem Desktop merken... + if ( IsFloatingMode() ) + { + aFloatingPosAndSize.SetPos( GetParent()->OutputToScreenPixel( GetPosPixel() ) ); + aFloatingPosAndSize.SetSize( GetSizePixel() ); + } +} + + + +ExtendedEdit::ExtendedEdit( Window* pParent, IDEResId nRes ) : + Edit( pParent, nRes ) +{ + aAcc.SetSelectHdl( LINK( this, ExtendedEdit, EditAccHdl ) ); + Control::SetGetFocusHdl( LINK( this, ExtendedEdit, ImplGetFocusHdl ) ); + Control::SetLoseFocusHdl( LINK( this, ExtendedEdit, ImplLoseFocusHdl ) ); +} + +IMPL_LINK( ExtendedEdit, ImplGetFocusHdl, Control*, EMPTYARG ) +{ + Application::InsertAccel( &aAcc ); + aLoseFocusHdl.Call( this ); + return 0; +} + + +IMPL_LINK( ExtendedEdit, ImplLoseFocusHdl, Control*, EMPTYARG ) +{ + Application::RemoveAccel( &aAcc ); + return 0; +} + + +IMPL_LINK_INLINE_START( ExtendedEdit, EditAccHdl, Accelerator *, pAcc ) +{ + aAccHdl.Call( pAcc ); + return 0; +} +IMPL_LINK_INLINE_END( ExtendedEdit, EditAccHdl, Accelerator *, pAcc ) + + + +struct TabBarDDInfo +{ + ULONG npTabBar; + USHORT nPage; + + TabBarDDInfo() { npTabBar = 0; nPage = 0; } + TabBarDDInfo( ULONG _npTabBar, USHORT _nPage ) { npTabBar = _npTabBar; nPage = _nPage; } +}; + + +BasicIDETabBar::BasicIDETabBar( Window* pParent ) : + TabBar( pParent, WinBits( WB_3DLOOK | WB_SCROLL | WB_BORDER | WB_SIZEABLE | WB_DRAG ) ) +{ + EnableEditMode( TRUE ); + + SetHelpId( HID_BASICIDE_TABBAR ); +} + +void __EXPORT BasicIDETabBar::MouseButtonDown( const MouseEvent& rMEvt ) +{ + if ( rMEvt.IsLeft() && ( rMEvt.GetClicks() == 2 ) && !IsInEditMode() ) + { + BasicIDEShell* pIDEShell = IDE_DLL()->GetShell(); + SfxViewFrame* pViewFrame = pIDEShell ? pIDEShell->GetViewFrame() : NULL; + SfxDispatcher* pDispatcher = pViewFrame ? pViewFrame->GetDispatcher() : NULL; + if( pDispatcher ) + { + pDispatcher->Execute( SID_BASICIDE_MODULEDLG ); + } + } + else + { + TabBar::MouseButtonDown( rMEvt ); + } +} + +void __EXPORT BasicIDETabBar::Command( const CommandEvent& rCEvt ) +{ + if ( ( rCEvt.GetCommand() == COMMAND_CONTEXTMENU ) && !IsInEditMode() ) + { + Point aPos( rCEvt.IsMouseEvent() ? rCEvt.GetMousePosPixel() : Point(1,1) ); + if ( rCEvt.IsMouseEvent() ) // Richtige Tab selektieren + { + Point aP = PixelToLogic( aPos ); + MouseEvent aMouseEvent( aP, 1, MOUSE_SIMPLECLICK, MOUSE_LEFT ); + TabBar::MouseButtonDown( aMouseEvent ); + } + + PopupMenu aPopup( IDEResId( RID_POPUP_TABBAR ) ); + if ( GetPageCount() == 0 ) + { + aPopup.EnableItem( SID_BASICIDE_DELETECURRENT, FALSE ); + aPopup.EnableItem( SID_BASICIDE_RENAMECURRENT, FALSE ); + aPopup.EnableItem( SID_BASICIDE_HIDECURPAGE, FALSE ); + } + + if ( StarBASIC::IsRunning() ) + { + aPopup.EnableItem(SID_BASICIDE_DELETECURRENT, false); + aPopup.EnableItem( SID_BASICIDE_RENAMECURRENT, false); + aPopup.EnableItem(SID_BASICIDE_MODULEDLG, false); + } + + BasicIDEShell* pIDEShell = IDE_DLL()->GetShell(); + if ( pIDEShell ) + { + ScriptDocument aDocument( pIDEShell->GetCurDocument() ); + ::rtl::OUString aOULibName( pIDEShell->GetCurLibName() ); + 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 ) ) ) + { + aPopup.EnableItem( aPopup.GetItemId( 0 ), FALSE ); + aPopup.EnableItem( SID_BASICIDE_DELETECURRENT, FALSE ); + aPopup.EnableItem( SID_BASICIDE_RENAMECURRENT, FALSE ); + aPopup.RemoveDisabledEntries(); + } + if ( aDocument.isInVBAMode() ) + { + // disable to delete or remove object modules in IDE + BasicManager* pBasMgr = aDocument.getBasicManager(); + if ( pBasMgr ) + { + StarBASIC* pBasic = pBasMgr->GetLib( aOULibName ); + if( pBasic ) + { + IDEWindowTable& aIDEWindowTable = pIDEShell->GetIDEWindowTable(); + IDEBaseWindow* pWin = aIDEWindowTable.Get( GetCurPageId() ); + if( pWin && pWin->ISA( ModulWindow ) ) + { + SbModule* pActiveModule = (SbModule*)pBasic->FindModule( pWin->GetName() ); + if( pActiveModule && ( pActiveModule->GetModuleType() == script::ModuleType::DOCUMENT ) ) + { + aPopup.EnableItem( SID_BASICIDE_DELETECURRENT, FALSE ); + aPopup.EnableItem( SID_BASICIDE_RENAMECURRENT, FALSE ); + } + } + } + } + } + } + + + SfxViewFrame* pViewFrame = pIDEShell ? pIDEShell->GetViewFrame() : NULL; + SfxDispatcher* pDispatcher = pViewFrame ? pViewFrame->GetDispatcher() : NULL; + if ( pDispatcher ) + pDispatcher->Execute( aPopup.Execute( this, aPos ) ); + } +} + +long BasicIDETabBar::AllowRenaming() +{ + BOOL bValid = BasicIDE::IsValidSbxName( GetEditText() ); + + if ( !bValid ) + ErrorBox( this, WB_OK | WB_DEF_OK, String( IDEResId( RID_STR_BADSBXNAME ) ) ).Execute(); + + return bValid ? TABBAR_RENAMING_YES : TABBAR_RENAMING_NO; +} + + +void __EXPORT BasicIDETabBar::EndRenaming() +{ + if ( !IsEditModeCanceled() ) + { + SfxUInt16Item aID( SID_BASICIDE_ARG_TABID, GetEditPageId() ); + SfxStringItem aNewName( SID_BASICIDE_ARG_MODULENAME, GetEditText() ); + BasicIDEShell* pIDEShell = IDE_DLL()->GetShell(); + SfxViewFrame* pViewFrame = pIDEShell ? pIDEShell->GetViewFrame() : NULL; + SfxDispatcher* pDispatcher = pViewFrame ? pViewFrame->GetDispatcher() : NULL; + if( pDispatcher ) + { + pDispatcher->Execute( SID_BASICIDE_NAMECHANGEDONTAB, + SFX_CALLMODE_SYNCHRON, &aID, &aNewName, 0L ); + } + } +} + + +void BasicIDETabBar::Sort() +{ + BasicIDEShell* pIDEShell = IDE_DLL()->GetShell(); + if ( pIDEShell ) + { + IDEWindowTable& aIDEWindowTable = pIDEShell->GetIDEWindowTable(); + TabBarSortHelper aTabBarSortHelper; + ::std::vector<TabBarSortHelper> aModuleList; + ::std::vector<TabBarSortHelper> aDialogList; + USHORT nPageCount = GetPageCount(); + USHORT i; + + // create module and dialog lists for sorting + for ( i = 0; i < nPageCount; i++) + { + USHORT nId = GetPageId( i ); + aTabBarSortHelper.nPageId = nId; + aTabBarSortHelper.aPageText = GetPageText( nId ); + IDEBaseWindow* pWin = aIDEWindowTable.Get( nId ); + + if ( pWin->IsA( TYPE( ModulWindow ) ) ) + { + aModuleList.push_back( aTabBarSortHelper ); + } + else if ( pWin->IsA( TYPE( DialogWindow ) ) ) + { + aDialogList.push_back( aTabBarSortHelper ); + } + } + + // sort module and dialog lists by page text + ::std::sort( aModuleList.begin() , aModuleList.end() ); + ::std::sort( aDialogList.begin() , aDialogList.end() ); + + + USHORT nModules = sal::static_int_cast<USHORT>( aModuleList.size() ); + USHORT nDialogs = sal::static_int_cast<USHORT>( aDialogList.size() ); + + // move module pages to new positions + for (i = 0; i < nModules; i++) + { + MovePage( aModuleList[i].nPageId , i ); + } + + // move dialog pages to new positions + for (i = 0; i < nDialogs; i++) + { + MovePage( aDialogList[i].nPageId , nModules + i ); + } + } +} + +void CutLines( ::rtl::OUString& rStr, sal_Int32 nStartLine, sal_Int32 nLines, BOOL bEraseTrailingEmptyLines ) +{ + sal_Int32 nStartPos = 0; + sal_Int32 nEndPos = 0; + sal_Int32 nLine = 0; + while ( nLine < nStartLine ) + { + nStartPos = searchEOL( rStr, nStartPos ); + if( nStartPos == -1 ) + break; + nStartPos++; // nicht das \n. + nLine++; + } + + DBG_ASSERTWARNING( nStartPos != -1, "CutLines: Startzeile nicht gefunden!" ); + + if ( nStartPos != -1 ) + { + nEndPos = nStartPos; + for ( sal_Int32 i = 0; i < nLines; i++ ) + nEndPos = searchEOL( rStr, nEndPos+1 ); + + if ( nEndPos == -1 ) // kann bei letzter Zeile passieren + nEndPos = rStr.getLength(); + else + nEndPos++; + + ::rtl::OUString aEndStr = rStr.copy( nEndPos ); + rStr = rStr.copy( 0, nStartPos ); + rStr += aEndStr; + } + if ( bEraseTrailingEmptyLines ) + { + sal_Int32 n = nStartPos; + sal_Int32 nLen = rStr.getLength(); + while ( ( n < nLen ) && ( rStr.getStr()[ n ] == LINE_SEP || + rStr.getStr()[ n ] == LINE_SEP_CR ) ) + { + n++; + } + + if ( n > nStartPos ) + { + ::rtl::OUString aEndStr = rStr.copy( n ); + rStr = rStr.copy( 0, nStartPos ); + rStr += aEndStr; + } + } +} + +ULONG CalcLineCount( SvStream& rStream ) +{ + ULONG nLFs = 0; + ULONG nCRs = 0; + char c; + + rStream.Seek( 0 ); + rStream >> c; + while ( !rStream.IsEof() ) + { + if ( c == '\n' ) + nLFs++; + else if ( c == '\r' ) + nCRs++; + rStream >> c; + } + + rStream.Seek( 0 ); + if ( nLFs > nCRs ) + return nLFs; + return nCRs; +} + +LibInfoKey::LibInfoKey( const ScriptDocument& rDocument, const String& rLibName ) + :m_aDocument( rDocument ) + ,m_aLibName( rLibName ) +{ +} + +LibInfoKey::~LibInfoKey() +{ +} + +LibInfoKey::LibInfoKey( const LibInfoKey& rKey ) + :m_aDocument( rKey.m_aDocument ) + ,m_aLibName( rKey.m_aLibName ) +{ +} + +LibInfoKey& LibInfoKey::operator=( const LibInfoKey& rKey ) +{ + m_aDocument = rKey.m_aDocument; + m_aLibName = rKey.m_aLibName; + return *this; +} + +bool LibInfoKey::operator==( const LibInfoKey& rKey ) const +{ + bool bRet = false; + if ( m_aDocument == rKey.m_aDocument && m_aLibName == rKey.m_aLibName ) + bRet = true; + return bRet; +} + +LibInfoItem::LibInfoItem( const ScriptDocument& rDocument, const String& rLibName, const String& rCurrentName, USHORT nCurrentType ) + :m_aDocument( rDocument ) + ,m_aLibName( rLibName ) + ,m_aCurrentName( rCurrentName ) + ,m_nCurrentType( nCurrentType ) +{ +} + +LibInfoItem::~LibInfoItem() +{ +} + +LibInfoItem::LibInfoItem( const LibInfoItem& rItem ) + :m_aDocument( rItem.m_aDocument ) + ,m_aLibName( rItem.m_aLibName ) + ,m_aCurrentName( rItem.m_aCurrentName ) + ,m_nCurrentType( rItem.m_nCurrentType ) +{ +} + +LibInfoItem& LibInfoItem::operator=( const LibInfoItem& rItem ) +{ + m_aDocument = rItem.m_aDocument; + m_aLibName = rItem.m_aLibName; + m_aCurrentName = rItem.m_aCurrentName; + m_nCurrentType = rItem.m_nCurrentType; + + return *this; +} + +LibInfos::LibInfos() +{ +} + +LibInfos::~LibInfos() +{ + LibInfoMap::iterator end = m_aLibInfoMap.end(); + for ( LibInfoMap::iterator it = m_aLibInfoMap.begin(); it != end; ++it ) + delete it->second; + m_aLibInfoMap.clear(); +} + +void LibInfos::InsertInfo( LibInfoItem* pItem ) +{ + LibInfoKey aKey( pItem->GetDocument(), pItem->GetLibName() ); + LibInfoMap::iterator it = m_aLibInfoMap.find( aKey ); + if ( it != m_aLibInfoMap.end() ) + { + LibInfoItem* pI = it->second; + m_aLibInfoMap.erase( it ); + delete pI; + } + m_aLibInfoMap.insert( LibInfoMap::value_type( aKey, pItem ) ); +} + +void LibInfos::RemoveInfoFor( const ScriptDocument& _rDocument ) +{ + for ( LibInfoMap::iterator it = m_aLibInfoMap.begin(); + it != m_aLibInfoMap.end(); + ) + { + if ( it->first.GetDocument() != _rDocument ) + { + ++it; + continue; + } + + LibInfoItem* pItem = it->second; + + LibInfoMap::iterator next_it = it; ++next_it; + m_aLibInfoMap.erase( it ); + it = next_it; + + delete pItem; + } +} + +LibInfoItem* LibInfos::GetInfo( const LibInfoKey& rKey ) +{ + LibInfoItem* pItem = 0; + LibInfoMap::iterator it = m_aLibInfoMap.find( rKey ); + if ( it != m_aLibInfoMap.end() ) + pItem = it->second; + return pItem; +} + +SbxItem::SbxItem(USHORT nWhich_, const ScriptDocument& rDocument, const String& aLibName, const String& aName, USHORT nType ) + :SfxPoolItem( nWhich_ ) + ,m_aDocument(rDocument) + ,m_aLibName(aLibName) + ,m_aName(aName) + ,m_nType(nType) +{ +} + +SbxItem::SbxItem(USHORT nWhich_, const ScriptDocument& rDocument, const String& aLibName, const String& aName, const String& aMethodName, USHORT nType ) + :SfxPoolItem( nWhich_ ) + ,m_aDocument(rDocument) + ,m_aLibName(aLibName) + ,m_aName(aName) + ,m_aMethodName(aMethodName) + ,m_nType(nType) +{ +} + +SbxItem::SbxItem(const SbxItem& rCopy) + :SfxPoolItem( rCopy ) + ,m_aDocument( rCopy.m_aDocument ) +{ + m_aLibName = rCopy.m_aLibName; + m_aName = rCopy.m_aName; + m_aMethodName = rCopy.m_aMethodName; + m_nType = rCopy.m_nType; +} + +int SbxItem::operator==( const SfxPoolItem& rCmp) const +{ + DBG_ASSERT( rCmp.ISA( SbxItem ), "==: Kein SbxItem!" ); + return ( SfxPoolItem::operator==( rCmp ) && ( m_aDocument == ((const SbxItem&)rCmp).m_aDocument ) + && ( m_aLibName == ((const SbxItem&)rCmp).m_aLibName ) + && ( m_aName == ((const SbxItem&)rCmp).m_aName ) + && ( m_aMethodName == ((const SbxItem&)rCmp).m_aMethodName ) + && ( m_nType == ((const SbxItem&)rCmp).m_nType ) ); +} + +SfxPoolItem *SbxItem::Clone( SfxItemPool* ) const +{ + return new SbxItem(*this); +} + +BOOL QueryDel( const String& rName, const ResId& rId, Window* pParent ) +{ + String aQuery( rId ); + String aName( rName ); + aName += '\''; + aName.Insert( '\'', 0 ); + aQuery.SearchAndReplace( String( RTL_CONSTASCII_USTRINGPARAM( "XX" ) ), aName ); + QueryBox aQueryBox( pParent, WB_YES_NO | WB_DEF_YES, aQuery ); + if ( aQueryBox.Execute() == RET_YES ) + return TRUE; + return FALSE; +} + +BOOL QueryDelMacro( const String& rName, Window* pParent ) +{ + return QueryDel( rName, IDEResId( RID_STR_QUERYDELMACRO ), pParent ); +} + +BOOL QueryReplaceMacro( const String& rName, Window* pParent ) +{ + return QueryDel( rName, IDEResId( RID_STR_QUERYREPLACEMACRO ), pParent ); +} + +BOOL QueryDelDialog( const String& rName, Window* pParent ) +{ + return QueryDel( rName, IDEResId( RID_STR_QUERYDELDIALOG ), pParent ); +} + +BOOL QueryDelLib( const String& rName, BOOL bRef, Window* pParent ) +{ + return QueryDel( rName, IDEResId( bRef ? RID_STR_QUERYDELLIBREF : RID_STR_QUERYDELLIB ), pParent ); +} + +BOOL QueryDelModule( const String& rName, Window* pParent ) +{ + return QueryDel( rName, IDEResId( RID_STR_QUERYDELMODULE ), pParent ); +} + +BOOL QueryPassword( const Reference< script::XLibraryContainer >& xLibContainer, const String& rLibName, String& rPassword, BOOL bRepeat, BOOL bNewTitle ) +{ + BOOL bOK = FALSE; + USHORT nRet = 0; + + do + { + // password dialog + SfxPasswordDialog* pDlg = new SfxPasswordDialog( Application::GetDefDialogParent() ); + pDlg->SetMinLen( 1 ); + + // set new title + if ( bNewTitle ) + { + String aTitle( IDEResId( RID_STR_ENTERPASSWORD ) ); + aTitle.SearchAndReplace( String( RTL_CONSTASCII_USTRINGPARAM( "XX" ) ), rLibName ); + pDlg->SetText( aTitle ); + } + + // execute dialog + nRet = pDlg->Execute(); + + // verify password + if ( nRet == RET_OK ) + { + ::rtl::OUString aOULibName( rLibName ); + if ( xLibContainer.is() && xLibContainer->hasByName( aOULibName ) ) + { + Reference< script::XLibraryContainerPassword > xPasswd( xLibContainer, UNO_QUERY ); + if ( xPasswd.is() && xPasswd->isLibraryPasswordProtected( aOULibName ) && !xPasswd->isLibraryPasswordVerified( aOULibName ) ) + { + rPassword = pDlg->GetPassword(); + ::rtl::OUString aOUPassword( rPassword ); + bOK = xPasswd->verifyLibraryPassword( aOULibName, aOUPassword ); + + if ( !bOK ) + { + ErrorBox aErrorBox( Application::GetDefDialogParent(), WB_OK, String( IDEResId( RID_STR_WRONGPASSWORD ) ) ); + aErrorBox.Execute(); + } + } + } + } + + delete pDlg; + } + while ( bRepeat && !bOK && nRet == RET_OK ); + + return bOK; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ |