/************************************************************** * * 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 #include #include #include #include #include #include #include #include #include #include #ifndef _COM_SUN_STAR_SCRIPT_XLIBRYARYCONTAINER2_HPP_ #include #endif #include #include #include #include #include #include #include #include #include #include #include #include #include #include //#ifndef _TXTCMP_HXX //autogen //#include //#endif #include #include using namespace ::com::sun::star; using namespace ::com::sun::star::uno; #define SPLIT_MARGIN 5 #define SPLIT_HEIGHT 2 #define LMARGPRN 1700 #define RMARGPRN 900 #define TMARGPRN 2000 #define BMARGPRN 1000 #define BORDERPRN 300 #define APPWAIT_START 100 #define VALIDWINDOW 0x1234 #if defined(OW) || defined(MTF) #define FILTERMASK_ALL "*" #elif defined(PM2) #define FILTERMASK_ALL "" #else #define FILTERMASK_ALL "*.*" #endif using namespace ::com::sun::star; using namespace ::com::sun::star::uno; using namespace ::com::sun::star::ui::dialogs; using namespace utl; using namespace comphelper; DBG_NAME( ModulWindow ) TYPEINIT1( ModulWindow , IDEBaseWindow ); void lcl_PrintHeader( Printer* pPrinter, sal_uInt16 nPages, sal_uInt16 nCurPage, const String& rTitle, bool bOutput ) { short nLeftMargin = LMARGPRN; Size aSz = pPrinter->GetOutputSize(); short nBorder = BORDERPRN; const Color aOldLineColor( pPrinter->GetLineColor() ); const Color aOldFillColor( pPrinter->GetFillColor() ); const Font aOldFont( pPrinter->GetFont() ); pPrinter->SetLineColor( Color( COL_BLACK ) ); pPrinter->SetFillColor(); Font aFont( aOldFont ); aFont.SetWeight( WEIGHT_BOLD ); aFont.SetAlign( ALIGN_BOTTOM ); pPrinter->SetFont( aFont ); long nFontHeight = pPrinter->GetTextHeight(); // 1.Border => Strich, 2+3 Border = Freiraum. long nYTop = TMARGPRN-3*nBorder-nFontHeight; long nXLeft = nLeftMargin-nBorder; long nXRight = aSz.Width()-RMARGPRN+nBorder; if( bOutput ) pPrinter->DrawRect( Rectangle( Point( nXLeft, nYTop ), Size( nXRight-nXLeft, aSz.Height() - nYTop - BMARGPRN + nBorder ) ) ); long nY = TMARGPRN-2*nBorder; Point aPos( nLeftMargin, nY ); if( bOutput ) pPrinter->DrawText( aPos, rTitle ); if ( nPages != 1 ) { aFont.SetWeight( WEIGHT_NORMAL ); pPrinter->SetFont( aFont ); String aPageStr( RTL_CONSTASCII_USTRINGPARAM( " [" ) ); aPageStr += String( IDEResId( RID_STR_PAGE ) ); aPageStr += ' '; aPageStr += String::CreateFromInt32( nCurPage ); aPageStr += ']'; aPos.X() += pPrinter->GetTextWidth( rTitle ); if( bOutput ) pPrinter->DrawText( aPos, aPageStr ); } nY = TMARGPRN-nBorder; if( bOutput ) pPrinter->DrawLine( Point( nXLeft, nY ), Point( nXRight, nY ) ); pPrinter->SetFont( aOldFont ); pPrinter->SetFillColor( aOldFillColor ); pPrinter->SetLineColor( aOldLineColor ); } void lcl_ConvertTabsToSpaces( String& rLine ) { if ( rLine.Len() ) { sal_uInt16 nPos = 0; sal_uInt16 nMax = rLine.Len(); while ( nPos < nMax ) { if ( rLine.GetChar( nPos ) == '\t' ) { // Nicht 4 Blanks, sondern an 4er TabPos: String aBlanker; aBlanker.Fill( ( 4 - ( nPos % 4 ) ), ' ' ); rLine.Erase( nPos, 1 ); rLine.Insert( aBlanker, nPos ); nMax = rLine.Len(); } nPos++; // Nicht optimal, falls Tab, aber auch nicht verkehrt... } } } ModulWindow::ModulWindow( ModulWindowLayout* pParent, const ScriptDocument& rDocument, String aLibName, String aName, ::rtl::OUString& aModule ) :IDEBaseWindow( pParent, rDocument, aLibName, aName ) ,aXEditorWindow( this ) ,m_aModule( aModule ) { DBG_CTOR( ModulWindow, 0 ); nValid = VALIDWINDOW; pLayout = pParent; aXEditorWindow.Show(); SetBackground(); } SbModuleRef ModulWindow::XModule() { // ModuleWindows can now be created as a result of the // modules getting created via the api. This is a result of an // elementInserted event from the BasicLibrary container. // However the SbModule is also created from a different listener to // the same event ( in basmgr ) Therefore it is possible when we look // for xModule it may not yet be available, here we keep trying to access // the module until such time as it exists if ( !xModule.Is() ) { BasicManager* pBasMgr = GetDocument().getBasicManager(); if ( pBasMgr ) { StarBASIC* pBasic = pBasMgr->GetLib( GetLibName() ); if ( pBasic ) { xBasic = pBasic; xModule = (SbModule*)pBasic->FindModule( GetName() ); } } } return xModule; } __EXPORT ModulWindow::~ModulWindow() { DBG_DTOR( ModulWindow, 0 ); nValid = 0; StarBASIC::Stop(); } void __EXPORT ModulWindow::GetFocus() { if ( nValid != VALIDWINDOW ) return; DBG_CHKTHIS( ModulWindow, 0 ); aXEditorWindow.GetEdtWindow().GrabFocus(); // Basisklasse nicht rufen, weil Focus jetzt woanders... } void ModulWindow::DoInit() { DBG_CHKTHIS( ModulWindow, 0 ); // Wird beim Umschalten der Fenster gerufen... if ( GetVScrollBar() ) GetVScrollBar()->Hide(); GetHScrollBar()->Show(); // GetEditorWindow().SetScrollBarRanges(); GetEditorWindow().InitScrollBars(); // GetEditorWindow().GrabFocus(); } void __EXPORT ModulWindow::Paint( const Rectangle& ) { } void __EXPORT ModulWindow::Resize() { aXEditorWindow.SetPosSizePixel( Point( 0, 0 ), Size( GetOutputSizePixel() ) ); } // "Import" von baside4.cxx void CreateEngineForBasic( StarBASIC* pBasic ); void ModulWindow::CheckCompileBasic() { DBG_CHKTHIS( ModulWindow, 0 ); if ( XModule().Is() ) { // Zur Laufzeit wird niemals compiliert! sal_Bool bRunning = StarBASIC::IsRunning(); sal_Bool bModified = ( !xModule->IsCompiled() || ( GetEditEngine() && GetEditEngine()->IsModified() ) ); if ( !bRunning && bModified ) { sal_Bool bDone = sal_False; BasicIDEShell* pIDEShell = IDE_DLL()->GetShell(); pIDEShell->GetViewFrame()->GetWindow().EnterWait(); if( bModified ) { AssertValidEditEngine(); GetEditorWindow().SetSourceInBasic( sal_False ); } sal_Bool bWasModified = GetBasic()->IsModified(); bDone = GetBasic()->Compile( xModule ); if ( !bWasModified ) GetBasic()->SetModified( sal_False ); if ( bDone ) { GetBreakPoints().SetBreakPointsInBasic( xModule ); } pIDEShell->GetViewFrame()->GetWindow().LeaveWait(); aStatus.bError = !bDone; aStatus.bIsRunning = sal_False; } } } sal_Bool ModulWindow::BasicExecute() { DBG_CHKTHIS( ModulWindow, 0 ); // #116444# check security settings before macro execution ScriptDocument aDocument( GetDocument() ); if ( aDocument.isDocument() ) { if ( !aDocument.allowMacros() ) { WarningBox( this, WB_OK, String( IDEResId( RID_STR_CANNOTRUNMACRO ) ) ).Execute(); return sal_False; } } CheckCompileBasic(); if ( XModule().Is() && xModule->IsCompiled() && !aStatus.bError ) { if ( GetBreakPoints().Count() ) aStatus.nBasicFlags = aStatus.nBasicFlags | SbDEBUG_BREAK; if ( !aStatus.bIsRunning ) { DBG_ASSERT( xModule.Is(), "Kein Modul!" ); AddStatus( BASWIN_RUNNINGBASIC ); sal_uInt16 nStart, nEnd, nCurMethodStart = 0; TextSelection aSel = GetEditView()->GetSelection(); if ( aDocument.isInVBAMode() ) nCurMethodStart = ( aSel.GetStart().GetPara() + 1 ); SbMethod* pMethod = 0; // erstes Macro, sonst blind "Main" (ExtSearch?) for ( sal_uInt16 nMacro = 0; nMacro < xModule->GetMethods()->Count(); nMacro++ ) { SbMethod* pM = (SbMethod*)xModule->GetMethods()->Get( nMacro ); DBG_ASSERT( pM, "Method?" ); pM->GetLineRange( nStart, nEnd ); if ( aDocument.isInVBAMode() ) { if ( nCurMethodStart >= nStart && nCurMethodStart <= nEnd ) { pMethod = pM; break; } } else if ( !pMethod || ( nStart < nCurMethodStart && !pM->IsHidden() ) ) { pMethod = pM; nCurMethodStart = nStart; } } if ( !pMethod ) { if ( aDocument.isInVBAMode() ) return ( BasicIDE::ChooseMacro( uno::Reference< frame::XModel >(), sal_False, rtl::OUString() ).isEmpty() == false ) ? sal_True : sal_False; else pMethod = (SbMethod*)xModule->Find( String( RTL_CONSTASCII_USTRINGPARAM( "Main" ) ), SbxCLASS_METHOD ); } if ( pMethod ) { pMethod->SetDebugFlags( aStatus.nBasicFlags ); BasicDLL::SetDebugMode( sal_True ); BasicIDE::RunMethod( pMethod ); BasicDLL::SetDebugMode( sal_False ); // Falls waehrend Interactive=sal_False abgebrochen BasicDLL::EnableBreak( sal_True ); } ClearStatus( BASWIN_RUNNINGBASIC ); } else aStatus.bIsRunning = sal_False; // Abbruch von Reschedule() } sal_Bool bDone = !aStatus.bError; return bDone; } sal_Bool ModulWindow::CompileBasic() { DBG_CHKTHIS( ModulWindow, 0 ); CheckCompileBasic(); sal_Bool bIsCompiled = sal_False; if ( XModule().Is() ) bIsCompiled = xModule->IsCompiled(); return bIsCompiled; } sal_Bool ModulWindow::BasicRun() { DBG_CHKTHIS( ModulWindow, 0 ); aStatus.nBasicFlags = 0; sal_Bool bDone = BasicExecute(); return bDone; } sal_Bool ModulWindow::BasicStepOver() { DBG_CHKTHIS( ModulWindow, 0 ); aStatus.nBasicFlags = SbDEBUG_STEPINTO | SbDEBUG_STEPOVER; sal_Bool bDone = BasicExecute(); return bDone; } sal_Bool ModulWindow::BasicStepInto() { DBG_CHKTHIS( ModulWindow, 0 ); aStatus.nBasicFlags = SbDEBUG_STEPINTO; sal_Bool bDone = BasicExecute(); return bDone; } sal_Bool ModulWindow::BasicStepOut() { DBG_CHKTHIS( ModulWindow, 0 ); aStatus.nBasicFlags = SbDEBUG_STEPOUT; sal_Bool bDone = BasicExecute(); return bDone; } void ModulWindow::BasicStop() { DBG_CHKTHIS( ModulWindow, 0 ); GetBasic()->Stop(); aStatus.bIsRunning = sal_False; } sal_Bool ModulWindow::LoadBasic() { DBG_CHKTHIS( ModulWindow, 0 ); sal_Bool bDone = sal_False; Reference< lang::XMultiServiceFactory > xMSF( ::comphelper::getProcessServiceFactory() ); Reference < XFilePicker > xFP; if( xMSF.is() ) { Sequence aServiceType(1); aServiceType[0] <<= TemplateDescription::FILEOPEN_SIMPLE; xFP = Reference< XFilePicker >( xMSF->createInstanceWithArguments( ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.ui.dialogs.FilePicker" ) ), aServiceType ), UNO_QUERY ); } if ( aCurPath.Len() ) xFP->setDisplayDirectory ( aCurPath ); //xFP->setTitle( String( IDEResId( RID_STR_OPEN ) ) ); Reference< XFilterManager > xFltMgr(xFP, UNO_QUERY); xFltMgr->appendFilter( String( RTL_CONSTASCII_USTRINGPARAM( "BASIC" ) ), String( RTL_CONSTASCII_USTRINGPARAM( "*.bas" ) ) ); xFltMgr->appendFilter( String( IDEResId( RID_STR_FILTER_ALLFILES ) ), String( RTL_CONSTASCII_USTRINGPARAM( FILTERMASK_ALL ) ) ); xFltMgr->setCurrentFilter( String( RTL_CONSTASCII_USTRINGPARAM( "BASIC" ) ) ); if( xFP->execute() == RET_OK ) { Sequence< ::rtl::OUString > aPaths = xFP->getFiles(); aCurPath = aPaths[0]; SfxMedium aMedium( aCurPath, STREAM_READ | STREAM_SHARE_DENYWRITE | STREAM_NOCREATE, sal_True ); SvStream* pStream = aMedium.GetInStream(); if ( pStream ) { AssertValidEditEngine(); sal_uLong nLines = CalcLineCount( *pStream ); // nLines*4: ReadText/Formatting/Highlighting/Formatting GetEditorWindow().CreateProgress( String( IDEResId( RID_STR_GENERATESOURCE ) ), nLines*4 ); GetEditEngine()->SetUpdateMode( sal_False ); GetEditView()->Read( *pStream ); GetEditEngine()->SetUpdateMode( sal_True ); GetEditorWindow().Update(); // Es wurde bei UpdateMode = sal_True nur Invalidiert GetEditorWindow().ForceSyntaxTimeout(); GetEditorWindow().DestroyProgress(); sal_uLong nError = aMedium.GetError(); if ( nError ) ErrorHandler::HandleError( nError ); else bDone = sal_True; } else ErrorBox( this, WB_OK | WB_DEF_OK, String( IDEResId( RID_STR_COULDNTREAD ) ) ).Execute(); } return bDone; } sal_Bool ModulWindow::SaveBasicSource() { DBG_CHKTHIS( ModulWindow, 0 ); sal_Bool bDone = sal_False; Reference< lang::XMultiServiceFactory > xMSF( ::comphelper::getProcessServiceFactory() ); Reference < XFilePicker > xFP; if( xMSF.is() ) { Sequence aServiceType(1); aServiceType[0] <<= TemplateDescription::FILESAVE_AUTOEXTENSION_PASSWORD; xFP = Reference< XFilePicker >( xMSF->createInstanceWithArguments( ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.ui.dialogs.FilePicker" ) ), aServiceType ), UNO_QUERY ); } Reference< XFilePickerControlAccess > xFPControl(xFP, UNO_QUERY); xFPControl->enableControl(ExtendedFilePickerElementIds::CHECKBOX_PASSWORD, sal_False); Any aValue; aValue <<= (sal_Bool) sal_True; xFPControl->setValue(ExtendedFilePickerElementIds::CHECKBOX_AUTOEXTENSION, 0, aValue); if ( aCurPath.Len() ) xFP->setDisplayDirectory ( aCurPath ); //xFP->setTitle( String( IDEResId( RID_STR_SAVE ) ) ); Reference< XFilterManager > xFltMgr(xFP, UNO_QUERY); xFltMgr->appendFilter( String( RTL_CONSTASCII_USTRINGPARAM( "BASIC" ) ), String( RTL_CONSTASCII_USTRINGPARAM( "*.bas" ) ) ); xFltMgr->appendFilter( String( IDEResId( RID_STR_FILTER_ALLFILES ) ), String( RTL_CONSTASCII_USTRINGPARAM( FILTERMASK_ALL ) ) ); xFltMgr->setCurrentFilter( String( RTL_CONSTASCII_USTRINGPARAM( "BASIC" ) ) ); if( xFP->execute() == RET_OK ) { Sequence< ::rtl::OUString > aPaths = xFP->getFiles(); aCurPath = aPaths[0]; SfxMedium aMedium( aCurPath, STREAM_WRITE | STREAM_SHARE_DENYWRITE | STREAM_TRUNC, sal_True, NULL ); SvStream* pStream = aMedium.GetOutStream(); if ( pStream ) { EnterWait(); AssertValidEditEngine(); GetEditEngine()->Write( *pStream ); aMedium.Commit(); LeaveWait(); sal_uLong nError = aMedium.GetError(); if ( nError ) ErrorHandler::HandleError( nError ); else bDone = sal_True; } else ErrorBox( this, WB_OK | WB_DEF_OK, String( IDEResId( RID_STR_COULDNTWRITE) ) ).Execute(); } return bDone; } sal_Bool implImportDialog( Window* pWin, const String& rCurPath, const ScriptDocument& rDocument, const String& aLibName ); sal_Bool ModulWindow::ImportDialog() { const ScriptDocument& rDocument = GetDocument(); String aLibName = GetLibName(); sal_Bool bRet = implImportDialog( this, aCurPath, rDocument, aLibName ); return bRet; } sal_Bool ModulWindow::ToggleBreakPoint( sal_uLong nLine ) { DBG_ASSERT( XModule().Is(), "Kein Modul!" ); sal_Bool bNewBreakPoint = sal_False; if ( XModule().Is() ) { CheckCompileBasic(); if ( aStatus.bError ) { Sound::Beep(); return sal_False; } BreakPoint* pBrk = GetBreakPoints().FindBreakPoint( nLine ); if ( pBrk ) // entfernen { xModule->ClearBP( (sal_uInt16)nLine ); delete GetBreakPoints().Remove( pBrk ); } else // einen erzeugen { if ( xModule->SetBP( (sal_uInt16)nLine) ) { GetBreakPoints().InsertSorted( new BreakPoint( nLine ) ); bNewBreakPoint = sal_True; if ( StarBASIC::IsRunning() ) { for ( sal_uInt16 nMethod = 0; nMethod < xModule->GetMethods()->Count(); nMethod++ ) { SbMethod* pMethod = (SbMethod*)xModule->GetMethods()->Get( nMethod ); DBG_ASSERT( pMethod, "Methode nicht gefunden! (NULL)" ); pMethod->SetDebugFlags( pMethod->GetDebugFlags() | SbDEBUG_BREAK ); } } } if ( !bNewBreakPoint ) Sound::Beep(); } } return bNewBreakPoint; } void ModulWindow::UpdateBreakPoint( const BreakPoint& rBrk ) { DBG_ASSERT( XModule().Is(), "Kein Modul!" ); if ( XModule().Is() ) { CheckCompileBasic(); if ( rBrk.bEnabled ) xModule->SetBP( (sal_uInt16)rBrk.nLine ); else xModule->ClearBP( (sal_uInt16)rBrk.nLine ); } } sal_Bool ModulWindow::BasicToggleBreakPoint() { DBG_CHKTHIS( ModulWindow, 0 ); AssertValidEditEngine(); TextSelection aSel = GetEditView()->GetSelection(); aSel.GetStart().GetPara()++; // Basic-Zeilen beginnen bei 1! aSel.GetEnd().GetPara()++; sal_Bool bNewBreakPoint = sal_False; for ( sal_uLong nLine = aSel.GetStart().GetPara(); nLine <= aSel.GetEnd().GetPara(); nLine++ ) { if ( ToggleBreakPoint( nLine ) ) bNewBreakPoint = sal_True; } aXEditorWindow.GetBrkWindow().Invalidate(); return bNewBreakPoint; } void ModulWindow::BasicToggleBreakPointEnabled() { DBG_CHKTHIS( ModulWindow, 0 ); AssertValidEditEngine(); ExtTextView* pView = GetEditView(); if ( pView ) { TextSelection aSel = pView->GetSelection(); BreakPointList& rList = GetBreakPoints(); for ( sal_uLong nLine = ++aSel.GetStart().GetPara(), nEnd = ++aSel.GetEnd().GetPara(); nLine <= nEnd; ++nLine ) { BreakPoint* pBrk = rList.FindBreakPoint( nLine ); if ( pBrk ) { pBrk->bEnabled = pBrk->bEnabled ? sal_False : sal_True; UpdateBreakPoint( *pBrk ); } } GetBreakPointWindow().Invalidate(); } } void ModulWindow::ManageBreakPoints() { BreakPointWindow& rBrkWin = GetBreakPointWindow(); BreakPointDialog aBrkDlg( &rBrkWin, GetBreakPoints() ); aBrkDlg.Execute(); rBrkWin.Invalidate(); } IMPL_LINK( ModulWindow, BasicErrorHdl, StarBASIC *, pBasic ) { DBG_CHKTHIS( ModulWindow, 0 ); GoOnTop(); // ReturnWert: BOOL // FALSE: Abbrechen // TRUE: Weiter.... String aErrorText( pBasic->GetErrorText() ); sal_uInt16 nErrorLine = pBasic->GetLine() - 1; sal_uInt16 nErrCol1 = pBasic->GetCol1(); sal_uInt16 nErrCol2 = pBasic->GetCol2(); if ( nErrCol2 != 0xFFFF ) nErrCol2++; AssertValidEditEngine(); GetEditView()->SetSelection( TextSelection( TextPaM( nErrorLine, nErrCol1 ), TextPaM( nErrorLine, nErrCol2 ) ) ); String aErrorTextPrefix; if( pBasic->IsCompilerError() ) { aErrorTextPrefix = String( IDEResId( RID_STR_COMPILEERROR ) ); } else { aErrorTextPrefix = String( IDEResId( RID_STR_RUNTIMEERROR ) ); aErrorTextPrefix += StarBASIC::GetVBErrorCode( pBasic->GetErrorCode() ); aErrorTextPrefix += ' '; pLayout->GetStackWindow().UpdateCalls(); } // Wenn anderes Basic, dan sollte die IDE versuchen, da richtige // Modul anzuzeigen... sal_Bool bMarkError = ( pBasic == GetBasic() ) ? sal_True : sal_False; if ( bMarkError ) aXEditorWindow.GetBrkWindow().SetMarkerPos( nErrorLine, sal_True ); // ErrorBox( this, WB_OK | WB_DEF_OK, String( aErrorTextPrefix + aErrorText ) ).Execute(); // ErrorHandler::HandleError( pBasic->GetErrorCode() ); // #i47002# Reference< awt::XWindow > xWindow = VCLUnoHelper::GetInterface( this ); ErrorHandler::HandleError( StarBASIC::GetErrorCode() ); // #i47002# Window* pWindow = VCLUnoHelper::GetWindow( xWindow ); if ( !pWindow ) return sal_False; if ( bMarkError ) aXEditorWindow.GetBrkWindow().SetMarkerPos( MARKER_NOMARKER ); return sal_False; } long __EXPORT ModulWindow::BasicBreakHdl( StarBASIC* pBasic ) { DBG_CHKTHIS( ModulWindow, 0 ); // Ein GoOnTop aktiviert da Fenster, das veraendert aber den Context fuer // das Programm! // GoOnTop(); // #i69280 Required in Window despite normal usage in next command! (void)pBasic; // ReturnWert: sal_uInt16 => siehe SB-Debug-Flags sal_uInt16 nErrorLine = pBasic->GetLine(); // Gibt es hier einen BreakPoint? BreakPoint* pBrk = GetBreakPoints().FindBreakPoint( nErrorLine ); if ( pBrk ) { pBrk->nHitCount++; if ( pBrk->nHitCount < pBrk->nStopAfter && GetBasic()->IsBreak() ) return aStatus.nBasicFlags; // weiterlaufen... } nErrorLine--; // EditEngine begint bei 0, Basic bei 1 // Alleine schon damit gescrollt wird... AssertValidEditEngine(); GetEditView()->SetSelection( TextSelection( TextPaM( nErrorLine, 0 ), TextPaM( nErrorLine, 0 ) ) ); aXEditorWindow.GetBrkWindow().SetMarkerPos( nErrorLine ); pLayout->GetWatchWindow().UpdateWatches(); pLayout->GetStackWindow().UpdateCalls(); aStatus.bIsInReschedule = sal_True; aStatus.bIsRunning = sal_True; AddStatus( BASWIN_INRESCHEDULE ); BasicIDE::InvalidateDebuggerSlots(); while( aStatus.bIsRunning ) Application::Yield(); aStatus.bIsInReschedule = sal_False; aXEditorWindow.GetBrkWindow().SetMarkerPos( MARKER_NOMARKER ); ClearStatus( BASWIN_INRESCHEDULE ); return aStatus.nBasicFlags; } void ModulWindow::BasicAddWatch() { DBG_CHKTHIS( ModulWindow, 0 ); String aWatchStr; sal_Bool bInserted = sal_False; AssertValidEditEngine(); sal_Bool bAdd = sal_True; if ( !GetEditView()->HasSelection() ) { // bAdd = GetEditView()->SelectCurrentWord(); TextPaM aWordStart; String aWord = GetEditEngine()->GetWord( GetEditView()->GetSelection().GetEnd(), &aWordStart ); if ( aWord.Len() ) { TextSelection aSel( aWordStart ); sal_uInt16& rIndex = aSel.GetEnd().GetIndex(); rIndex = rIndex + aWord.Len(); // aSel.GetEnd().GetIndex() += sal::static_int_cast( aWord.Len() ); GetEditView()->SetSelection( aSel ); bAdd = sal_True; } } if ( bAdd ) { TextSelection aSel = GetEditView()->GetSelection(); if ( aSel.GetStart().GetPara() == aSel.GetEnd().GetPara() ) { aWatchStr = GetEditView()->GetSelected(); pLayout->GetWatchWindow().AddWatch( aWatchStr ); pLayout->GetWatchWindow().UpdateWatches(); bInserted = sal_True; } } if ( !bInserted ) Sound::Beep(); } void ModulWindow::BasicRemoveWatch() { DBG_CHKTHIS( ModulWindow, 0 ); sal_Bool bRemoved = pLayout->GetWatchWindow().RemoveSelectedWatch(); if ( !bRemoved ) Sound::Beep(); } void ModulWindow::EditMacro( const String& rMacroName ) { DBG_CHKTHIS( ModulWindow, 0 ); DBG_ASSERT( XModule().Is(), "Kein Modul!" ); if ( XModule().Is() ) { CheckCompileBasic(); if ( !aStatus.bError ) { sal_uInt16 nStart, nEnd; SbMethod* pMethod = (SbMethod*)xModule->Find( rMacroName, SbxCLASS_METHOD ); if ( pMethod ) { pMethod->GetLineRange( nStart, nEnd ); if ( nStart ) { // Basic beginnt bei 1 nStart--; nEnd--; } TextSelection aSel( TextPaM( nStart, 0 ), TextPaM( nStart, 0 ) ); AssertValidEditEngine(); TextView * pView = GetEditView(); // ggf. hinscrollen, so dass erste Zeile oben... long nVisHeight = GetOutputSizePixel().Height(); if ( (long)pView->GetTextEngine()->GetTextHeight() > nVisHeight ) { long nMaxY = pView->GetTextEngine()->GetTextHeight() - nVisHeight; long nOldStartY = pView->GetStartDocPos().Y(); long nNewStartY = nStart * pView->GetTextEngine()->GetCharHeight(); nNewStartY = Min( nNewStartY, nMaxY ); pView->Scroll( 0, -(nNewStartY-nOldStartY) ); pView->ShowCursor( sal_False, sal_True ); GetEditVScrollBar().SetThumbPos( pView->GetStartDocPos().Y() ); } pView->SetSelection( aSel ); pView->ShowCursor(); pView->GetWindow()->GrabFocus(); } } } } void __EXPORT ModulWindow::StoreData() { DBG_CHKTHIS( ModulWindow, 0 ); // StoreData wird gerufen, wenn der BasicManager zerstoert oder // dieses Fenster beendet wird. // => Keine Unterbrechungen erwuenscht! // Und bei SAVE, wenn AppBasic... GetEditorWindow().SetSourceInBasic( sal_True ); // Nicht das Modify loeschen, sonst wird das Basic nicht gespeichert // Es wird beim Speichern sowieso geloescht. // xModule->SetModified( sal_False ); } sal_Bool __EXPORT ModulWindow::CanClose() { DBG_CHKTHIS( ModulWindow, 0 ); return sal_True; } sal_Bool __EXPORT ModulWindow::AllowUndo() { return GetEditorWindow().CanModify(); } void __EXPORT ModulWindow::UpdateData() { DBG_CHKTHIS( ModulWindow, 0 ); DBG_ASSERT( XModule().Is(), "Kein Modul!" ); // UpdateData wird gerufen, wenn sich der Source von aussen // geaendert hat. // => Keine Unterbrechungen erwuenscht! if ( XModule().Is() ) { SetModule( xModule->GetSource32() ); if ( GetEditView() ) { TextSelection aSel = GetEditView()->GetSelection(); setTextEngineText( GetEditEngine(), xModule->GetSource32() ); GetEditView()->SetSelection( aSel ); GetEditEngine()->SetModified( sal_False ); BasicIDE::MarkDocumentModified( GetDocument() ); } } } sal_Int32 ModulWindow::countPages( Printer* pPrinter ) { return FormatAndPrint( pPrinter, -1 ); } void ModulWindow::printPage( sal_Int32 nPage, Printer* pPrinter ) { FormatAndPrint( pPrinter, nPage ); } /* implementation note: this is totally inefficient for the XRenderable interface usage since the whole "document" will be format for every page. Should this ever become a problem we should - format only once for every new printer - keep an index list for each page which is the starting paragraph */ sal_Int32 ModulWindow::FormatAndPrint( Printer* pPrinter, sal_Int32 nPrintPage ) { DBG_CHKTHIS( ModulWindow, 0 ); AssertValidEditEngine(); MapMode eOldMapMode( pPrinter->GetMapMode() ); Font aOldFont( pPrinter->GetFont() ); // Font aFont( GetEditEngine()->CreateFontFromItemSet( GetEditEngine()->GetEmptyItemSet() ) ); Font aFont( GetEditEngine()->GetFont() ); aFont.SetAlign( ALIGN_BOTTOM ); aFont.SetTransparent( sal_True ); aFont.SetSize( Size( 0, 360 ) ); pPrinter->SetFont( aFont ); pPrinter->SetMapMode( MAP_100TH_MM ); String aTitle( CreateQualifiedName() ); sal_uInt16 nLineHeight = (sal_uInt16) pPrinter->GetTextHeight(); // etwas mehr. sal_uInt16 nParaSpace = 10; Size aPaperSz = pPrinter->GetOutputSize(); aPaperSz.Width() -= (LMARGPRN+RMARGPRN); aPaperSz.Height() -= (TMARGPRN+BMARGPRN); // nLinepPage stimmt nicht, wenn Zeilen umgebrochen werden muessen... sal_uInt16 nLinespPage = (sal_uInt16) (aPaperSz.Height()/nLineHeight); sal_uInt16 nCharspLine = (sal_uInt16) (aPaperSz.Width() / pPrinter->GetTextWidth( 'X' ) ); sal_uLong nParas = GetEditEngine()->GetParagraphCount(); sal_uInt16 nPages = (sal_uInt16) (nParas/nLinespPage+1 ); sal_uInt16 nCurPage = 1; // Header drucken... lcl_PrintHeader( pPrinter, nPages, nCurPage, aTitle, nPrintPage == 0 ); Point aPos( LMARGPRN, TMARGPRN ); for ( sal_uLong nPara = 0; nPara < nParas; nPara++ ) { String aLine( GetEditEngine()->GetText( nPara ) ); lcl_ConvertTabsToSpaces( aLine ); sal_uInt16 nLines = aLine.Len()/nCharspLine+1; for ( sal_uInt16 nLine = 0; nLine < nLines; nLine++ ) { String aTmpLine( aLine, nLine*nCharspLine, nCharspLine ); aPos.Y() += nLineHeight; if ( aPos.Y() > ( aPaperSz.Height()+TMARGPRN ) ) { nCurPage++; lcl_PrintHeader( pPrinter, nPages, nCurPage, aTitle, nCurPage-1 == nPrintPage ); aPos = Point( LMARGPRN, TMARGPRN+nLineHeight ); } if( nCurPage-1 == nPrintPage ) pPrinter->DrawText( aPos, aTmpLine ); } aPos.Y() += nParaSpace; } pPrinter->SetFont( aOldFont ); pPrinter->SetMapMode( eOldMapMode ); return sal_Int32(nCurPage); } void __EXPORT ModulWindow::ExecuteCommand( SfxRequest& rReq ) { DBG_CHKTHIS( ModulWindow, 0 ); AssertValidEditEngine(); sal_uInt16 nSlot = rReq.GetSlot(); switch ( nSlot ) { case SID_BASICRUN: { BasicRun(); } break; case SID_BASICCOMPILE: { CompileBasic(); } break; case SID_BASICSTEPOVER: { BasicStepOver(); } break; case SID_BASICSTEPINTO: { BasicStepInto(); } break; case SID_BASICSTEPOUT: { BasicStepOut(); } break; case SID_BASICLOAD: { LoadBasic(); } break; case SID_BASICSAVEAS: { SaveBasicSource(); } break; case SID_IMPORT_DIALOG: { ImportDialog(); } break; case SID_BASICIDE_MATCHGROUP: { if ( !GetEditView()->MatchGroup() ) Sound::Beep(); } break; case SID_BASICIDE_TOGGLEBRKPNT: { BasicToggleBreakPoint(); } break; case SID_BASICIDE_MANAGEBRKPNTS: { ManageBreakPoints(); } break; case SID_BASICIDE_TOGGLEBRKPNTENABLED: { BasicToggleBreakPointEnabled(); } break; case SID_BASICIDE_ADDWATCH: { BasicAddWatch(); } break; case SID_BASICIDE_REMOVEWATCH: { BasicRemoveWatch(); } break; case SID_CUT: { if ( !IsReadOnly() ) { GetEditView()->Cut(); SfxBindings* pBindings = BasicIDE::GetBindingsPtr(); if ( pBindings ) pBindings->Invalidate( SID_DOC_MODIFIED ); } } break; case SID_COPY: { GetEditView()->Copy(); } break; case SID_PASTE: { if ( !IsReadOnly() ) { GetEditView()->Paste(); SfxBindings* pBindings = BasicIDE::GetBindingsPtr(); if ( pBindings ) pBindings->Invalidate( SID_DOC_MODIFIED ); } } break; case SID_BASICIDE_BRKPNTSCHANGED: { GetBreakPointWindow().Invalidate(); } break; case SID_SELECTALL: { TextSelection aSel( TextPaM( 0, 0 ), TextPaM( TEXT_PARA_ALL, 0xFFFF ) ); TextView * pView = GetEditView(); pView->SetSelection( aSel ); pView->GetWindow()->GrabFocus(); } break; } } void __EXPORT ModulWindow::GetState( SfxItemSet &rSet ) { DBG_CHKTHIS( ModulWindow, 0 ); SfxWhichIter aIter(rSet); for ( sal_uInt16 nWh = aIter.FirstWhich(); 0 != nWh; nWh = aIter.NextWhich() ) { switch ( nWh ) { // allgemeine Items: case SID_CUT: { if ( !GetEditView() || !GetEditView()->HasSelection() ) rSet.DisableItem( nWh ); if ( IsReadOnly() ) rSet.DisableItem( nWh ); } break; case SID_COPY: { if ( !GetEditView() || !GetEditView()->HasSelection() ) rSet.DisableItem( nWh ); } break; case SID_PASTE: { if ( !IsPasteAllowed() ) rSet.DisableItem( nWh ); if ( IsReadOnly() ) rSet.DisableItem( nWh ); } break; case SID_BASICIDE_STAT_POS: { TextView* pView = GetEditView(); if ( pView ) { TextSelection aSel = pView->GetSelection(); String aPos( IDEResId( RID_STR_LINE ) ); aPos += ' '; aPos += String::CreateFromInt32( aSel.GetEnd().GetPara()+1 ); aPos += String( RTL_CONSTASCII_USTRINGPARAM( ", " ) ); aPos += String( IDEResId( RID_STR_COLUMN ) ); aPos += ' '; aPos += String::CreateFromInt32( aSel.GetEnd().GetIndex()+1 ); SfxStringItem aItem( SID_BASICIDE_STAT_POS, aPos ); rSet.Put( aItem ); } } break; case SID_ATTR_INSERT: { TextView* pView = GetEditView(); if ( pView ) { SfxBoolItem aItem( SID_ATTR_INSERT, pView->IsInsertMode() ); rSet.Put( aItem ); } } break; case SID_SELECTALL: { if ( !GetEditView() ) rSet.DisableItem( nWh ); } break; } } } void __EXPORT ModulWindow::DoScroll( ScrollBar* pCurScrollBar ) { DBG_CHKTHIS( ModulWindow, 0 ); if ( ( pCurScrollBar == GetHScrollBar() ) && GetEditView() ) { // Nicht mit dem Wert Scrollen, sondern lieber die Thumb-Pos fuer die // VisArea verwenden: long nDiff = GetEditView()->GetStartDocPos().X() - pCurScrollBar->GetThumbPos(); GetEditView()->Scroll( nDiff, 0 ); GetEditView()->ShowCursor( sal_False, sal_True ); pCurScrollBar->SetThumbPos( GetEditView()->GetStartDocPos().X() ); } } sal_Bool __EXPORT ModulWindow::IsModified() { return GetEditEngine() ? GetEditEngine()->IsModified() : sal_False; } void __EXPORT ModulWindow::GoOnTop() { IDE_DLL()->GetShell()->GetViewFrame()->ToTop(); } String ModulWindow::GetSbModuleName() { String aModuleName; if ( XModule().Is() ) aModuleName = xModule->GetName(); return aModuleName; } String __EXPORT ModulWindow::GetTitle() { return GetSbModuleName(); } void ModulWindow::FrameWindowMoved() { // if ( GetEditEngine() && GetEditEngine()->IsInSelectionMode() ) // GetEditEngine()->StopSelectionMode(); } void ModulWindow::ShowCursor( sal_Bool bOn ) { if ( GetEditEngine() ) { TextView* pView = GetEditEngine()->GetActiveView(); if ( pView ) { if ( bOn ) pView->ShowCursor(); else pView->HideCursor(); } } } Window* __EXPORT ModulWindow::GetLayoutWindow() { return pLayout; } void ModulWindow::AssertValidEditEngine() { if ( !GetEditEngine() ) GetEditorWindow().CreateEditEngine(); } void ModulWindow::Deactivating() { if ( GetEditView() ) GetEditView()->EraseVirtualDevice(); } sal_uInt16 ModulWindow::StartSearchAndReplace( const SvxSearchItem& rSearchItem, sal_Bool bFromStart ) { // Mann koennte fuer das blinde Alle-Ersetzen auch auf // Syntaxhighlighting/Formatierung verzichten... AssertValidEditEngine(); ExtTextView* pView = GetEditView(); TextSelection aSel; if ( bFromStart ) { aSel = pView->GetSelection(); if ( !rSearchItem.GetBackward() ) pView->SetSelection( TextSelection() ); else pView->SetSelection( TextSelection( TextPaM( 0xFFFFFFFF, 0xFFFF ), TextPaM( 0xFFFFFFFF, 0xFFFF ) ) ); } sal_Bool bForward = !rSearchItem.GetBackward(); sal_uInt16 nFound = 0; if ( ( rSearchItem.GetCommand() == SVX_SEARCHCMD_FIND ) || ( rSearchItem.GetCommand() == SVX_SEARCHCMD_FIND_ALL ) ) { nFound = pView->Search( rSearchItem.GetSearchOptions() , bForward ); } else if ( ( rSearchItem.GetCommand() == SVX_SEARCHCMD_REPLACE ) || ( rSearchItem.GetCommand() == SVX_SEARCHCMD_REPLACE_ALL ) ) { if ( !IsReadOnly() ) { sal_Bool bAll = rSearchItem.GetCommand() == SVX_SEARCHCMD_REPLACE_ALL; nFound = pView->Replace( rSearchItem.GetSearchOptions() , bAll , bForward ); } } if ( bFromStart && !nFound ) pView->SetSelection( aSel ); return nFound; } ::svl::IUndoManager* __EXPORT ModulWindow::GetUndoManager() { if ( GetEditEngine() ) return &GetEditEngine()->GetUndoManager(); return NULL; } sal_uInt16 __EXPORT ModulWindow::GetSearchOptions() { sal_uInt16 nOptions = SEARCH_OPTIONS_SEARCH | SEARCH_OPTIONS_WHOLE_WORDS | SEARCH_OPTIONS_BACKWARDS | SEARCH_OPTIONS_REG_EXP | SEARCH_OPTIONS_EXACT | SEARCH_OPTIONS_SELECTION | SEARCH_OPTIONS_SIMILARITY; if ( !IsReadOnly() ) { nOptions |= SEARCH_OPTIONS_REPLACE; nOptions |= SEARCH_OPTIONS_REPLACE_ALL; } return nOptions; } void __EXPORT ModulWindow::BasicStarted() { if ( XModule().Is() ) { aStatus.bIsRunning = sal_True; BreakPointList& rList = GetBreakPoints(); if ( rList.Count() ) { rList.ResetHitCount(); rList.SetBreakPointsInBasic( xModule ); for ( sal_uInt16 nMethod = 0; nMethod < xModule->GetMethods()->Count(); nMethod++ ) { SbMethod* pMethod = (SbMethod*)xModule->GetMethods()->Get( nMethod ); DBG_ASSERT( pMethod, "Methode nicht gefunden! (NULL)" ); pMethod->SetDebugFlags( pMethod->GetDebugFlags() | SbDEBUG_BREAK ); } } } } void __EXPORT ModulWindow::BasicStopped() { aStatus.bIsRunning = sal_False; GetBreakPointWindow().SetMarkerPos( MARKER_NOMARKER ); } BasicEntryDescriptor ModulWindow::CreateEntryDescriptor() { ScriptDocument aDocument( GetDocument() ); String aLibName( GetLibName() ); LibraryLocation eLocation = aDocument.getLibraryLocation( aLibName ); String aModName( GetName() ); String aLibSubName; if( xBasic.Is() && aDocument.isInVBAMode() && XModule().Is() ) { switch( xModule->GetModuleType() ) { case script::ModuleType::DOCUMENT: { aLibSubName = String( IDEResId( RID_STR_DOCUMENT_OBJECTS ) ); uno::Reference< container::XNameContainer > xLib = aDocument.getOrCreateLibrary( E_SCRIPTS, aLibName ); if( xLib.is() ) { String sObjName; ModuleInfoHelper::getObjectName( xLib, aModName, sObjName ); if( sObjName.Len() ) { aModName.AppendAscii(" (").Append(sObjName).AppendAscii(")"); } } break; } case script::ModuleType::FORM: aLibSubName = String( IDEResId( RID_STR_USERFORMS ) ); break; case script::ModuleType::NORMAL: aLibSubName = String( IDEResId( RID_STR_NORMAL_MODULES ) ); break; case script::ModuleType::CLASS: aLibSubName = String( IDEResId( RID_STR_CLASS_MODULES ) ); break; } } return BasicEntryDescriptor( aDocument, eLocation, aLibName, aLibSubName, aModName, OBJ_TYPE_MODULE ); } void ModulWindow::SetReadOnly( sal_Bool b ) { if ( GetEditView() ) GetEditView()->SetReadOnly( b ); } sal_Bool ModulWindow::IsReadOnly() { sal_Bool bReadOnly = sal_False; if ( GetEditView() ) bReadOnly = GetEditView()->IsReadOnly(); return bReadOnly; } sal_Bool ModulWindow::IsPasteAllowed() { sal_Bool bPaste = sal_False; // get clipboard Reference< datatransfer::clipboard::XClipboard > xClipboard = GetClipboard(); if ( xClipboard.is() ) { // get clipboard content const sal_uInt32 nRef = Application::ReleaseSolarMutex(); Reference< datatransfer::XTransferable > xTransf = xClipboard->getContents(); Application::AcquireSolarMutex( nRef ); if ( xTransf.is() ) { datatransfer::DataFlavor aFlavor; SotExchange::GetFormatDataFlavor( SOT_FORMAT_STRING, aFlavor ); if ( xTransf->isDataFlavorSupported( aFlavor ) ) { bPaste = sal_True; } } } return bPaste; } ModulWindowLayout::ModulWindowLayout( Window* pParent ) : Window( pParent, WB_CLIPCHILDREN ), aVSplitter( this, WinBits( WB_VSCROLL ) ), aHSplitter( this, WinBits( WB_HSCROLL ) ), aWatchWindow( this ), aStackWindow( this ), bVSplitted(sal_False), bHSplitted(sal_False), m_pModulWindow(0), m_aImagesNormal(IDEResId(RID_IMGLST_LAYOUT)), m_aImagesHighContrast(IDEResId(RID_IMGLST_LAYOUT_HC)) { SetBackground(GetSettings().GetStyleSettings().GetWindowColor()); aVSplitter.SetSplitHdl( LINK( this, ModulWindowLayout, SplitHdl ) ); aHSplitter.SetSplitHdl( LINK( this, ModulWindowLayout, SplitHdl ) ); aVSplitter.Show(); aHSplitter.Show(); aWatchWindow.Show(); aStackWindow.Show(); Color aColor(GetSettings().GetStyleSettings().GetFieldTextColor()); m_aSyntaxColors[TT_UNKNOWN] = aColor; m_aSyntaxColors[TT_WHITESPACE] = aColor; m_aSyntaxColors[TT_EOL] = aColor; m_aColorConfig.AddListener(this); m_aSyntaxColors[TT_IDENTIFIER] = Color(m_aColorConfig.GetColorValue(svtools::BASICIDENTIFIER).nColor); m_aSyntaxColors[TT_NUMBER] = Color(m_aColorConfig.GetColorValue(svtools::BASICNUMBER).nColor); m_aSyntaxColors[TT_STRING] = Color(m_aColorConfig.GetColorValue(svtools::BASICSTRING).nColor); m_aSyntaxColors[TT_COMMENT] = Color(m_aColorConfig.GetColorValue(svtools::BASICCOMMENT).nColor); m_aSyntaxColors[TT_ERROR] = Color(m_aColorConfig.GetColorValue(svtools::BASICERROR).nColor); m_aSyntaxColors[TT_OPERATOR] = Color(m_aColorConfig.GetColorValue(svtools::BASICOPERATOR).nColor); m_aSyntaxColors[TT_KEYWORDS] = Color(m_aColorConfig.GetColorValue(svtools::BASICKEYWORD).nColor); Font aFont( GetFont() ); Size aSz( aFont.GetSize() ); aSz.Height() *= 3; aSz.Height() /= 2; aFont.SetSize( aSz ); aFont.SetWeight( WEIGHT_BOLD ); aFont.SetColor(GetSettings().GetStyleSettings().GetWindowTextColor()); SetFont( aFont ); } ModulWindowLayout::~ModulWindowLayout() { m_aColorConfig.RemoveListener(this); } void __EXPORT ModulWindowLayout::Resize() { // ScrollBars, etc. passiert in BasicIDEShell:Adjust... ArrangeWindows(); // Invalidate(); } void __EXPORT ModulWindowLayout::Paint( const Rectangle& ) { DrawText( Point(), String( IDEResId( RID_STR_NOMODULE ) ) ); } void ModulWindowLayout::ArrangeWindows() { Size aSz = GetOutputSizePixel(); // prueffen, ob der Splitter in einem gueltigen Bereich liegt... long nMinPos = SPLIT_MARGIN; long nMaxPos = aSz.Height() - SPLIT_MARGIN; long nVSplitPos = aVSplitter.GetSplitPosPixel(); long nHSplitPos = aHSplitter.GetSplitPosPixel(); if ( !bVSplitted ) { // Wenn noch nie gesplitted wurde, Verhaeltniss = 3 : 4 nVSplitPos = aSz.Height() * 3 / 4; aVSplitter.SetSplitPosPixel( nVSplitPos ); } if ( !bHSplitted ) { // Wenn noch nie gesplitted wurde, Verhaeltniss = 2 : 3 nHSplitPos = aSz.Width() * 2 / 3; aHSplitter.SetSplitPosPixel( nHSplitPos ); } if ( ( nVSplitPos < nMinPos ) || ( nVSplitPos > nMaxPos ) ) nVSplitPos = ( nVSplitPos < nMinPos ) ? 0 : ( aSz.Height() - SPLIT_HEIGHT ); Size aXEWSz; aXEWSz.Width() = aSz.Width(); aXEWSz.Height() = nVSplitPos + 1; if ( m_pModulWindow ) { DBG_CHKOBJ( m_pModulWindow, ModulWindow, 0 ); m_pModulWindow->SetPosSizePixel( Point( 0, 0 ), aXEWSz ); } aVSplitter.SetDragRectPixel( Rectangle( Point( 0, 0 ), Size( aSz.Width(), aSz.Height() ) ) ); aVSplitter.SetPosPixel( Point( 0, nVSplitPos ) ); aVSplitter.SetSizePixel( Size( aSz.Width(), SPLIT_HEIGHT ) ); aHSplitter.SetDragRectPixel( Rectangle( Point( 0, nVSplitPos+SPLIT_HEIGHT ), Size( aSz.Width(), aSz.Height() - nVSplitPos - SPLIT_HEIGHT ) ) ); aHSplitter.SetPosPixel( Point( nHSplitPos, nVSplitPos ) ); aHSplitter.SetSizePixel( Size( SPLIT_HEIGHT, aSz.Height() - nVSplitPos ) ); Size aWWSz; Point aWWPos( 0, nVSplitPos+SPLIT_HEIGHT ); aWWSz.Width() = nHSplitPos; aWWSz.Height() = aSz.Height() - aWWPos.Y(); if ( !aWatchWindow.IsFloatingMode() ) aWatchWindow.SetPosSizePixel( aWWPos, aWWSz ); Size aSWSz; Point aSWPos( nHSplitPos+SPLIT_HEIGHT, nVSplitPos+SPLIT_HEIGHT ); aSWSz.Width() = aSz.Width() - aSWPos.X(); aSWSz.Height() = aSz.Height() - aSWPos.Y(); if ( !aStackWindow.IsFloatingMode() ) aStackWindow.SetPosSizePixel( aSWPos, aSWSz ); if ( aStackWindow.IsFloatingMode() && aWatchWindow.IsFloatingMode() ) aHSplitter.Hide(); else aHSplitter.Show(); long nHDoubleClickSplitPosX = aSz.Width()-aHSplitter.GetSizePixel().Width(); if ( aHSplitter.GetSplitPosPixel() < nHDoubleClickSplitPosX ) aHSplitter.SetLastSplitPosPixel( nHDoubleClickSplitPosX ); long nHDoubleClickSplitPosY = aSz.Height()-aVSplitter.GetSizePixel().Height(); if ( aVSplitter.GetSplitPosPixel() < nHDoubleClickSplitPosY ) aVSplitter.SetLastSplitPosPixel( nHDoubleClickSplitPosY ); } IMPL_LINK( ModulWindowLayout, SplitHdl, Splitter *, pSplitter ) { if ( pSplitter == &aVSplitter ) bVSplitted = sal_True; else bHSplitted = sal_True; ArrangeWindows(); return 0; } sal_Bool ModulWindowLayout::IsToBeDocked( DockingWindow* pDockingWindow, const Point& rPos, Rectangle& rRect ) { // prueffen, ob als Dock oder als Child: // TRUE: Floating // FALSE: Child Point aPosInMe = ScreenToOutputPixel( rPos ); Size aSz = GetOutputSizePixel(); if ( ( aPosInMe.X() > 0 ) && ( aPosInMe.X() < aSz.Width() ) && ( aPosInMe.Y() > 0 ) && ( aPosInMe.Y() < aSz.Height() ) ) { long nVSplitPos = aVSplitter.GetSplitPosPixel(); long nHSplitPos = aHSplitter.GetSplitPosPixel(); if ( pDockingWindow == &aWatchWindow ) { if ( ( aPosInMe.Y() > nVSplitPos ) && ( aPosInMe.X() < nHSplitPos ) ) { rRect.SetSize( Size( nHSplitPos, aSz.Height() - nVSplitPos ) ); rRect.SetPos( OutputToScreenPixel( Point( 0, nVSplitPos ) ) ); return sal_True; } } if ( pDockingWindow == &aStackWindow ) { if ( ( aPosInMe.Y() > nVSplitPos ) && ( aPosInMe.X() > nHSplitPos ) ) { rRect.SetSize( Size( aSz.Width() - nHSplitPos, aSz.Height() - nVSplitPos ) ); rRect.SetPos( OutputToScreenPixel( Point( nHSplitPos, nVSplitPos ) ) ); return sal_True; } } } return sal_False; } void ModulWindowLayout::DockaWindow( DockingWindow* pDockingWindow ) { if ( pDockingWindow == &aWatchWindow ) { // evtl. Sonderbehandlung... ArrangeWindows(); } else if ( pDockingWindow == &aStackWindow ) { // evtl. Sonderbehandlung... ArrangeWindows(); } #ifdef DBG_UTIL else DBG_ERROR( "Wer will sich denn hier andocken ?" ); #endif } void ModulWindowLayout::SetModulWindow( ModulWindow* pModWin ) { m_pModulWindow = pModWin; ArrangeWindows(); } // virtual void ModulWindowLayout::DataChanged(DataChangedEvent const & rDCEvt) { Window::DataChanged(rDCEvt); if (rDCEvt.GetType() == DATACHANGED_SETTINGS && (rDCEvt.GetFlags() & SETTINGS_STYLE) != 0) { bool bInvalidate = false; Color aColor(GetSettings().GetStyleSettings().GetWindowColor()); if (aColor != rDCEvt.GetOldSettings()->GetStyleSettings().GetWindowColor()) { SetBackground(Wallpaper(aColor)); bInvalidate = true; } aColor = GetSettings().GetStyleSettings().GetWindowTextColor(); if (aColor != rDCEvt.GetOldSettings()-> GetStyleSettings().GetWindowTextColor()) { Font aFont(GetFont()); aFont.SetColor(aColor); SetFont(aFont); bInvalidate = true; } if (bInvalidate) Invalidate(); aColor = GetSettings().GetStyleSettings().GetFieldTextColor(); if (aColor != m_aSyntaxColors[TT_UNKNOWN]) { m_aSyntaxColors[TT_UNKNOWN] = aColor; m_aSyntaxColors[TT_WHITESPACE] = aColor; m_aSyntaxColors[TT_EOL] = aColor; updateSyntaxHighlighting(); } } } // virtual void ModulWindowLayout::ConfigurationChanged( utl::ConfigurationBroadcaster*, sal_uInt32 ) { { Color aColor(m_aColorConfig.GetColorValue(svtools::BASICIDENTIFIER). nColor); bool bChanged = aColor != m_aSyntaxColors[TT_IDENTIFIER]; m_aSyntaxColors[TT_IDENTIFIER] = aColor; aColor = Color(m_aColorConfig.GetColorValue(svtools::BASICNUMBER).nColor); if (bChanged || aColor != m_aSyntaxColors[TT_NUMBER]) bChanged = true; m_aSyntaxColors[TT_NUMBER] = aColor; aColor = Color(m_aColorConfig.GetColorValue(svtools::BASICSTRING).nColor); if (bChanged || aColor != m_aSyntaxColors[TT_STRING]) bChanged = true; m_aSyntaxColors[TT_STRING] = aColor; aColor = Color(m_aColorConfig.GetColorValue(svtools::BASICCOMMENT). nColor); if (bChanged || aColor != m_aSyntaxColors[TT_COMMENT]) bChanged = true; m_aSyntaxColors[TT_COMMENT] = aColor; aColor = Color(m_aColorConfig.GetColorValue(svtools::BASICERROR).nColor); if (bChanged || aColor != m_aSyntaxColors[TT_ERROR]) bChanged = true; m_aSyntaxColors[TT_ERROR] = aColor; aColor = Color(m_aColorConfig.GetColorValue(svtools::BASICOPERATOR). nColor); if (bChanged || aColor != m_aSyntaxColors[TT_OPERATOR]) bChanged = true; m_aSyntaxColors[TT_OPERATOR] = aColor; aColor = Color(m_aColorConfig.GetColorValue(svtools::BASICKEYWORD). nColor); if (bChanged || aColor != m_aSyntaxColors[TT_KEYWORDS]) bChanged = true; m_aSyntaxColors[TT_KEYWORDS] = aColor; if (bChanged) updateSyntaxHighlighting(); } } void ModulWindowLayout::updateSyntaxHighlighting() { if (m_pModulWindow != 0) { EditorWindow & rEditor = m_pModulWindow->GetEditorWindow(); sal_uLong nCount = rEditor.GetEditEngine()->GetParagraphCount(); for (sal_uLong i = 0; i < nCount; ++i) rEditor.DoDelayedSyntaxHighlight(i); } } Image ModulWindowLayout::getImage(sal_uInt16 nId, bool bHighContrastMode) const { return (bHighContrastMode ? m_aImagesHighContrast : m_aImagesNormal). GetImage(nId); }