Skip to main content :: ::

KDE API Reference

:: Skip to Link Menu

/ API Reference / kate

katedocument.cpp /* This file is part of the KDE libraries Copyright (C) 2001-2004 Christoph Cullmann <cullmann@kde.org> Copyright (C) 2001 Joseph Wenninger <jowenn@kde.org> Copyright (C) 1999 Jochen Wilhelmy <digisnap@cs.tu-berlin.de> This library is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License version 2 as published by the Free Software Foundation. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Library General Public License for more details. You should have received a copy of the GNU Library General Public License along with this library; see the file COPYING.LIB. If not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-13020, USA. */ //BEGIN includes #include "katedocument.h" #include "katedocument.moc" #include "katekeyinterceptorfunctor.h" #include "katefactory.h" #include "katedialogs.h" #include "katehighlight.h" #include "kateview.h" #include "katesearch.h" #include "kateautoindent.h" #include "katetextline.h" #include "katedocumenthelpers.h" #include "kateprinter.h" #include "katelinerange.h" #include "katesupercursor.h" #include "katearbitraryhighlight.h" #include "katerenderer.h" #include "kateattribute.h" #include "kateconfig.h" #include "katefiletype.h" #include "kateschema.h" #include "katetemplatehandler.h" #include <ktexteditor/plugin.h> #include <kio/job.h> #include <kio/netaccess.h> #include <kio/kfileitem.h> #include <kparts/event.h> #include <klocale.h> #include <kglobal.h> #include <kapplication.h> #include <kpopupmenu.h> #include <kconfig.h> #include <kfiledialog.h> #include <kmessagebox.h> #include <kstdaction.h> #include <kiconloader.h> #include <kxmlguifactory.h> #include <kdialogbase.h> #include <kdebug.h> #include <kglobalsettings.h> #include <klibloader.h> #include <kdirwatch.h> #include <kwin.h> #include <kencodingfiledialog.h> #include <ktempfile.h> #include <kmdcodec.h> #include <qtimer.h> #include <qfile.h> #include <qclipboard.h> #include <qtextstream.h> #include <qtextcodec.h> #include <qmap.h> //END includes //BEGIN PRIVATE CLASSES class KatePartPluginItem { public: KTextEditor::Plugin *plugin; }; //END PRIVATE CLASSES //BEGIN d'tor, c'tor // // KateDocument Constructor // KateDocument::KateDocument ( bool bSingleViewMode, bool bBrowserView, bool bReadOnly, QWidget *parentWidget, const char *widgetName, QObject *parent, const char *name) : Kate::Document(parent, name), m_plugins (KateFactory::self()->plugins().count()), m_undoDontMerge(false), m_undoIgnoreCancel(false), lastUndoGroupWhenSaved( 0 ), docWasSavedWhenUndoWasEmpty( true ), m_modOnHd (false), m_modOnHdReason (0), m_job (0), m_tempFile (0), m_tabInterceptor(0) { m_undoComplexMerge=false; m_isInUndo = false; // my dcop object setObjId ("KateDocument#"+documentDCOPSuffix()); // ktexteditor interfaces setBlockSelectionInterfaceDCOPSuffix (documentDCOPSuffix()); setConfigInterfaceDCOPSuffix (documentDCOPSuffix()); setConfigInterfaceExtensionDCOPSuffix (documentDCOPSuffix()); setCursorInterfaceDCOPSuffix (documentDCOPSuffix()); setEditInterfaceDCOPSuffix (documentDCOPSuffix()); setEncodingInterfaceDCOPSuffix (documentDCOPSuffix()); setHighlightingInterfaceDCOPSuffix (documentDCOPSuffix()); setMarkInterfaceDCOPSuffix (documentDCOPSuffix()); setMarkInterfaceExtensionDCOPSuffix (documentDCOPSuffix()); setPrintInterfaceDCOPSuffix (documentDCOPSuffix()); setSearchInterfaceDCOPSuffix (documentDCOPSuffix()); setSelectionInterfaceDCOPSuffix (documentDCOPSuffix()); setSelectionInterfaceExtDCOPSuffix (documentDCOPSuffix()); setSessionConfigInterfaceDCOPSuffix (documentDCOPSuffix()); setUndoInterfaceDCOPSuffix (documentDCOPSuffix()); setWordWrapInterfaceDCOPSuffix (documentDCOPSuffix()); // init local plugin array m_plugins.fill (0); // register doc at factory KateFactory::self()->registerDocument (this); m_reloading = false; m_loading = false; m_encodingSticky = false; m_buffer = new KateBuffer (this); // init the config object, be careful not to use it // until the initial readConfig() call is done m_config = new KateDocumentConfig (this); // init some more vars ! m_activeView = 0L; hlSetByUser = false; m_fileType = -1; m_fileTypeSetByUser = false; setInstance( KateFactory::self()->instance() ); editSessionNumber = 0; editIsRunning = false; m_editCurrentUndo = 0L; editWithUndo = false; m_docNameNumber = 0; m_bSingleViewMode = bSingleViewMode; m_bBrowserView = bBrowserView; m_bReadOnly = bReadOnly; m_marks.setAutoDelete( true ); m_markPixmaps.setAutoDelete( true ); m_markDescriptions.setAutoDelete( true ); setMarksUserChangable( markType01 ); m_undoMergeTimer = new QTimer(this); connect(m_undoMergeTimer, SIGNAL(timeout()), SLOT(undoCancel())); clearMarks (); clearUndo (); clearRedo (); setModified (false); docWasSavedWhenUndoWasEmpty = true; // normal hl m_buffer->setHighlight (0); m_extension = new KateBrowserExtension( this ); m_arbitraryHL = new KateArbitraryHighlight(); m_indenter = KateAutoIndent::createIndenter ( this, 0 ); m_indenter->updateConfig (); // some nice signals from the buffer connect(m_buffer, SIGNAL(tagLines(int,int)), this, SLOT(tagLines(int,int))); connect(m_buffer, SIGNAL(codeFoldingUpdated()),this,SIGNAL(codeFoldingUpdated())); // if the user changes the highlight with the dialog, notify the doc connect(KateHlManager::self(),SIGNAL(changed()),SLOT(internalHlChanged())); // signal for the arbitrary HL connect(m_arbitraryHL, SIGNAL(tagLines(KateView*, KateSuperRange*)), SLOT(tagArbitraryLines(KateView*, KateSuperRange*))); // signals for mod on hd connect( KateFactory::self()->dirWatch(), SIGNAL(dirty (const QString &)), this, SLOT(slotModOnHdDirty (const QString &)) ); connect( KateFactory::self()->dirWatch(), SIGNAL(created (const QString &)), this, SLOT(slotModOnHdCreated (const QString &)) ); connect( KateFactory::self()->dirWatch(), SIGNAL(deleted (const QString &)), this, SLOT(slotModOnHdDeleted (const QString &)) ); // update doc name setDocName (""); // if single view mode, like in the konqui embedding, create a default view ;) if ( m_bSingleViewMode ) { KTextEditor::View *view = createView( parentWidget, widgetName ); insertChildClient( view ); view->show(); setWidget( view ); } connect(this,SIGNAL(sigQueryClose(bool *, bool*)),this,SLOT(slotQueryClose_save(bool *, bool*))); m_isasking = 0; // plugins for (uint i=0; i<KateFactory::self()->plugins().count(); i++) { if (config()->plugin (i)) loadPlugin (i); } } // // KateDocument Destructor // KateDocument::~KateDocument() { // remove file from dirwatch deactivateDirWatch (); if (!singleViewMode()) { // clean up remaining views m_views.setAutoDelete( true ); m_views.clear(); } delete m_editCurrentUndo; delete m_arbitraryHL; // cleanup the undo items, very important, truee :/ undoItems.setAutoDelete(true); undoItems.clear(); // clean up plugins unloadAllPlugins (); delete m_config; delete m_indenter; KateFactory::self()->deregisterDocument (this); } //END //BEGIN Plugins void KateDocument::unloadAllPlugins () { for (uint i=0; i<m_plugins.count(); i++) unloadPlugin (i); } void KateDocument::enableAllPluginsGUI (KateView *view) { for (uint i=0; i<m_plugins.count(); i++) enablePluginGUI (m_plugins[i], view); } void KateDocument::disableAllPluginsGUI (KateView *view) { for (uint i=0; i<m_plugins.count(); i++) disablePluginGUI (m_plugins[i], view); } void KateDocument::loadPlugin (uint pluginIndex) { if (m_plugins[pluginIndex]) return; m_plugins[pluginIndex] = KTextEditor::createPlugin (QFile::encodeName((KateFactory::self()->plugins())[pluginIndex]->library()), this); enablePluginGUI (m_plugins[pluginIndex]); } void KateDocument::unloadPlugin (uint pluginIndex) { if (!m_plugins[pluginIndex]) return; disablePluginGUI (m_plugins[pluginIndex]); delete m_plugins[pluginIndex]; m_plugins[pluginIndex] = 0L; } void KateDocument::enablePluginGUI (KTextEditor::Plugin *plugin, KateView *view) { if (!plugin) return; if (!KTextEditor::pluginViewInterface(plugin)) return; KXMLGUIFactory *factory = view->factory(); if ( factory ) factory->removeClient( view ); KTextEditor::pluginViewInterface(plugin)->addView(view); if ( factory ) factory->addClient( view ); } void KateDocument::enablePluginGUI (KTextEditor::Plugin *plugin) { if (!plugin) return; if (!KTextEditor::pluginViewInterface(plugin)) return; for (uint i=0; i< m_views.count(); i++) enablePluginGUI (plugin, m_views.at(i)); } void KateDocument::disablePluginGUI (KTextEditor::Plugin *plugin, KateView *view) { if (!plugin) return; if (!KTextEditor::pluginViewInterface(plugin)) return; KXMLGUIFactory *factory = view->factory(); if ( factory ) factory->removeClient( view ); KTextEditor::pluginViewInterface( plugin )->removeView( view ); if ( factory ) factory->addClient( view ); } void KateDocument::disablePluginGUI (KTextEditor::Plugin *plugin) { if (!plugin) return; if (!KTextEditor::pluginViewInterface(plugin)) return; for (uint i=0; i< m_views.count(); i++) disablePluginGUI (plugin, m_views.at(i)); } //END //BEGIN KTextEditor::Document stuff KTextEditor::View *KateDocument::createView( QWidget *parent, const char *name ) { KateView* newView = new KateView( this, parent, name); connect(newView, SIGNAL(cursorPositionChanged()), SLOT(undoCancel())); if ( s_fileChangedDialogsActivated ) connect( newView, SIGNAL(gotFocus( Kate::View * )), this, SLOT(slotModifiedOnDisk()) ); return newView; } QPtrList<KTextEditor::View> KateDocument::views () const { return m_textEditViews; } void KateDocument::setActiveView( KateView *view ) { if ( m_activeView == view ) return; m_activeView = view; } //END //BEGIN KTextEditor::ConfigInterfaceExtension stuff uint KateDocument::configPages () const { return 10; } KTextEditor::ConfigPage *KateDocument::configPage (uint number, QWidget *parent, const char * ) { switch( number ) { case 0: return new KateViewDefaultsConfig (parent); case 1: return new KateSchemaConfigPage (parent, this); case 2: return new KateSelectConfigTab (parent); case 3: return new KateEditConfigTab (parent); case 4: return new KateIndentConfigTab (parent); case 5: return new KateSaveConfigTab (parent); case 6: return new KateHlConfigPage (parent, this); case 7: return new KateFileTypeConfigTab (parent); case 8: return new KateEditKeyConfiguration (parent, this); case 9: return new KatePartPluginConfigPage (parent); default: return 0; } return 0; } QString KateDocument::configPageName (uint number) const { switch( number ) { case 0: return i18n ("Appearance"); case 1: return i18n ("Fonts & Colors"); case 2: return i18n ("Cursor & Selection"); case 3: return i18n ("Editing"); case 4: return i18n ("Indentation"); case 5: return i18n("Open/Save"); case 6: return i18n ("Highlighting"); case 7: return i18n("Filetypes"); case 8: return i18n ("Shortcuts"); case 9: return i18n ("Plugins"); default: return QString (""); } return QString (""); } QString KateDocument::configPageFullName (uint number) const { switch( number ) { case 0: return i18n("Appearance"); case 1: return i18n ("Font & Color Schemas"); case 2: return i18n ("Cursor & Selection Behavior"); case 3: return i18n ("Editing Options"); case 4: return i18n ("Indentation Rules"); case 5: return i18n("File Opening & Saving"); case 6: return i18n ("Highlighting Rules"); case 7: return i18n("Filetype Specific Settings"); case 8: return i18n ("Shortcuts Configuration"); case 9: return i18n ("Plugin Manager"); default: return QString (""); } return QString (""); } QPixmap KateDocument::configPagePixmap (uint number, int size) const { switch( number ) { case 0: return BarIcon("view_text",size); case 1: return BarIcon("colorize", size); case 2: return BarIcon("frame_edit", size); case 3: return BarIcon("edit", size); case 4: return BarIcon("rightjust", size); case 5: return BarIcon("filesave", size); case 6: return BarIcon("source", size); case 7: return BarIcon("edit", size); case 8: return BarIcon("key_enter", size); case 9: return BarIcon("connect_established", size); default: return BarIcon("edit", size); } return BarIcon("edit", size); } //END //BEGIN KTextEditor::EditInterface stuff QString KateDocument::text() const { QString s; for (uint i = 0; i < m_buffer->count(); i++) { KateTextLine::Ptr textLine = m_buffer->plainLine(i); if (textLine) { s.append (textLine->string()); if ((i+1) < m_buffer->count()) s.append('\n'); } } return s; } QString KateDocument::text ( uint startLine, uint startCol, uint endLine, uint endCol ) const { return text(startLine, startCol, endLine, endCol, false); } QString KateDocument::text ( uint startLine, uint startCol, uint endLine, uint endCol, bool blockwise) const { if ( blockwise && (startCol > endCol) ) return QString (); QString s; if (startLine == endLine) { if (startCol > endCol) return QString (); KateTextLine::Ptr textLine = m_buffer->plainLine(startLine); if ( !textLine ) return QString (); return textLine->string(startCol, endCol-startCol); } else { for (uint i = startLine; (i <= endLine) && (i < m_buffer->count()); i++) { KateTextLine::Ptr textLine = m_buffer->plainLine(i); if ( !blockwise ) { if (i == startLine) s.append (textLine->string(startCol, textLine->length()-startCol)); else if (i == endLine) s.append (textLine->string(0, endCol)); else s.append (textLine->string()); } else { s.append( textLine->string( startCol, endCol-startCol)); } if ( i < endLine ) s.append('\n'); } } return s; } QString KateDocument::textLine( uint line ) const { KateTextLine::Ptr l = m_buffer->plainLine(line); if (!l) return QString(); return l->string(); } bool KateDocument::setText(const QString &s) { if (!isReadWrite()) return false; QPtrList<KTextEditor::Mark> m = marks (); QValueList<KTextEditor::Mark> msave; for (uint i=0; i < m.count(); i++) msave.append (*m.at(i)); editStart (); // delete the text clear(); // insert the new text insertText (0, 0, s); editEnd (); for (uint i=0; i < msave.count(); i++) setMark (msave[i].line, msave[i].type); return true; } bool KateDocument::clear() { if (!isReadWrite()) return false; for (KateView * view = m_views.first(); view != 0L; view = m_views.next() ) { view->clear(); view->tagAll(); view->update(); } clearMarks (); return removeText (0,0,lastLine()+1, 0); } bool KateDocument::insertText( uint line, uint col, const QString &s) { return insertText (line, col, s, false); } bool KateDocument::insertText( uint line, uint col, const QString &s, bool blockwise ) { if (!isReadWrite()) return false; if (s.isEmpty()) return true; if (line == numLines()) editInsertLine(line,""); else if (line > lastLine()) return false; editStart (); uint insertPos = col; uint len = s.length(); QString buf; bool replacetabs = ( config()->configFlags() & KateDocumentConfig::cfReplaceTabsDyn && ! m_isInUndo ); uint tw = config()->tabWidth(); uint insertPosExpanded = insertPos; KateTextLine::Ptr l = m_buffer->line( line ); if (l != 0) insertPosExpanded = l->cursorX( insertPos, tw ); for (uint pos = 0; pos < len; pos++) { QChar ch = s[pos]; if (ch == '\n') { editInsertText (line, insertPos, buf); if ( !blockwise ) { editWrapLine (line, insertPos + buf.length()); insertPos = insertPosExpanded = 0; } else { if ( line == lastLine() ) editWrapLine (line, insertPos + buf.length()); } line++; buf.truncate(0); l = m_buffer->line( line ); if (l) insertPosExpanded = l->cursorX( insertPos, tw ); } else { if ( replacetabs && ch == '\t' ) { uint tr = tw - ( insertPosExpanded+buf.length() )%tw; for ( uint i=0; i < tr; i++ ) buf += ' '; } else buf += ch; // append char to buffer } } editInsertText (line, insertPos, buf); editEnd (); emit textInserted(line,insertPos); return true; } bool KateDocument::removeText ( uint startLine, uint startCol, uint endLine, uint endCol ) { return removeText (startLine, startCol, endLine, endCol, false); } bool KateDocument::removeText ( uint startLine, uint startCol, uint endLine, uint endCol, bool blockwise) { if (!isReadWrite()) return false; if ( blockwise && (startCol > endCol) ) return false; if ( startLine > endLine ) return false; if ( startLine > lastLine() ) return false; if (!blockwise) { emit aboutToRemoveText(KateTextRange(startLine,startCol,endLine,endCol)); } editStart (); if ( !blockwise ) { if ( endLine > lastLine() ) { endLine = lastLine()+1; endCol = 0; } if (startLine == endLine) { editRemoveText (startLine, startCol, endCol-startCol); } else if ((startLine+1) == endLine) { if ( (m_buffer->plainLine(startLine)->length()-startCol) > 0 ) editRemoveText (startLine, startCol, m_buffer->plainLine(startLine)->length()-startCol); editRemoveText (startLine+1, 0, endCol); editUnWrapLine (startLine); } else { for (uint line = endLine; line >= startLine; line--) { if ((line > startLine) && (line < endLine)) { editRemoveLine (line); } else { if (line == endLine) { if ( endLine <= lastLine() ) editRemoveText (line, 0, endCol); } else { if ( (m_buffer->plainLine(line)->length()-startCol) > 0 ) editRemoveText (line, startCol, m_buffer->plainLine(line)->length()-startCol); editUnWrapLine (startLine); } } if ( line == 0 ) break; } } } // if ( ! blockwise ) else { if ( endLine > lastLine() ) endLine = lastLine (); for (uint line = endLine; line >= startLine; line--) { editRemoveText (line, startCol, endCol-startCol); if ( line == 0 ) break; } } editEnd (); emit textRemoved(); return true; } bool KateDocument::insertLine( uint l, const QString &str ) { if (!isReadWrite()) return false; if (l > numLines()) return false; return editInsertLine (l, str); } bool KateDocument::removeLine( uint line ) { if (!isReadWrite()) return false; if (line > lastLine()) return false; return editRemoveLine (line); } uint KateDocument::length() const { uint l = 0; for (uint i = 0; i < m_buffer->count(); i++) { KateTextLine::Ptr line = m_buffer->plainLine(i); if (line) l += line->length(); } return l; } uint KateDocument::numLines() const { return m_buffer->count(); } uint KateDocument::numVisLines() const { return m_buffer->countVisible (); } int KateDocument::lineLength ( uint line ) const { KateTextLine::Ptr l = m_buffer->plainLine(line); if (!l) return -1; return l->length(); } //END //BEGIN KTextEditor::EditInterface internal stuff // // Starts an edit session with (or without) undo, update of view disabled during session // void KateDocument::editStart (bool withUndo) { editSessionNumber++; if (editSessionNumber > 1) return; editIsRunning = true; editWithUndo = withUndo; if (editWithUndo) undoStart(); else undoCancel(); for (uint z = 0; z < m_views.count(); z++) { m_views.at(z)->editStart (); } m_buffer->editStart (); } void KateDocument::undoStart() { if (m_editCurrentUndo || (m_activeView && m_activeView->imComposeEvent())) return; // Make sure the buffer doesn't get bigger than requested if ((config()->undoSteps() > 0) && (undoItems.count() > config()->undoSteps())) { undoItems.setAutoDelete(true); undoItems.removeFirst(); undoItems.setAutoDelete(false); docWasSavedWhenUndoWasEmpty = false; } // new current undo item m_editCurrentUndo = new KateUndoGroup(this); } void KateDocument::undoEnd() { if (m_activeView && m_activeView->imComposeEvent()) return; if (m_editCurrentUndo) { bool changedUndo = false; if (m_editCurrentUndo->isEmpty()) delete m_editCurrentUndo; else if (!m_undoDontMerge && undoItems.last() && undoItems.last()->merge(m_editCurrentUndo,m_undoComplexMerge)) delete m_editCurrentUndo; else { undoItems.append(m_editCurrentUndo); changedUndo = true; } m_undoDontMerge = false; m_undoIgnoreCancel = true; m_editCurrentUndo = 0L; // (Re)Start the single-shot timer to cancel the undo merge // the user has 5 seconds to input more data, or undo merging gets canceled for the current undo item. m_undoMergeTimer->start(5000, true); if (changedUndo) emit undoChanged(); } } void KateDocument::undoCancel() { if (m_undoIgnoreCancel) { m_undoIgnoreCancel = false; return; } m_undoDontMerge = true; Q_ASSERT(!m_editCurrentUndo); // As you can see by the above assert, neither of these should really be required delete m_editCurrentUndo; m_editCurrentUndo = 0L; } void KateDocument::undoSafePoint() { Q_ASSERT(m_editCurrentUndo); if (!m_editCurrentUndo) return; m_editCurrentUndo->safePoint(); } // // End edit session and update Views // void KateDocument::editEnd () { if (editSessionNumber == 0) return; // wrap the new/changed text, if something really changed! if (m_buffer->editChanged() && (editSessionNumber == 1)) if (editWithUndo && config()->wordWrap()) wrapText (m_buffer->editTagStart(), m_buffer->editTagEnd()); editSessionNumber--; if (editSessionNumber > 0) return; // end buffer edit, will trigger hl update // this will cause some possible adjustment of tagline start/end m_buffer->editEnd (); if (editWithUndo) undoEnd(); // edit end for all views !!!!!!!!! for (uint z = 0; z < m_views.count(); z++) m_views.at(z)->editEnd (m_buffer->editTagStart(), m_buffer->editTagEnd(), m_buffer->editTagFrom()); if (m_buffer->editChanged()) { setModified(true); emit textChanged (); } editIsRunning = false; } bool KateDocument::wrapText (uint startLine, uint endLine) { uint col = config()->wordWrapAt(); if (col == 0) return false; editStart (); for (uint line = startLine; (line <= endLine) && (line < numLines()); line++) { KateTextLine::Ptr l = m_buffer->line(line); if (!l) return false; kdDebug (13020) << "try wrap line: " << line << endl; if (l->lengthWithTabs(m_buffer->tabWidth()) > col) { KateTextLine::Ptr nextl = m_buffer->line(line+1); kdDebug (13020) << "do wrap line: " << line << endl; const QChar *text = l->text(); uint eolPosition = l->length()-1; // take tabs into account here, too uint x = 0; const QString & t = l->string(); uint z2 = 0; for ( ; z2 < l->length(); z2++) { if (t[z2] == QChar('\t')) x += m_buffer->tabWidth() - (x % m_buffer->tabWidth()); else x++; if (x > col) break; } uint searchStart = kMin (z2, l->length()-1); // If where we are wrapping is an end of line and is a space we don't // want to wrap there if (searchStart == eolPosition && text[searchStart].isSpace()) searchStart--; // Scan backwards looking for a place to break the line // We are not interested in breaking at the first char // of the line (if it is a space), but we are at the second // anders: if we can't find a space, try breaking on a word // boundry, using KateHighlight::canBreakAt(). // This could be a priority (setting) in the hl/filetype/document int z = 0; uint nw = 0; // alternative position, a non word character for (z=searchStart; z > 0; z--) { if (text[z].isSpace()) break; if ( ! nw && highlight()->canBreakAt( text[z] , l->attribute(z) ) ) nw = z; } if (z > 0) { // cu space editRemoveText (line, z, 1); } else { // There was no space to break at so break at a nonword character if // found, or at the wrapcolumn ( that needs be configurable ) // Don't try and add any white space for the break if ( nw && nw < col ) nw++; // break on the right side of the character z = nw ? nw : col; } if (nextl && !nextl->isAutoWrapped()) { editWrapLine (line, z, true); editMarkLineAutoWrapped (line+1, true); endLine++; } else { if (nextl && (nextl->length() > 0) && !nextl->getChar(0).isSpace() && ((l->length() < 1) || !l->getChar(l->length()-1).isSpace())) editInsertText (line+1, 0, QString (" ")); bool newLineAdded = false; editWrapLine (line, z, false, &newLineAdded); editMarkLineAutoWrapped (line+1, true); endLine++; } } } editEnd (); return true; } void KateDocument::editAddUndo (KateUndoGroup::UndoType type, uint line, uint col, uint len, const QString &text) { if (editIsRunning && editWithUndo && m_editCurrentUndo) { m_editCurrentUndo->addItem(type, line, col, len, text); // Clear redo buffer if (redoItems.count()) { redoItems.setAutoDelete(true); redoItems.clear(); redoItems.setAutoDelete(false); } } } bool KateDocument::editInsertText ( uint line, uint col, const QString &str ) { if (!isReadWrite()) return false; QString s = str; KateTextLine::Ptr l = m_buffer->line(line); if (!l) return false; if ( config()->configFlags() & KateDocumentConfig::cfReplaceTabsDyn && ! m_isInUndo ) { uint tw = config()->tabWidth(); int pos = 0; uint l = 0; while ( (pos = s.find('\t')) > -1 ) { l = tw - ( (col + pos)%tw ); s.replace( pos, 1, QString().fill( ' ', l ) ); } } editStart (); editAddUndo (KateUndoGroup::editInsertText, line, col, s.length(), s); l->insertText (col, s.length(), s.unicode()); // removeTrailingSpace(line); // ### nessecary? m_buffer->changeLine(line); for( QPtrListIterator<KateSuperCursor> it (m_superCursors); it.current(); ++it ) it.current()->editTextInserted (line, col, s.length()); editEnd (); return true; } bool KateDocument::editRemoveText ( uint line, uint col, uint len ) { if (!isReadWrite()) return false; KateTextLine::Ptr l = m_buffer->line(line); if (!l) return false; editStart (); editAddUndo (KateUndoGroup::editRemoveText, line, col, len, l->string().mid(col, len)); l->removeText (col, len); removeTrailingSpace( line ); m_buffer->changeLine(line); for( QPtrListIterator<KateSuperCursor> it (m_superCursors); it.current(); ++it ) it.current()->editTextRemoved (line, col, len); editEnd (); return true; } bool KateDocument::editMarkLineAutoWrapped ( uint line, bool autowrapped ) { if (!isReadWrite()) return false; KateTextLine::Ptr l = m_buffer->line(line); if (!l) return false; editStart (); editAddUndo (KateUndoGroup::editMarkLineAutoWrapped, line, autowrapped ? 1 : 0, 0, QString::null); l->setAutoWrapped (autowrapped); m_buffer->changeLine(line); editEnd (); return true; } bool KateDocument::editWrapLine ( uint line, uint col, bool newLine, bool *newLineAdded) { if (!isReadWrite()) return false; KateTextLine::Ptr l = m_buffer->line(line); if (!l) return false; editStart (); KateTextLine::Ptr nextLine = m_buffer->line(line+1); int pos = l->length() - col; if (pos < 0) pos = 0; editAddUndo (KateUndoGroup::editWrapLine, line, col, pos, (!nextLine || newLine) ? "1" : "0"); if (!nextLine || newLine) { KateTextLine::Ptr textLine = new KateTextLine(); textLine->insertText (0, pos, l->text()+col, l->attributes()+col); l->truncate(col); m_buffer->insertLine (line+1, textLine); m_buffer->changeLine(line); QPtrList<KTextEditor::Mark> list; for( QIntDictIterator<KTextEditor::Mark> it( m_marks ); it.current(); ++it ) { if( it.current()->line >