Logo Search packages:      
Sourcecode: ktechlab version File versions

textdocument.cpp

/***************************************************************************
 *   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 <kate/katedocument.h>

#include <kdebug.h>
#include <klibloader.h>
#include <klocale.h>
#include <kmessagebox.h>
#include <ktempfile.h>


00037 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<TextView*>( (View*)*it) )
            {
                  Kate::View * kv = tv->kateView();
                  p_ktechlab->factory()->removeClient( kv );
            }
      }
      
      delete m_doc;
      m_doc = 0l;
      
      delete m_pDocumentIface;
      m_pDocumentIface = 0l;
}


00119 bool TextDocument::fileClose()
{
      const QString path = url().prettyURL();
      if ( !path.isEmpty() )
            fileMetaInfo()->grabMetaInfo( path, this );
      
      return Document::fileClose();
}


00129 TextView* TextDocument::textView() const
{
      return static_cast<TextView*>(activeView());
}


00135 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<Kate::View*>((m_doc->createView( parent, name ))->qt_cast("Kate::View"));
}


00152 void TextDocument::cut()
{
      if (textView())
            textView()->cut();
}
00157 void TextDocument::copy()
{
      if (textView())
            textView()->copy();
}
00162 void TextDocument::paste()
{
      if (textView())
            textView()->paste();
}


00169 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<TextView*>((View*)*it))->saveCursorPosition();
            
      m_doc->setText(text);
      
      for ( ViewList::iterator it = m_viewList.begin(); it != end; ++it )
            (static_cast<TextView*>((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()) );
      }
}


00200 void TextDocument::undo()
{
      m_doc->undo();
      slotSyncModifiedStates();
}


00207 void TextDocument::redo()
{
      m_doc->redo();
      slotSyncModifiedStates();
}


void TextDocument::slotSyncModifiedStates()
{
      setModified( m_doc->isModified() );
}
00218 void TextDocument::setModified( bool modified )
{
      if ( (modified == b_modified) && (modified == isModified()) ) {
            return;
      }
      m_doc->setModified(modified);
      b_modified = modified;
      
      emit modifiedStateChanged();
}


00230 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 ( i<hlModeCount && m_doc->hlModeName(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<TextView*>( (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();
}


00324 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();
}


00344 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;
}


00366 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;
}


00385 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!"<<endl;
            return;
      }
      
      OutputMethodDlg dlg( i18n("Assembly Code Output"), url(), showPICSelect, p_ktechlab );
      
      if ( m_guessedCodeType == TextDocument::ct_c )
            dlg.microSelect()->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!"<<endl;
            return;
      }
      
      OutputMethodDlg dlg( i18n("Hex Code Output"), url(), showPICSelect, p_ktechlab );
      dlg.setOutputExtension(".hex");
      dlg.setFilter("*.hex|Hex (*.hex)\n*|All Files");
      
      if ( m_guessedCodeType == TextDocument::ct_c )
            dlg.microSelect()->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!"<<endl;
                  return;
      }
      
      ProgrammerDlg * dlg = new ProgrammerDlg( picID, (QWidget*)p_ktechlab, "Programmer Dlg" );
      
      if ( m_guessedCodeType == TextDocument::ct_c )
            dlg->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();
}


00555 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 () );
}


00568 IntList TextDocument::bookmarkList() const
{
      IntList bookmarkList;
      
      typedef QPtrList<KTextEditor::Mark> 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;
}


00586 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<KTextEditor::Mark> 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<TextView*>(activeView()))->gotoLine(line);
}


00635 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<KTextEditor::Mark> 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();
}


00659 void TextDocument::setBookmark( uint line, bool isBookmark )
{
      if (isBookmark)
            m_doc->addMark( line, Bookmark );
      
      else
            m_doc->removeMark( line, Bookmark );
}


00669 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
}


00680 IntList TextDocument::breakpointList() const
{
      IntList breakpointList;
      
#ifndef NO_GPSIM
      typedef QPtrList<KTextEditor::Mark> 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;
}


00700 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
}


00838 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<KTextEditor::Mark> 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();
}


00904 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<KTextEditor::Mark> 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;
}


00938 bool TextDocument::debuggerIsRunning() const
{
      return m_pDebugger;
}


00944 bool TextDocument::debuggerIsStepping() const
{
      return m_pDebugger && !m_pDebugger->gpsim()->isRunning();
}


00950 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<TextDocument*>(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"

Generated by  Doxygen 1.6.0   Back to index