From 5de3dd4762ca33a0f92e79ffa4fe2ff67069d531 Mon Sep 17 00:00:00 2001 From: tpearson Date: Wed, 24 Feb 2010 01:49:02 +0000 Subject: Added KDE3 version of ktechlab git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/applications/ktechlab@1095338 283d02a7-25f6-0310-bc7c-ecb5cbfe19da --- src/textdocument.cpp | 1146 ++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1146 insertions(+) create mode 100644 src/textdocument.cpp (limited to 'src/textdocument.cpp') diff --git a/src/textdocument.cpp b/src/textdocument.cpp new file mode 100644 index 0000000..ba03c04 --- /dev/null +++ b/src/textdocument.cpp @@ -0,0 +1,1146 @@ +/*************************************************************************** + * Copyright (C) 2005 by David Saxton * + * david@bluehaze.org * + * * + * This program is free software; you can redistribute it and/or modify * + * it under the terms of the GNU General Public License as published by * + * the Free Software Foundation; either version 2 of the License, or * + * (at your option) any later version. * + ***************************************************************************/ + +#include "asmformatter.h" +#include "asminfo.h" +#include "asmparser.h" +#include "debugmanager.h" +#include "docmanager.h" +#include "documentiface.h" +#include "filemetainfo.h" +#include "gpsimprocessor.h" +#include "ktechlab.h" +#include "language.h" +#include "languagemanager.h" +#include "microselectwidget.h" +#include "programmerdlg.h" +#include "symbolviewer.h" +#include "textdocument.h" +#include "textview.h" + +// #include + +#include +#include +#include +#include +#include + + +TextDocument *TextDocument::constructTextDocument( const QString& caption, KTechlab *parent, const char *name ) +{ + TextDocument *textDocument = new TextDocument( caption, parent, name); + if( textDocument->m_constructorSuccessful ) + return textDocument; + delete textDocument; + return 0L; +} + + +TextDocument::TextDocument( const QString &caption, KTechlab *ktechlab, const char *name ) + : Document( caption, ktechlab, name ), + m_doc(0) +{ + m_constructorSuccessful = false; + +#ifndef NO_GPSIM + m_bOwnDebugger = false; + b_lockSyncBreakpoints = false; + m_lastDebugLineAt = -1; + m_pDebugger = 0l; +#endif + + m_pLastTextOutputTarget = 0l; + m_guessedCodeType = TextDocument::ct_unknown; + m_type = Document::dt_text; + m_bookmarkActions.setAutoDelete(true); + m_pDocumentIface = new TextDocumentIface(this); + + KLibFactory *factory = KLibLoader::self()->factory("libkatepart"); + if(!factory) + { + KMessageBox::sorry( ktechlab, i18n("Libkatepart not available for constructing editor") ); + return; + } + m_doc = (Kate::Document*)(KTextEditor::Document *)factory->create( 0L, "kate", "KTextEditor::Document"); + + guessScheme(); + + connect( m_doc, SIGNAL(undoChanged()), this, SIGNAL(undoRedoStateChanged()) ); + connect( m_doc, SIGNAL(undoChanged()), this, SLOT(slotSyncModifiedStates()) ); + connect( m_doc, SIGNAL(textChanged()), this, SLOT(slotSyncModifiedStates()) ); + connect( m_doc, SIGNAL(marksChanged()), this, SLOT(slotUpdateMarksInfo()) ); + connect( m_doc, SIGNAL(selectionChanged()), this, SLOT(slotSelectionmChanged()) ); + + m_doc->setDescription((KTextEditor::MarkInterface::MarkTypes)Breakpoint, i18n("Breakpoint")); + m_doc->setPixmap((KTextEditor::MarkInterface::MarkTypes)Breakpoint, *inactiveBreakpointPixmap()); + m_doc->setPixmap((KTextEditor::MarkInterface::MarkTypes)ActiveBreakpoint, *activeBreakpointPixmap()); + m_doc->setPixmap((KTextEditor::MarkInterface::MarkTypes)ReachedBreakpoint, *reachedBreakpointPixmap()); + m_doc->setPixmap((KTextEditor::MarkInterface::MarkTypes)DisabledBreakpoint, *disabledBreakpointPixmap()); + m_doc->setPixmap((KTextEditor::MarkInterface::MarkTypes)ExecutionPoint, *executionPointPixmap()); + m_doc->setMarksUserChangable( Bookmark | Breakpoint ); + + m_constructorSuccessful = true; +} + + +TextDocument::~TextDocument() +{ + if( !m_constructorSuccessful ) + return; + + debugStop(); + + ViewList::iterator end = m_viewList.end(); + for ( ViewList::iterator it = m_viewList.begin(); it != end; ++it ) + { + if ( TextView * tv = dynamic_cast( (View*)*it) ) + { + Kate::View * kv = tv->kateView(); + p_ktechlab->factory()->removeClient( kv ); + } + } + + delete m_doc; + m_doc = 0l; + + delete m_pDocumentIface; + m_pDocumentIface = 0l; +} + + +bool TextDocument::fileClose() +{ + const QString path = url().prettyURL(); + if ( !path.isEmpty() ) + fileMetaInfo()->grabMetaInfo( path, this ); + + return Document::fileClose(); +} + + +TextView* TextDocument::textView() const +{ + return static_cast(activeView()); +} + + +View * TextDocument::createView( ViewContainer *viewContainer, uint viewAreaId, const char *name ) +{ + TextView * textView = new TextView( this, viewContainer, viewAreaId, name ); + + fileMetaInfo()->initializeFromMetaInfo( url().prettyURL(), textView ); + + handleNewView(textView); + return textView; +} + + +Kate::View* TextDocument::createKateView( QWidget *parent, const char *name ) +{ + return static_cast((m_doc->createView( parent, name ))->qt_cast("Kate::View")); +} + + +void TextDocument::cut() +{ + if (textView()) + textView()->cut(); +} +void TextDocument::copy() +{ + if (textView()) + textView()->copy(); +} +void TextDocument::paste() +{ + if (textView()) + textView()->paste(); +} + + +void TextDocument::setText( const QString & text, bool asInitial ) +{ + if ( asInitial ) + { + disconnect( m_doc, SIGNAL(undoChanged()), this, SIGNAL(undoRedoStateChanged()) ); + disconnect( m_doc, SIGNAL(undoChanged()), this, SLOT(slotSyncModifiedStates()) ); + disconnect( m_doc, SIGNAL(textChanged()), this, SLOT(slotSyncModifiedStates()) ); + } + + const ViewList::iterator end = m_viewList.end(); + for ( ViewList::iterator it = m_viewList.begin(); it != end; ++it ) + (static_cast((View*)*it))->saveCursorPosition(); + + m_doc->setText(text); + + for ( ViewList::iterator it = m_viewList.begin(); it != end; ++it ) + (static_cast((View*)*it))->restoreCursorPosition(); + + if ( asInitial ) + { + m_doc->clearUndo(); + m_doc->clearRedo(); + setModified(false); + + connect( m_doc, SIGNAL(undoChanged()), this, SIGNAL(undoRedoStateChanged()) ); + connect( m_doc, SIGNAL(undoChanged()), this, SLOT(slotSyncModifiedStates()) ); + connect( m_doc, SIGNAL(textChanged()), this, SLOT(slotSyncModifiedStates()) ); + } +} + + +void TextDocument::undo() +{ + m_doc->undo(); + slotSyncModifiedStates(); +} + + +void TextDocument::redo() +{ + m_doc->redo(); + slotSyncModifiedStates(); +} + + +void TextDocument::slotSyncModifiedStates() +{ + setModified( m_doc->isModified() ); +} +void TextDocument::setModified( bool modified ) +{ + if ( (modified == b_modified) && (modified == isModified()) ) { + return; + } + m_doc->setModified(modified); + b_modified = modified; + + emit modifiedStateChanged(); +} + + +void TextDocument::guessScheme( bool allowDisable ) +{ + // And specific file actions depending on the current type of file + QString fileName = url().fileName(); + QString extension = fileName.right( fileName.length() - fileName.findRev('.') - 1 ); + + if ( extension == "asm" || extension == "src" || extension == "inc" ) + slotInitLanguage(ct_asm); + + else if ( extension == "hex" ) + slotInitLanguage(ct_hex); + + else if ( extension == "basic" || extension == "microbe" ) + slotInitLanguage(ct_microbe); + + else if ( extension == "c" ) + slotInitLanguage(ct_c); + + else if ( m_guessedCodeType != TextDocument::ct_unknown ) + slotInitLanguage(m_guessedCodeType); + + else if ( allowDisable && activeView() ) + textView()->disableActions(); +} + + +void TextDocument::slotInitLanguage( CodeType type ) +{ + QString hlName; + + switch (type) + { + case ct_asm: + hlName = "PicAsm"; + break; + + case ct_c: + hlName = "C"; + break; + + case ct_hex: + break; + + case ct_microbe: + hlName = "Microbe"; + break; + + case ct_unknown: + break; + } + + if ( !hlName.isEmpty() ) + { + int i = 0; + int hlModeCount = m_doc->hlModeCount(); + while ( ihlModeName(i) != hlName ) + i++; + + m_doc->setHlMode(i); + } + + m_guessedCodeType = type; + + ViewList::iterator end = m_viewList.end(); + for ( ViewList::iterator it = m_viewList.begin(); it != end; ++it ) + { + if ( TextView * tv = dynamic_cast( (View*)*it ) ) + tv->initCodeActions(); + } +} + + +void TextDocument::formatAssembly() +{ + AsmFormatter formatter; + QStringList lines = QStringList::split( "\n", m_doc->text(), true ); + setText( formatter.tidyAsm(lines), false ); + setModified(true); +} + + +void TextDocument::fileSave( const KURL& url ) +{ + if ( m_doc->url().path() != url.path() ) + { + kdError() << k_funcinfo << "Error: Kate::View url and passed url do not match; cannot save." << endl; + return; + } + + if ( activeView() && (textView()->save() == Kate::View::SAVE_OK ) ) + saveDone(); +} + + +void TextDocument::fileSaveAs() +{ + if ( activeView() && (textView()->saveAs() == Kate::View::SAVE_OK) ) + saveDone(); + + // Our modified state may not have changed, but we emit this to force the + // main window to update our caption. + emit modifiedStateChanged(); +} + + +void TextDocument::saveDone() +{ + setURL( m_doc->url() ); + guessScheme(false); + setModified(false); + emit modifiedStateChanged(); +} + + +bool TextDocument::openURL( const KURL& url ) +{ + m_doc->openURL(url); + setURL(url); + + fileMetaInfo()->initializeFromMetaInfo( url.prettyURL(), this ); + guessScheme(); + +#ifndef NO_GPSIM + DebugManager::self()->urlOpened( this ); +#endif + + return true; +} + + +void TextDocument::setLastTextOutputTarget( TextDocument * target ) +{ + m_pLastTextOutputTarget = target; +} + + +QString TextDocument::outputFilePath( const QString &ext ) +{ + QString filePath = url().path(); + if ( filePath.isEmpty() ) + { + KTempFile f( QString::null, ext ); + (*f.textStream()) << m_doc->text(); + f.close(); + DocManager::self()->associateDocument( f.name(), this ); + return f.name(); + } + if ( isModified() ) + { + fileSave(); + } + return filePath; +} + + +void TextDocument::slotConvertTo( int target ) +{ + switch ( (ConvertToTarget)target ) + { + case TextDocument::MicrobeOutput: + break; + + case TextDocument::AssemblyOutput: + convertToAssembly(); + break; + + case TextDocument::HexOutput: + convertToHex(); + break; + + case TextDocument::PICOutput: + convertToPIC(); + break; + } +} + + +void TextDocument::convertToAssembly() +{ + QString filePath; + bool showPICSelect = false; + ProcessOptions::ProcessPath::MediaType toType; + + if ( m_guessedCodeType == TextDocument::ct_microbe ) + { + toType = ProcessOptions::ProcessPath::AssemblyAbsolute; + filePath = outputFilePath(".microbe"); + } + + else if ( m_guessedCodeType == TextDocument::ct_hex ) + { + toType = ProcessOptions::ProcessPath::Disassembly; + filePath = outputFilePath(".hex"); + } + + else if ( m_guessedCodeType == TextDocument::ct_c ) + { + toType = ProcessOptions::ProcessPath::AssemblyRelocatable; + filePath = outputFilePath(".c"); + showPICSelect = true; + } + + else + { + kdError() << "Could not get file type for converting to assembly!"<setAllowedAsmSet( AsmInfo::PIC14 | AsmInfo::PIC16 ); + + dlg.setOutputExtension(".asm"); + dlg.setFilter("*.asm *.src *.inc|Assembly Code (*.asm, *.src, *.inc)\n*|All Files"); + dlg.exec(); + if (!dlg.isAccepted()) + return; + + ProcessOptions o( dlg.info() ); + o.setTextOutputTarget( m_pLastTextOutputTarget, this, SLOT(setLastTextOutputTarget( TextDocument* )) ); + o.setInputFiles(filePath); + o.setProcessPath( ProcessOptions::ProcessPath::path( ProcessOptions::guessMediaType(filePath), toType ) ); + LanguageManager::self()->compile(o); +} + + +void TextDocument::convertToHex() +{ + QString filePath; + bool showPICSelect = false; + + if ( m_guessedCodeType == TextDocument::ct_microbe ) + filePath = outputFilePath(".microbe"); + + else if ( m_guessedCodeType == TextDocument::ct_asm ) + filePath = outputFilePath(".asm"); + + else if ( m_guessedCodeType == TextDocument::ct_c ) + { + filePath = outputFilePath(".c"); + showPICSelect = true; + } + + else + { + kdError() << "Could not get file type for converting to hex!"<setAllowedAsmSet( AsmInfo::PIC14 | AsmInfo::PIC16 ); + + dlg.exec(); + if (!dlg.isAccepted()) + return; + + ProcessOptions o( dlg.info() ); + o.setTextOutputTarget( m_pLastTextOutputTarget, this, SLOT(setLastTextOutputTarget( TextDocument* )) ); + o.setInputFiles(filePath); + o.setProcessPath( ProcessOptions::ProcessPath::path( ProcessOptions::guessMediaType(filePath), ProcessOptions::ProcessPath::Program ) ); + LanguageManager::self()->compile(o); +} + + +void TextDocument::convertToPIC() +{ + QString filePath; + + QString picID; + + switch ( m_guessedCodeType ) + { + case ct_microbe: + filePath = outputFilePath(".microbe"); + break; + + case ct_asm: + { + filePath = outputFilePath(".asm"); + AsmParser p( filePath ); + p.parse(); + picID = p.picID(); + break; + } + + case ct_c: + filePath = outputFilePath(".c"); + break; + + case ct_hex: + filePath = outputFilePath(".hex"); + break; + + case ct_unknown: + kdError() << "Could not get file type for converting to hex!"<microSelect()->setAllowedAsmSet( AsmInfo::PIC14 | AsmInfo::PIC16 ); + + dlg->exec(); + if ( !dlg->isAccepted() ) + { + dlg->deleteLater(); + return; + } + + ProcessOptions o; + dlg->initOptions( & o ); + o.setInputFiles( filePath ); + o.setProcessPath( ProcessOptions::ProcessPath::path( ProcessOptions::guessMediaType(filePath), ProcessOptions::ProcessPath::Pic ) ); + LanguageManager::self()->compile( o ); + + dlg->deleteLater(); +} + + +void TextDocument::print() +{ + KTextEditor::printInterface(m_doc)->print (); +} + + +void TextDocument::slotSelectionmChanged() +{ + p_ktechlab->action( "edit_cut" )->setEnabled( m_doc->hasSelection () ); + p_ktechlab->action( "edit_copy" )->setEnabled( m_doc->hasSelection () ); +} + + +IntList TextDocument::bookmarkList() const +{ + IntList bookmarkList; + + typedef QPtrList MarkList; + MarkList markList = m_doc->marks(); + + // Find out what marks need adding to our internal lists + for ( KTextEditor::Mark * mark = markList.first(); mark; mark = markList.next() ) + { + if ( mark->type & Bookmark ) + bookmarkList += mark->line; + } + + return bookmarkList; +} + + +void TextDocument::slotUpdateMarksInfo() +{ + if ( activeView() ) + textView()->slotUpdateMarksInfo(); + +#ifndef NO_GPSIM + syncBreakpoints(); +#endif + + // Update our list of bookmarks in the menu + p_ktechlab->unplugActionList("bookmark_actionlist"); + m_bookmarkActions.clear(); + + QPtrList markList = m_doc->marks(); + + // Find out what marks need adding to our internal lists + for ( KTextEditor::Mark * mark = markList.first(); mark; mark = markList.next() ) + { + if ( mark->type & Bookmark ) + { + KAction * a = new KAction( i18n("%1 - %2").arg( QString::number( mark->line+1 ) ).arg( m_doc->textLine(mark->line) ), + 0, this, SLOT(slotBookmarkRequested()), this, + QString("bookmark_%1").arg(QString::number(mark->line).ascii()) ); + m_bookmarkActions.append(a); + } + } + + p_ktechlab->plugActionList( "bookmark_actionlist", m_bookmarkActions ); +} + + +void TextDocument::slotBookmarkRequested() +{ + const QObject * s = sender(); + if (!s) return; + + QString name = s->name(); + if ( !name.startsWith("bookmark_") ) + return; + + name.remove("bookmark_"); + int line = -1; + bool ok; + line = name.toInt(&ok); + if ( ok && line >= 0 && activeView() ) + (static_cast(activeView()))->gotoLine(line); +} + + +void TextDocument::setBookmarks( const IntList &lines ) +{ + clearBookmarks(); + const IntList::const_iterator end = lines.end(); + for ( IntList::const_iterator it = lines.begin(); it != end; ++it ) + setBookmark( *it, true ); +} + + +void TextDocument::clearBookmarks() +{ + QPtrList markList = m_doc->marks(); + + // Find out what marks need adding to our internal lists + for ( KTextEditor::Mark * mark = markList.first(); mark; mark = markList.next() ) + { + if ( mark->type & Bookmark ) + m_doc->removeMark( mark->line, Bookmark ); + } + + slotUpdateMarksInfo(); +} + + +void TextDocument::setBookmark( uint line, bool isBookmark ) +{ + if (isBookmark) + m_doc->addMark( line, Bookmark ); + + else + m_doc->removeMark( line, Bookmark ); +} + + +void TextDocument::setBreakpoints( const IntList &lines ) +{ +#ifndef NO_GPSIM + clearBreakpoints(); + const IntList::const_iterator end = lines.end(); + for ( IntList::const_iterator it = lines.begin(); it != end; ++it ) + setBreakpoint( *it, true ); +#endif // !NO_GPSIM +} + + +IntList TextDocument::breakpointList() const +{ + IntList breakpointList; + +#ifndef NO_GPSIM + typedef QPtrList MarkList; + MarkList markList = m_doc->marks(); + + // Find out what marks need adding to our internal lists + for ( KTextEditor::Mark * mark = markList.first(); mark; mark = markList.next() ) + { + if ( mark->type & Breakpoint ) + breakpointList += mark->line; + } +#endif // !NO_GPSIM + + return breakpointList; +} + + +void TextDocument::setBreakpoint( uint line, bool isBreakpoint ) +{ +#ifndef NO_GPSIM + if (isBreakpoint) + { + m_doc->addMark( line, Breakpoint ); + if (m_pDebugger) + m_pDebugger->setBreakpoint( m_debugFile, line, true ); + } + else + { + m_doc->removeMark( line, Breakpoint ); + if (m_pDebugger) + m_pDebugger->setBreakpoint( m_debugFile, line, false ); + } +#endif // !NO_GPSIM +} + + +void TextDocument::debugRun() +{ +#ifndef NO_GPSIM + if (m_pDebugger) + { + m_pDebugger->gpsim()->setRunning(true); + slotInitDebugActions(); + return; + } + + switch ( guessedCodeType() ) + { + case ct_unknown: + KMessageBox::sorry( 0l, i18n("Unknown code type."), i18n("Cannot debug") ); + return; + + case ct_hex: + KMessageBox::sorry( 0l, i18n("Cannot debug hex."), i18n("Cannot debug") ); + return; + + case ct_microbe: + m_bLoadDebuggerAsHLL = true; + m_debugFile = outputFilePath(".microbe"); + break; + + case ct_asm: + m_bLoadDebuggerAsHLL = false; + m_debugFile = outputFilePath(".asm"); + break; + + case ct_c: + m_bLoadDebuggerAsHLL = true; + m_debugFile = outputFilePath(".c"); + break; + } + + m_symbolFile = GpsimProcessor::generateSymbolFile( m_debugFile, this, SLOT(slotCODCreationSucceeded()), SLOT(slotCODCreationFailed()) ); +#endif // !NO_GPSIM +} + + +void TextDocument::debugInterrupt() +{ +#ifndef NO_GPSIM + if (!m_pDebugger) + return; + + m_pDebugger->gpsim()->setRunning(false); + slotInitDebugActions(); +#endif // !NO_GPSIM +} + + +void TextDocument::debugStop() +{ +#ifndef NO_GPSIM + if ( !m_pDebugger || !m_bOwnDebugger ) + return; + + m_pDebugger->gpsim()->deleteLater(); + m_pDebugger = 0l; + slotDebugSetCurrentLine( SourceLine() ); + slotInitDebugActions(); +#endif // !NO_GPSIM +} + + +void TextDocument::debugStep() +{ +#ifndef NO_GPSIM + if (!m_pDebugger) + return; + + m_pDebugger->stepInto(); +#endif // !NO_GPSIM +} + + +void TextDocument::debugStepOver() +{ +#ifndef NO_GPSIM + if (!m_pDebugger) + return; + + m_pDebugger->stepOver(); +#endif // !NO_GPSIM +} + + +void TextDocument::debugStepOut() +{ +#ifndef NO_GPSIM + if (!m_pDebugger) + return; + + m_pDebugger->stepOut(); +#endif // !NO_GPSIM +} + + +void TextDocument::slotDebugSetCurrentLine( const SourceLine & line ) +{ +#ifndef NO_GPSIM + int textLine = line.line(); + + if ( DocManager::self()->findDocument( line.fileName() ) != this ) + textLine = -1; + + m_doc->removeMark( m_lastDebugLineAt, ExecutionPoint ); + m_doc->addMark( textLine, ExecutionPoint ); + + if ( activeView() ) + textView()->setCursorPosition( textLine, 0 ); + + m_lastDebugLineAt = textLine; +#endif // !NO_GPSIM +} + + +void TextDocument::slotInitDebugActions() +{ +#ifndef NO_GPSIM + if ( m_pDebugger ) + { + if ( m_pDebugger->gpsim()->isRunning() ) + slotDebugSetCurrentLine( SourceLine() ); + else + slotDebugSetCurrentLine( m_pDebugger->currentLine() ); + } + + if ( activeView() ) + textView()->slotInitDebugActions(); +#endif // !NO_GPSIM +} + + +void TextDocument::slotCODCreationSucceeded() +{ +#ifndef NO_GPSIM + GpsimProcessor * gpsim = new GpsimProcessor( m_symbolFile, this ); + + if (m_bLoadDebuggerAsHLL) + gpsim->setDebugMode( GpsimDebugger::HLLDebugger ); + else + gpsim->setDebugMode( GpsimDebugger::AsmDebugger ); + + setDebugger( gpsim->currentDebugger(), true ); +#endif // !NO_GPSIM +} +void TextDocument::slotCODCreationFailed() +{ +#ifndef NO_GPSIM + m_debugFile = QString::null; + m_symbolFile = QString::null; +#endif // !NO_GPSIM +} + + +void TextDocument::slotDebuggerDestroyed() +{ +#ifndef NO_GPSIM + slotDebugSetCurrentLine( SourceLine() ); + m_pDebugger = 0l; + m_debugFile = QString::null; + slotInitDebugActions(); +#endif // !NO_GPSIM +} + + +#ifndef NO_GPSIM +void TextDocument::clearBreakpoints() +{ + QPtrList markList = m_doc->marks(); + + // Find out what marks need adding to our internal lists + for ( KTextEditor::Mark * mark = markList.first(); mark; mark = markList.next() ) + { + if ( mark->type & Bookmark ) + m_doc->removeMark( mark->line, Breakpoint ); + } + + slotUpdateMarksInfo(); +} + + +void TextDocument::syncBreakpoints() +{ + if (b_lockSyncBreakpoints) + return; + + // We don't really care about synching marks if we aren't debugging / aren't able to take use of the marks + if (!m_pDebugger) + return; + + b_lockSyncBreakpoints = true; + + typedef QPtrList MarkList; + MarkList markList = m_doc->marks(); + + IntList bpList; + + // Find out what marks need adding to our internal lists + for ( KTextEditor::Mark * mark = markList.first(); mark; mark = markList.next() ) + { + const int line = mark->line; + + if ( mark->type & Breakpoint ) + bpList.append(line); + + if ( mark->type == ExecutionPoint ) + m_lastDebugLineAt = line; + } + + m_pDebugger->setBreakpoints( m_debugFile, bpList ); + + b_lockSyncBreakpoints = false; +} + + +bool TextDocument::debuggerIsRunning() const +{ + return m_pDebugger; +} + + +bool TextDocument::debuggerIsStepping() const +{ + return m_pDebugger && !m_pDebugger->gpsim()->isRunning(); +} + + +void TextDocument::setDebugger( GpsimDebugger * debugger, bool ownDebugger ) +{ + if ( debugger == m_pDebugger ) + return; + + // If we create a gpsim, then we may get called by DebugManager, which will + // try to claim we don't own it. So if we have a symbol file waiting, thne + // wait until we are called from its successful creation + if ( !m_symbolFile.isEmpty() && !ownDebugger ) + return; + + // Reset it for use next time + m_symbolFile = QString::null; + + if (m_bOwnDebugger) + delete m_pDebugger; + + m_pDebugger = debugger; + m_bOwnDebugger = ownDebugger; + + if (!m_pDebugger) + return; + + if ( m_debugFile.isEmpty() ) + m_debugFile = url().path(); + + connect( m_pDebugger, SIGNAL(destroyed()), this, SLOT(slotDebuggerDestroyed()) ); + connect( m_pDebugger->gpsim(), SIGNAL(runningStatusChanged(bool )), this, SLOT(slotInitDebugActions()) ); + connect( m_pDebugger, SIGNAL(lineReached(const SourceLine &)), this, SLOT(slotDebugSetCurrentLine(const SourceLine &)) ); + m_pDebugger->setBreakpoints( m_debugFile, breakpointList() ); + + slotInitDebugActions(); + if ( !m_pDebugger->gpsim()->isRunning() ) + slotDebugSetCurrentLine( m_pDebugger->currentLine() ); + + if ( this == dynamic_cast(DocManager::self()->getFocusedDocument()) ) + SymbolViewer::self()->setContext( m_pDebugger->gpsim() ); +} +#endif // !NO_GPSIM + + +const QPixmap* TextDocument::inactiveBreakpointPixmap() +{ + const char*breakpoint_gr_xpm[]={ + "11 16 6 1", + "c c #c6c6c6", + "d c #2c2c2c", + "# c #000000", + ". c None", + "a c #ffffff", + "b c #555555", + "...........", + "...........", + "...#####...", + "..#aaaaa#..", + ".#abbbbbb#.", + "#abbbbbbbb#", + "#abcacacbd#", + "#abbbbbbbb#", + "#abcacacbd#", + "#abbbbbbbb#", + ".#bbbbbbb#.", + "..#bdbdb#..", + "...#####...", + "...........", + "...........", + "..........."}; + static QPixmap pixmap( breakpoint_gr_xpm ); + return &pixmap; +} + + +const QPixmap* TextDocument::activeBreakpointPixmap() +{ + const char* breakpoint_xpm[]={ + "11 16 6 1", + "c c #c6c6c6", + ". c None", + "# c #000000", + "d c #840000", + "a c #ffffff", + "b c #ff0000", + "...........", + "...........", + "...#####...", + "..#aaaaa#..", + ".#abbbbbb#.", + "#abbbbbbbb#", + "#abcacacbd#", + "#abbbbbbbb#", + "#abcacacbd#", + "#abbbbbbbb#", + ".#bbbbbbb#.", + "..#bdbdb#..", + "...#####...", + "...........", + "...........", + "..........."}; + static QPixmap pixmap( breakpoint_xpm ); + return &pixmap; +} + + + +const QPixmap* TextDocument::reachedBreakpointPixmap() +{ + const char*breakpoint_bl_xpm[]={ + "11 16 7 1", + "a c #c0c0ff", + "# c #000000", + "c c #0000c0", + "e c #0000ff", + "b c #dcdcdc", + "d c #ffffff", + ". c None", + "...........", + "...........", + "...#####...", + "..#ababa#..", + ".#bcccccc#.", + "#acccccccc#", + "#bcadadace#", + "#acccccccc#", + "#bcadadace#", + "#acccccccc#", + ".#ccccccc#.", + "..#cecec#..", + "...#####...", + "...........", + "...........", + "..........."}; + static QPixmap pixmap( breakpoint_bl_xpm ); + return &pixmap; +} + + +const QPixmap* TextDocument::disabledBreakpointPixmap() +{ + const char*breakpoint_wh_xpm[]={ + "11 16 7 1", + "a c #c0c0ff", + "# c #000000", + "c c #0000c0", + "e c #0000ff", + "b c #dcdcdc", + "d c #ffffff", + ". c None", + "...........", + "...........", + "...#####...", + "..#ddddd#..", + ".#ddddddd#.", + "#ddddddddd#", + "#ddddddddd#", + "#ddddddddd#", + "#ddddddddd#", + "#ddddddddd#", + ".#ddddddd#.", + "..#ddddd#..", + "...#####...", + "...........", + "...........", + "..........."}; + static QPixmap pixmap( breakpoint_wh_xpm ); + return &pixmap; +} + + +const QPixmap* TextDocument::executionPointPixmap() +{ + const char*exec_xpm[]={ + "11 16 4 1", + "a c #00ff00", + "b c #000000", + ". c None", + "# c #00c000", + "...........", + "...........", + "...........", + "#a.........", + "#aaa.......", + "#aaaaa.....", + "#aaaaaaa...", + "#aaaaaaaaa.", + "#aaaaaaa#b.", + "#aaaaa#b...", + "#aaa#b.....", + "#a#b.......", + "#b.........", + "...........", + "...........", + "..........."}; + static QPixmap pixmap( exec_xpm ); + return &pixmap; +} + +#include "textdocument.moc" -- cgit v1.2.1