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 <kstandarddirs.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 ), lastRedoGroupWhenSaved( 0 ), docWasSavedWhenUndoWasEmpty( true ), docWasSavedWhenRedoWasEmpty( 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 >= line ) { if ((col == 0) || (it.current()->line > line)) list.append( it.current() ); } } for( QPtrListIterator<KTextEditor::Mark> it( list ); it.current(); ++it ) { KTextEditor::Mark* mark = m_marks.take( it.current()->line ); mark->line++; m_marks.insert( mark->line, mark ); } if( !list.isEmpty() ) emit marksChanged(); // yes, we added a new line ! if (newLineAdded) (*newLineAdded) = true; } else { nextLine->insertText (0, pos, l->text()+col, l->attributes()+col); l->truncate(col); m_buffer->changeLine(line); m_buffer->changeLine(line+1); // no, no new line added ! if (newLineAdded) (*newLineAdded) = false; } for( QPtrListIterator<KateSuperCursor> it (m_superCursors); it.current(); ++it ) it.current()->editLineWrapped (line, col, !nextLine || newLine); editEnd (); return true; } bool KateDocument::editUnWrapLine ( uint line, bool removeLine, uint length ) { if (!isReadWrite()) return false; KateTextLine::Ptr l = m_buffer->line(line); KateTextLine::Ptr nextLine = m_buffer->line(line+1); if (!l || !nextLine) return false; editStart (); uint col = l->length (); editAddUndo (KateUndoGroup::editUnWrapLine, line, col, length, removeLine ? "1" : "0"); if (removeLine) { l->insertText (col, nextLine->length(), nextLine->text(), nextLine->attributes()); m_buffer->changeLine(line); m_buffer->removeLine(line+1); } else { l->insertText (col, (nextLine->length() < length) ? nextLine->length() : length, nextLine->text(), nextLine->attributes()); nextLine->removeText (0, (nextLine->length() < length) ? nextLine->length() : length); m_buffer->changeLine(line); m_buffer->changeLine(line+1); } QPtrList<KTextEditor::Mark> list; for( QIntDictIterator<KTextEditor::Mark> it( m_marks ); it.current(); ++it ) { if( it.current()->line >= line+1 ) list.append( it.current() ); if ( it.current()->line == line+1 ) { KTextEditor::Mark* mark = m_marks.take( line ); if (mark) { it.current()->type |= mark->type; } } } for( QPtrListIterator<KTextEditor::Mark> it( list ); it.current(); ++it ) { KTextEditor::Mark* mark = m_marks.take( it.current()->line ); mark->line--; m_marks.insert( mark->line, mark ); } if( !list.isEmpty() ) emit marksChanged(); for( QPtrListIterator<KateSuperCursor> it (m_superCursors); it.current(); ++it ) it.current()->editLineUnWrapped (line, col, removeLine, length); editEnd (); return true; } bool KateDocument::editInsertLine ( uint line, const QString &s ) { if (!isReadWrite()) return false; if ( line > numLines() ) return false; editStart (); editAddUndo (KateUndoGroup::editInsertLine, line, 0, s.length(), s); removeTrailingSpace( line ); // old line KateTextLine::Ptr tl = new KateTextLine(); tl->insertText (0, s.length(), s.unicode(), 0); m_buffer->insertLine(line, tl); m_buffer->changeLine(line); removeTrailingSpace( line ); // new line QPtrList<KTextEditor::Mark> list; for( QIntDictIterator<KTextEditor::Mark> it( m_marks ); it.current(); ++it ) { if( it.current()->line >= line ) list.append( it.current() ); } for( QPtrListIterator<KTextEditor::Mark> it( list ); it.current(); ++it ) { KTextEditor::Mark* mark = m_marks.take( it.current()->line ); mark->line++; m_marks.insert( mark->line, mark ); } if( !list.isEmpty() ) emit marksChanged(); for( QPtrListIterator<KateSuperCursor> it (m_superCursors); it.current(); ++it ) it.current()->editLineInserted (line); editEnd (); return true; } bool KateDocument::editRemoveLine ( uint line ) { if (!isReadWrite()) return false; if ( line > lastLine() ) return false; if ( numLines() == 1 ) return editRemoveText (0, 0, m_buffer->line(0)->length()); editStart (); editAddUndo (KateUndoGroup::editRemoveLine, line, 0, lineLength(line), textLine(line)); m_buffer->removeLine(line); QPtrList<KTextEditor::Mark> list; KTextEditor::Mark* rmark = 0; for( QIntDictIterator<KTextEditor::Mark> it( m_marks ); it.current(); ++it ) { if ( (it.current()->line > line) ) list.append( it.current() ); else if ( (it.current()->line == line) ) rmark = it.current(); } if (rmark) delete (m_marks.take (rmark->line)); for( QPtrListIterator<KTextEditor::Mark> it( list ); it.current(); ++it ) { KTextEditor::Mark* mark = m_marks.take( it.current()->line ); mark->line--; m_marks.insert( mark->line, mark ); } if( !list.isEmpty() ) emit marksChanged(); for( QPtrListIterator<KateSuperCursor> it (m_superCursors); it.current(); ++it ) it.current()->editLineRemoved (line); editEnd(); return true; } //END //BEGIN KTextEditor::UndoInterface stuff uint KateDocument::undoCount () const { return undoItems.count (); } uint KateDocument::redoCount () const { return redoItems.count (); } uint KateDocument::undoSteps () const { return m_config->undoSteps(); } void KateDocument::setUndoSteps(uint steps) { m_config->setUndoSteps (steps); } void KateDocument::undo() { m_isInUndo = true; if ((undoItems.count() > 0) && undoItems.last()) { clearSelection (); undoItems.last()->undo(); redoItems.append (undoItems.last()); undoItems.removeLast (); updateModified(); emit undoChanged (); } m_isInUndo = false; } void KateDocument::redo() { m_isInUndo = true; if ((redoItems.count() > 0) && redoItems.last()) { clearSelection (); redoItems.last()->redo(); undoItems.append (redoItems.last()); redoItems.removeLast (); updateModified(); emit undoChanged (); } m_isInUndo = false; } void KateDocument::updateModified() { /* How this works: After noticing that there where to many scenarios to take into consideration when using 'if's to toggle the "Modified" flag I came up with this baby, flexible and repetitive calls are minimal. A numeric unique pattern is generated by toggleing a set of bits, each bit symbolizes a different state in the Undo Redo structure. undoItems.isEmpty() != null BIT 1 redoItems.isEmpty() != null BIT 2 docWasSavedWhenUndoWasEmpty == true BIT 3 docWasSavedWhenRedoWasEmpty == true BIT 4 lastUndoGroupWhenSavedIsLastUndo BIT 5 lastUndoGroupWhenSavedIsLastRedo BIT 6 lastRedoGroupWhenSavedIsLastUndo BIT 7 lastRedoGroupWhenSavedIsLastRedo BIT 8 If you find a new pattern, please add it to the patterns array */ unsigned char currentPattern = 0; const unsigned char patterns[] = {5,16,24,26,88,90,93,133,144,149,165}; const unsigned char patternCount = sizeof(patterns); KateUndoGroup* undoLast = 0; KateUndoGroup* redoLast = 0; if (undoItems.isEmpty()) { currentPattern |= 1; } else { undoLast = undoItems.last(); } if (redoItems.isEmpty()) { currentPattern |= 2; } else { redoLast = redoItems.last(); } if (docWasSavedWhenUndoWasEmpty) currentPattern |= 4; if (docWasSavedWhenRedoWasEmpty) currentPattern |= 8; if (lastUndoGroupWhenSaved == undoLast) currentPattern |= 16; if (lastUndoGroupWhenSaved == redoLast) currentPattern |= 32; if (lastRedoGroupWhenSaved == undoLast) currentPattern |= 64; if (lastRedoGroupWhenSaved == redoLast) currentPattern |= 128; // This will print out the pattern information kdDebug(13020) << k_funcinfo << "Pattern:" << static_cast<unsigned int>(currentPattern) << endl; for (uint patternIndex = 0; patternIndex < patternCount; ++patternIndex) { if ( currentPattern == patterns[patternIndex] ) { setModified( false ); kdDebug(13020) << k_funcinfo << "setting modified to false!" << endl; break; } } } void KateDocument::clearUndo() { undoItems.setAutoDelete (true); undoItems.clear (); undoItems.setAutoDelete (false); lastUndoGroupWhenSaved = 0; docWasSavedWhenUndoWasEmpty = false; emit undoChanged (); } void KateDocument::clearRedo() { redoItems.setAutoDelete (true); redoItems.clear (); redoItems.setAutoDelete (false); lastRedoGroupWhenSaved = 0; docWasSavedWhenRedoWasEmpty = false; emit undoChanged (); } QPtrList<KTextEditor::Cursor> KateDocument::cursors () const { return myCursors; } //END //BEGIN KTextEditor::SearchInterface stuff bool KateDocument::searchText (unsigned int startLine, unsigned int startCol, const QString &text, unsigned int *foundAtLine, unsigned int *foundAtCol, unsigned int *matchLen, bool casesensitive, bool backwards) { if (text.isEmpty()) return false; int line = startLine; int col = startCol; if (!backwards) { int searchEnd = lastLine(); while (line <= searchEnd) { KateTextLine::Ptr textLine = m_buffer->plainLine(line); if (!textLine) return false; uint foundAt, myMatchLen; bool found = textLine->searchText (col, text, &foundAt, &myMatchLen, casesensitive, false); if (found) { (*foundAtLine) = line; (*foundAtCol) = foundAt; (*matchLen) = myMatchLen; return true; } col = 0; line++; } } else { // backward search int searchEnd = 0; while (line >= searchEnd) { KateTextLine::Ptr textLine = m_buffer->plainLine(line); if (!textLine) return false; uint foundAt, myMatchLen; bool found = textLine->searchText (col, text, &foundAt, &myMatchLen, casesensitive, true); if (found) { /* if ((uint) line == startLine && foundAt + myMatchLen >= (uint) col && line == selectStart.line() && foundAt == (uint) selectStart.col() && line == selectEnd.line() && foundAt + myMatchLen == (uint) selectEnd.col()) { // To avoid getting stuck at one match we skip a match if it is already // selected (most likely because it has just been found). if (foundAt > 0) col = foundAt - 1; else { if (--line >= 0) col = lineLength(line); } continue; }*/ (*foundAtLine) = line; (*foundAtCol) = foundAt; (*matchLen) = myMatchLen; return true; } if (line >= 1) col = lineLength(line-1); line--; } } return false; } bool KateDocument::searchText (unsigned int startLine, unsigned int startCol, const QRegExp &regexp, unsigned int *foundAtLine, unsigned int *foundAtCol, unsigned int *matchLen, bool backwards) { kdDebug(13020)<<"KateDocument::searchText( "<<startLine<<", "<<startCol<<", "<<regexp.pattern()<<", "<<backwards<<" )"<<endl; if (regexp.isEmpty() || !regexp.isValid()) return false; int line = startLine; int col = startCol; if (!backwards) { int searchEnd = lastLine(); while (line <= searchEnd) { KateTextLine::Ptr textLine = m_buffer->plainLine(line); if (!textLine) return false; uint foundAt, myMatchLen; bool found = textLine->searchText (col, regexp, &foundAt, &myMatchLen, false); if (found) { // A special case which can only occur when searching with a regular expression consisting // only of a lookahead (e.g. ^(?=\{) for a function beginning without selecting '{'). if (myMatchLen == 0 && (uint) line == startLine && foundAt == (uint) col) { if (col < lineLength(line)) col++; else { line++; col = 0; } continue; } (*foundAtLine) = line; (*foundAtCol) = foundAt; (*matchLen) = myMatchLen; return true; } col = 0; line++; } } else { // backward search int searchEnd = 0; while (line >= searchEnd) { KateTextLine::Ptr textLine = m_buffer->plainLine(line); if (!textLine) return false; uint foundAt, myMatchLen; bool found = textLine->searchText (col, regexp, &foundAt, &myMatchLen, true); if (found) { /*if ((uint) line == startLine && foundAt + myMatchLen >= (uint) col && line == selectStart.line() && foundAt == (uint) selectStart.col() && line == selectEnd.line() && foundAt + myMatchLen == (uint) selectEnd.col()) { // To avoid getting stuck at one match we skip a match if it is already // selected (most likely because it has just been found). if (foundAt > 0) col = foundAt - 1; else { if (--line >= 0) col = lineLength(line); } continue; }*/ (*foundAtLine) = line; (*foundAtCol) = foundAt; (*matchLen) = myMatchLen; return true; } if (line >= 1) col = lineLength(line-1); line--; } } return false; } //END //BEGIN KTextEditor::HighlightingInterface stuff uint KateDocument::hlMode () { return KateHlManager::self()->findHl(highlight()); } bool KateDocument::setHlMode (uint mode) { m_buffer->setHighlight (mode); if (true) { setDontChangeHlOnSave(); return true; } return false; } void KateDocument::bufferHlChanged () { // update all views makeAttribs(false); emit hlChanged(); } uint KateDocument::hlModeCount () { return KateHlManager::self()->highlights(); } QString KateDocument::hlModeName (uint mode) { return KateHlManager::self()->hlName (mode); } QString KateDocument::hlModeSectionName (uint mode) { return KateHlManager::self()->hlSection (mode); } void KateDocument::setDontChangeHlOnSave() { hlSetByUser = true; } //END //BEGIN KTextEditor::ConfigInterface stuff void KateDocument::readConfig(KConfig *config) { config->setGroup("Kate Document Defaults"); // read max loadable blocks, more blocks will be swapped out KateBuffer::setMaxLoadedBlocks (config->readNumEntry("Maximal Loaded Blocks", KateBuffer::maxLoadedBlocks())); KateDocumentConfig::global()->readConfig (config); config->setGroup("Kate View Defaults"); KateViewConfig::global()->readConfig (config); config->setGroup("Kate Renderer Defaults"); KateRendererConfig::global()->readConfig (config); } void KateDocument::writeConfig(KConfig *config) { config->setGroup("Kate Document Defaults"); // write max loadable blocks, more blocks will be swapped out config->writeEntry("Maximal Loaded Blocks", KateBuffer::maxLoadedBlocks()); KateDocumentConfig::global()->writeConfig (config); config->setGroup("Kate View Defaults"); KateViewConfig::global()->writeConfig (config); config->setGroup("Kate Renderer Defaults"); KateRendererConfig::global()->writeConfig (config); } void KateDocument::readConfig() { KConfig *config = kapp->config(); readConfig (config); } void KateDocument::writeConfig() { KConfig *config = kapp->config(); writeConfig (config); config->sync(); } void KateDocument::readSessionConfig(KConfig *kconfig) { // restore the url KURL url (kconfig->readEntry("URL")); // get the encoding QString tmpenc=kconfig->readEntry("Encoding"); if (!tmpenc.isEmpty() && (tmpenc != encoding())) setEncoding(tmpenc); // open the file if url valid if (!url.isEmpty() && url.isValid()) openURL (url); // restore the hl stuff m_buffer->setHighlight(KateHlManager::self()->nameFind(kconfig->readEntry("Highlighting"))); if (hlMode() > 0) hlSetByUser = true; // indent mode config()->setIndentationMode( (uint)kconfig->readNumEntry("Indentation Mode", config()->indentationMode() ) ); // Restore Bookmarks QValueList<int> marks = kconfig->readIntListEntry("Bookmarks"); for( uint i = 0; i < marks.count(); i++ ) addMark( marks[i], KateDocument::markType01 ); } void KateDocument::writeSessionConfig(KConfig *kconfig) { if ( m_url.isLocalFile() && !KGlobal::dirs()->relativeLocation("tmp", m_url.path()).startsWith("/")) return; // save url kconfig->writeEntry("URL", m_url.prettyURL() ); // save encoding kconfig->writeEntry("Encoding",encoding()); // save hl kconfig->writeEntry("Highlighting", highlight()->name()); kconfig->writeEntry("Indentation Mode", config()->indentationMode() ); // Save Bookmarks QValueList<int> marks; for( QIntDictIterator<KTextEditor::Mark> it( m_marks ); it.current() && it.current()->type & KTextEditor::MarkInterface::markType01; ++it ) marks << it.current()->line; kconfig->writeEntry( "Bookmarks", marks ); } void KateDocument::configDialog() { KDialogBase *kd = new KDialogBase ( KDialogBase::IconList, i18n("Configure"), KDialogBase::Ok | KDialogBase::Cancel | KDialogBase::Help, KDialogBase::Ok, kapp->mainWidget() ); #ifndef Q_WS_WIN //TODO: reenable KWin::setIcons( kd->winId(), kapp->icon(), kapp->miniIcon() ); #endif QPtrList<KTextEditor::ConfigPage> editorPages; for (uint i = 0; i < KTextEditor::configInterfaceExtension (this)->configPages (); i++) { QStringList path; path.clear(); path << KTextEditor::configInterfaceExtension (this)->configPageName (i); QVBox *page = kd->addVBoxPage(path, KTextEditor::configInterfaceExtension (this)->configPageFullName (i), KTextEditor::configInterfaceExtension (this)->configPagePixmap(i, KIcon::SizeMedium) ); editorPages.append (KTextEditor::configInterfaceExtension (this)->configPage(i, page)); } kd->resize(800, 480); if (kd->exec()) { KateDocumentConfig::global()->configStart (); KateViewConfig::global()->configStart (); KateRendererConfig::global()->configStart (); for (uint i=0; i<editorPages.count(); i++) { editorPages.at(i)->apply(); } KateDocumentConfig::global()->configEnd (); KateViewConfig::global()->configEnd (); KateRendererConfig::global()->configEnd (); writeConfig (); } delete kd; } uint KateDocument::mark( uint line ) { if( !m_marks[line] ) return 0; return m_marks[line]->type; } void KateDocument::setMark( uint line, uint markType ) { clearMark( line ); addMark( line, markType ); } void KateDocument::clearMark( uint line ) { if( line > lastLine() ) return; if( !m_marks[line] ) return; KTextEditor::Mark* mark = m_marks.take( line ); emit markChanged( *mark, MarkRemoved ); emit marksChanged(); delete mark; tagLines( line, line ); repaintViews(true); } void KateDocument::addMark( uint line, uint markType ) { if( line > lastLine()) return; if( markType == 0 ) return; if( m_marks[line] ) { KTextEditor::Mark* mark = m_marks[line]; // Remove bits already set markType &= ~mark->type; if( markType == 0 ) return; // Add bits mark->type |= markType; } else { KTextEditor::Mark *mark = new KTextEditor::Mark; mark->line = line; mark->type = markType; m_marks.insert( line, mark ); } // Emit with a mark having only the types added. KTextEditor::Mark temp; temp.line = line; temp.type = markType; emit markChanged( temp, MarkAdded ); emit marksChanged(); tagLines( line, line ); repaintViews(true); } void KateDocument::removeMark( uint line, uint markType ) { if( line > lastLine() ) return; if( !m_marks[line] ) return; KTextEditor::Mark* mark = m_marks[line]; // Remove bits not set markType &= mark->type; if( markType == 0 ) return; // Subtract bits mark->type &= ~markType; // Emit with a mark having only the types removed. KTextEditor::Mark temp; temp.line = line; temp.type = markType; emit markChanged( temp, MarkRemoved ); if( mark->type == 0 ) m_marks.remove( line ); emit marksChanged(); tagLines( line, line ); repaintViews(true); } QPtrList<KTextEditor::Mark> KateDocument::marks() { QPtrList<KTextEditor::Mark> list; for( QIntDictIterator<KTextEditor::Mark> it( m_marks ); it.current(); ++it ) { list.append( it.current() ); } return list; } void KateDocument::clearMarks() { for( QIntDictIterator<KTextEditor::Mark> it( m_marks ); it.current(); ++it ) { KTextEditor::Mark* mark = it.current(); emit markChanged( *mark, MarkRemoved ); tagLines( mark->line, mark->line ); } m_marks.clear(); emit marksChanged(); repaintViews(true); } void KateDocument::setPixmap( MarkInterface::MarkTypes type, const QPixmap& pixmap ) { m_markPixmaps.replace( type, new QPixmap( pixmap ) ); } void KateDocument::setDescription( MarkInterface::MarkTypes type, const QString& description ) { m_markDescriptions.replace( type, new QString( description ) ); } QPixmap *KateDocument::markPixmap( MarkInterface::MarkTypes type ) { return m_markPixmaps[type]; } QColor KateDocument::markColor( MarkInterface::MarkTypes type ) { uint reserved = (0x1 << KTextEditor::MarkInterface::reservedMarkersCount()) - 1; if ((uint)type >= (uint)markType01 && (uint)type <= reserved) { return KateRendererConfig::global()->lineMarkerColor(type); } else { return QColor(); } } QString KateDocument::markDescription( MarkInterface::MarkTypes type ) { if( m_markDescriptions[type] ) return *m_markDescriptions[type]; return QString::null; } void KateDocument::setMarksUserChangable( uint markMask ) { m_editableMarks = markMask; } uint KateDocument::editableMarks() { return m_editableMarks; } //END //BEGIN KTextEditor::PrintInterface stuff bool KateDocument::printDialog () { return KatePrinter::print (this); } bool KateDocument::print () { return KatePrinter::print (this); } //END //BEGIN KTextEditor::DocumentInfoInterface (### unfinished) QString KateDocument::mimeType() { KMimeType::Ptr result = KMimeType::defaultMimeTypePtr(); // if the document has a URL, try KMimeType::findByURL if ( ! m_url.isEmpty() ) result = KMimeType::findByURL( m_url ); else if ( m_url.isEmpty() || ! m_url.isLocalFile() ) result = mimeTypeForContent(); return result->name(); } // TODO implement this -- how to calculate? long KateDocument::fileSize() { return 0; } // TODO implement this QString KateDocument::niceFileSize() { return "UNKNOWN"; } KMimeType::Ptr KateDocument::mimeTypeForContent() { QByteArray buf (1024); uint bufpos = 0; for (uint i=0; i < numLines(); i++) { QString line = textLine( i ); uint len = line.length() + 1; if (bufpos + len > 1024) len = 1024 - bufpos; memcpy(&buf[bufpos], (line + "\n").latin1(), len); bufpos += len; if (bufpos >= 1024) break; } buf.resize( bufpos ); int accuracy = 0; return KMimeType::findByContent( buf, &accuracy ); } //END KTextEditor::DocumentInfoInterface //BEGIN KParts::ReadWrite stuff bool KateDocument::openURL( const KURL &url ) { // kdDebug(13020)<<"KateDocument::openURL( "<<url.prettyURL()<<")"<<endl; // no valid URL if ( !url.isValid() ) return false; // could not close old one if ( !closeURL() ) return false; // set my url m_url = url; if ( m_url.isLocalFile() ) { // local mode, just like in kpart m_file = m_url.path(); emit started( 0 ); if (openFile()) { emit completed(); emit setWindowCaption( m_url.prettyURL() ); return true; } return false; } else { // remote mode m_bTemp = true; m_tempFile = new KTempFile (); m_file = m_tempFile->name(); m_job = KIO::get ( url, false, isProgressInfoEnabled() ); // connect to slots connect( m_job, SIGNAL( data( KIO::Job*, const QByteArray& ) ), SLOT( slotDataKate( KIO::Job*, const QByteArray& ) ) ); connect( m_job, SIGNAL( result( KIO::Job* ) ), SLOT( slotFinishedKate( KIO::Job* ) ) ); QWidget *w = widget (); if (!w && !m_views.isEmpty ()) w = m_views.first(); if (w) m_job->setWindow (w->topLevelWidget()); emit started( m_job ); return true; } } void KateDocument::slotDataKate ( KIO::Job *, const QByteArray &data ) { // kdDebug(13020) << "KateDocument::slotData" << endl; if (!m_tempFile || !m_tempFile->file()) return; m_tempFile->file()->writeBlock (data); } void KateDocument::slotFinishedKate ( KIO::Job * job ) { // kdDebug(13020) << "KateDocument::slotJobFinished" << endl; if (!m_tempFile) return; delete m_tempFile; m_tempFile = 0; m_job = 0; if (job->error()) emit canceled( job->errorString() ); else { if ( openFile(job) ) emit setWindowCaption( m_url.prettyURL() ); emit completed(); } } void KateDocument::abortLoadKate() { if ( m_job ) { kdDebug(13020) << "Aborting job " << m_job << endl; m_job->kill(); m_job = 0; } delete m_tempFile; m_tempFile = 0; } bool KateDocument::openFile() { return openFile (0); } bool KateDocument::openFile(KIO::Job * job) { m_loading = true; // add new m_file to dirwatch activateDirWatch (); // // use metadata // if (job) { QString metaDataCharset = job->queryMetaData("charset"); // only overwrite config if nothing set if (!metaDataCharset.isEmpty () && (!m_config->isSetEncoding() || m_config->encoding().isEmpty())) setEncoding (metaDataCharset); } // // service type magic to get encoding right // QString serviceType = m_extension->urlArgs().serviceType.simplifyWhiteSpace(); int pos = serviceType.find(';'); if (pos != -1) setEncoding (serviceType.mid(pos+1)); // if the encoding is set here - on the command line/from the dialog/from KIO // we prevent file type and document variables from changing it bool encodingSticky = m_encodingSticky; m_encodingSticky = m_config->isSetEncoding(); // Try getting the filetype here, so that variables does not have to be reset. int fileTypeFound = KateFactory::self()->fileTypeManager()->fileType (this); if ( fileTypeFound > -1 ) updateFileType( fileTypeFound ); // do we have success ? bool success = m_buffer->openFile (m_file); // // yeah, success // m_loading = false; // done reading file. if (success) { /*if (highlight() && !m_url.isLocalFile()) { // The buffer's highlighting gets nuked by KateBuffer::clear() m_buffer->setHighlight(m_highlight); }*/ // update our hl type if needed if (!hlSetByUser) { int hl (KateHlManager::self()->detectHighlighting (this)); if (hl >= 0) m_buffer->setHighlight(hl); } // update file type if we haven't allready done so. if ( fileTypeFound < 0 ) updateFileType (KateFactory::self()->fileTypeManager()->fileType (this)); // read dir config (if possible and wanted) readDirConfig (); // read vars readVariables(); // update the md5 digest createDigest( m_digest ); } // // update views // for (KateView * view = m_views.first(); view != 0L; view = m_views.next() ) { view->updateView(true); } // // emit the signal we need for example for kate app // emit fileNameChanged (); // // set doc name, dummy value as arg, don't need it // setDocName (QString::null); // // to houston, we are not modified // if (m_modOnHd) { m_modOnHd = false; m_modOnHdReason = 0; emit modifiedOnDisc (this, m_modOnHd, 0); } // // display errors // if (s_openErrorDialogsActivated) { if (!success && m_buffer->loadingBorked()) KMessageBox::error (widget(), i18n ("The file %1 could not be loaded completely, as there is not enough temporary disk storage for it.").arg(m_url.url())); else if (!success) KMessageBox::error (widget(), i18n ("The file %1 could not be loaded, as it was not possible to read from it.\n\nCheck if you have read access to this file.").arg(m_url.url())); } // warn -> opened binary file!!!!!!! if (m_buffer->binary()) { // this file can't be saved again without killing it setReadWrite( false ); KMessageBox::information (widget() , i18n ("The file %1 is a binary, saving it will result in a corrupt file.").arg(m_url.url()) , i18n ("Binary File Opened") , "Binary File Opened Warning"); } m_encodingSticky = encodingSticky; // // return the success // return success; } bool KateDocument::save() { bool l ( url().isLocalFile() ); if ( ( l && config()->backupFlags() & KateDocumentConfig::LocalFiles ) || ( ! l && config()->backupFlags() & KateDocumentConfig::RemoteFiles ) ) { KURL u( url() ); u.setFileName( config()->backupPrefix() + url().fileName() + config()->backupSuffix() ); kdDebug () << "backup src file name: " << url() << endl; kdDebug () << "backup dst file name: " << u << endl; // get the right permissions, start with safe default mode_t perms = 0600; KIO::UDSEntry fentry; if (KIO::NetAccess::stat (url(), fentry, kapp->mainWidget())) { kdDebug () << "stating succesfull: " << url() << endl; KFileItem item (fentry, url()); perms = item.permissions(); } // first del existing file if any, than copy over the file we have // failure if a: the existing file could not be deleted, b: the file could not be copied if ( (!KIO::NetAccess::exists( u, false, kapp->mainWidget() ) || KIO::NetAccess::del( u, kapp->mainWidget() )) && KIO::NetAccess::file_copy( url(), u, perms, true, false, kapp->mainWidget() ) ) { kdDebug(13020)<<"backing up successfull ("<<url().prettyURL()<<" -> "<<u.prettyURL()<<")"<<endl; } else { kdDebug(13020)<<"backing up failed ("<<url().prettyURL()<<" -> "<<u.prettyURL()<<")"<<endl; // FIXME: notify user for real ;) } } return KParts::ReadWritePart::save(); } bool KateDocument::saveFile() { // // we really want to save this file ? // if (m_buffer->loadingBorked() && (KMessageBox::warningContinueCancel(widget(), i18n("This file could not be loaded correctly due to lack of temporary disk space. Saving it could cause data loss.\n\nDo you really want to save it?"),i18n("Possible Data Loss"),i18n("Save Nevertheless")) != KMessageBox::Continue)) return false; // // warn -> try to save binary file!!!!!!! // if (m_buffer->binary() && (KMessageBox::warningContinueCancel (widget() , i18n ("The file %1 is a binary, saving it will result in a corrupt file.").arg(m_url.url()) , i18n ("Trying to Save Binary File") , i18n("Save Nevertheless"), "Binary File Save Warning") != KMessageBox::Continue)) return false; if ( !url().isEmpty() ) { if (s_fileChangedDialogsActivated && m_modOnHd) { QString str = reasonedMOHString() + "\n\n"; if (!isModified()) { if (KMessageBox::warningContinueCancel(0, str + i18n("Do you really want to save this unmodified file? You could overwrite changed data in the file on disk."),i18n("Trying to Save Unmodified File"),i18n("Save Nevertheless")) != KMessageBox::Continue) return false; } else { if (KMessageBox::warningContinueCancel(0, str + i18n("Do you really want to save this file? Both your open file and the file on disk were changed. There could be some data lost."),i18n("Possible Data Loss"),i18n("Save Nevertheless")) != KMessageBox::Continue) return false; } } } // // can we encode it if we want to save it ? // if (!m_buffer->canEncode () && (KMessageBox::warningContinueCancel(0, i18n("The selected encoding cannot encode every unicode character in this document. Do you really want to save it? There could be some data lost."),i18n("Possible Data Loss"),i18n("Save Nevertheless")) != KMessageBox::Continue)) { return false; } // remove file from dirwatch deactivateDirWatch (); // // try to save // bool success = m_buffer->saveFile (m_file); // update the md5 digest createDigest( m_digest ); // add m_file again to dirwatch activateDirWatch (); // // hurray, we had success, do stuff we need // if (success) { // update our hl type if needed if (!hlSetByUser) { int hl (KateHlManager::self()->detectHighlighting (this)); if (hl >= 0) m_buffer->setHighlight(hl); } // read our vars readVariables(); } // // we are not modified // if (success && m_modOnHd) { m_modOnHd = false; m_modOnHdReason = 0; emit modifiedOnDisc (this, m_modOnHd, 0); } // // display errors // if (!success) KMessageBox::error (widget(), i18n ("The document could not be saved, as it was not possible to write to %1.\n\nCheck that you have write access to this file or that enough disk space is available.").arg(m_url.url())); // // return success // return success; } bool KateDocument::saveAs( const KURL &u ) { QString oldDir = url().directory(); if ( KParts::ReadWritePart::saveAs( u ) ) { // null means base on filename setDocName( QString::null ); if ( u.directory() != oldDir ) readDirConfig(); emit fileNameChanged(); emit nameChanged((Kate::Document *) this); return true; } return false; } void KateDocument::readDirConfig () { int depth = config()->searchDirConfigDepth (); if (m_url.isLocalFile() && (depth > -1)) { QString currentDir = QFileInfo (m_file).dirPath(); // only search as deep as specified or not at all ;) while (depth > -1) { kdDebug (13020) << "search for config file in path: " << currentDir << endl; // try to open config file in this dir QFile f (currentDir + "/.kateconfig"); if (f.open (IO_ReadOnly)) { QTextStream stream (&f); uint linesRead = 0; QString line = stream.readLine(); while ((linesRead < 32) && !line.isNull()) { readVariableLine( line ); line = stream.readLine(); linesRead++; } break; } QString newDir = QFileInfo (currentDir).dirPath(); // bail out on looping (for example reached /) if (currentDir == newDir) break; currentDir = newDir; --depth; } } } void KateDocument::activateDirWatch () { // same file as we are monitoring, return if (m_file == m_dirWatchFile) return; // remove the old watched file deactivateDirWatch (); // add new file if needed if (m_url.isLocalFile() && !m_file.isEmpty()) { KateFactory::self()->dirWatch ()->addFile (m_file); m_dirWatchFile = m_file; } } void KateDocument::deactivateDirWatch () { if (!m_dirWatchFile.isEmpty()) KateFactory::self()->dirWatch ()->removeFile (m_dirWatchFile); m_dirWatchFile = QString::null; } bool KateDocument::closeURL() { abortLoadKate(); // // file mod on hd // if ( !m_reloading && !url().isEmpty() ) { if (s_fileChangedDialogsActivated && m_modOnHd) { if (!(KMessageBox::warningContinueCancel( widget(), reasonedMOHString() + "\n\n" + i18n("Do you really want to continue to close this file? Data loss may occur."), i18n("Possible Data Loss"), i18n("Close Nevertheless"), QString("kate_close_modonhd_%1").arg( m_modOnHdReason ) ) == KMessageBox::Continue)) return false; } } // // first call the normal kparts implementation // if (!KParts::ReadWritePart::closeURL ()) return false; // remove file from dirwatch deactivateDirWatch (); // // empty url + filename // m_url = KURL (); m_file = QString::null; // we are not modified if (m_modOnHd) { m_modOnHd = false; m_modOnHdReason = 0; emit modifiedOnDisc (this, m_modOnHd, 0); } // clear the buffer m_buffer->clear(); // remove all marks clearMarks (); // clear undo/redo history clearUndo(); clearRedo(); // no, we are no longer modified setModified(false); // we have no longer any hl m_buffer->setHighlight(0); // update all our views for (KateView * view = m_views.first(); view != 0L; view = m_views.next() ) { // Explicitly call the internal version because we don't want this to look like // an external request (and thus have the view not QWidget::scroll()ed. view->setCursorPositionInternal(0, 0, 1, false); view->clearSelection(); view->updateView(true); } // uh, filename changed emit fileNameChanged (); // update doc name setDocName (QString::null); // success return true; } void KateDocument::setReadWrite( bool rw ) { if (isReadWrite() != rw) { KParts::ReadWritePart::setReadWrite (rw); for( KateView* view = m_views.first(); view != 0L; view = m_views.next() ) { view->slotUpdate(); view->slotReadWriteChanged (); } } } void KateDocument::setModified(bool m) { if (isModified() != m) { KParts::ReadWritePart::setModified (m); for( KateView* view = m_views.first(); view != 0L; view = m_views.next() ) { view->slotUpdate(); } emit modifiedChanged (); emit modStateChanged ((Kate::Document *)this); } if ( m == false ) { if ( ! undoItems.isEmpty() ) { lastUndoGroupWhenSaved = undoItems.last(); } if ( ! redoItems.isEmpty() ) { lastRedoGroupWhenSaved = redoItems.last(); } docWasSavedWhenUndoWasEmpty = undoItems.isEmpty(); docWasSavedWhenRedoWasEmpty = redoItems.isEmpty(); } } //END //BEGIN Kate specific stuff ;) void KateDocument::makeAttribs(bool needInvalidate) { for (uint z = 0; z < m_views.count(); z++) m_views.at(z)->renderer()->updateAttributes (); if (needInvalidate) m_buffer->invalidateHighlighting(); tagAll (); } // the attributes of a hl have changed, update void KateDocument::internalHlChanged() { makeAttribs(); } void KateDocument::addView(KTextEditor::View *view) { if (!view) return; m_views.append( (KateView *) view ); m_textEditViews.append( view ); // apply the view & renderer vars from the file type const KateFileType *t = 0; if ((m_fileType > -1) && (t = KateFactory::self()->fileTypeManager()->fileType(m_fileType))) readVariableLine (t->varLine, true); // apply the view & renderer vars from the file readVariables (true); m_activeView = (KateView *) view; } void KateDocument::removeView(KTextEditor::View *view) { if (!view) return; if (m_activeView == view) m_activeView = 0L; m_views.removeRef( (KateView *) view ); m_textEditViews.removeRef( view ); } void KateDocument::addSuperCursor(KateSuperCursor *cursor, bool privateC) { if (!cursor) return; m_superCursors.append( cursor ); if (!privateC) myCursors.append( cursor ); } void KateDocument::removeSuperCursor(KateSuperCursor *cursor, bool privateC) { if (!cursor) return; if (!privateC) myCursors.removeRef( cursor ); m_superCursors.removeRef( cursor ); } bool KateDocument::ownedView(KateView *view) { // do we own the given view? return (m_views.containsRef(view) > 0); } bool KateDocument::isLastView(int numViews) { return ((int) m_views.count() == numViews); } uint KateDocument::currentColumn( const KateTextCursor& cursor ) { KateTextLine::Ptr textLine = m_buffer->plainLine(cursor.line()); if (textLine) return textLine->cursorX(cursor.col(), config()->tabWidth()); else return 0; } bool KateDocument::typeChars ( KateView *view, const QString &chars ) { KateTextLine::Ptr textLine = m_buffer->plainLine(view->cursorLine ()); if (!textLine) return false; bool bracketInserted = false; QString buf; QChar c; for( uint z = 0; z < chars.length(); z++ ) { QChar ch = c = chars[z]; if (ch.isPrint() || ch == '\t') { buf.append (ch); if (!bracketInserted && (config()->configFlags() & KateDocument::cfAutoBrackets)) { QChar end_ch; bool complete = true; QChar prevChar = textLine->getChar(view->cursorColumnReal()-1); QChar nextChar = textLine->getChar(view->cursorColumnReal()); switch(ch) { case '(': end_ch = ')'; break; case '[': end_ch = ']'; break; case '{': end_ch = '}'; break; case '\'':end_ch = '\'';break; case '"': end_ch = '"'; break; default: complete = false; } if (complete) { if (view->hasSelection()) { // there is a selection, enclose the selection buf.append (view->selection()); buf.append (end_ch); bracketInserted = true; } else { // no selection, check whether we should better refuse to complete if ( ( (ch == '\'' || ch == '"') && (prevChar.isLetterOrNumber() || prevChar == ch) ) || nextChar.isLetterOrNumber() || (nextChar == end_ch && prevChar != ch) ) { kdDebug(13020) << "AutoBracket refused before: " << nextChar << "\n"; } else { buf.append (end_ch); bracketInserted = true; } } } } } } if (buf.isEmpty()) return false; editStart (); if (!view->config()->persistentSelection() && view->hasSelection() ) view->removeSelectedText(); int oldLine = view->cursorLine (); int oldCol = view->cursorColumnReal (); if (config()->configFlags() & KateDocument::cfOvr) removeText (view->cursorLine(), view->cursorColumnReal(), view->cursorLine(), kMin( view->cursorColumnReal()+buf.length(), textLine->length() ) ); insertText (view->cursorLine(), view->cursorColumnReal(), buf); m_indenter->processChar(c); editEnd (); if (bracketInserted) view->setCursorPositionInternal (view->cursorLine(), view->cursorColumnReal()-1); emit charactersInteractivelyInserted (oldLine, oldCol, chars); return true; } void KateDocument::newLine( KateTextCursor& c, KateViewInternal *v ) { editStart(); if( !v->view()->config()->persistentSelection() && v->view()->hasSelection() ) v->view()->removeSelectedText(); // temporary hack to get the cursor pos right !!!!!!!!! c = v->getCursor (); if (c.line() > (int)lastLine()) c.setLine(lastLine()); if ( c.line() < 0 ) c.setLine( 0 ); uint ln = c.line(); KateTextLine::Ptr textLine = kateTextLine(c.line()); if (c.col() > (int)textLine->length()) c.setCol(textLine->length()); if (m_indenter->canProcessNewLine ()) { int pos = textLine->firstChar(); // length should do the job better if (pos < 0) pos = textLine->length(); if (c.col() < pos) c.setCol(pos); // place cursor on first char if before editWrapLine (c.line(), c.col()); KateDocCursor cursor (c.line() + 1, pos, this); m_indenter->processNewline(cursor, true); c.setPos(cursor); } else { editWrapLine (c.line(), c.col()); c.setPos(c.line() + 1, 0); } removeTrailingSpace( ln ); editEnd(); } void KateDocument::transpose( const KateTextCursor& cursor) { KateTextLine::Ptr textLine = m_buffer->plainLine(cursor.line()); if (!textLine || (textLine->length() < 2)) return; uint col = cursor.col(); if (col > 0) col--; if ((textLine->length() - col) < 2) return; uint line = cursor.line(); QString s; //clever swap code if first character on the line swap right&left //otherwise left & right s.append (textLine->getChar(col+1)); s.append (textLine->getChar(col)); //do the swap // do it right, never ever manipulate a textline editStart (); editRemoveText (line, col, 2); editInsertText (line, col, s); editEnd (); } void KateDocument::backspace( KateView *view, const KateTextCursor& c ) { if ( !view->config()->persistentSelection() && view->hasSelection() ) { view->removeSelectedText(); return; } uint col = kMax( c.col(), 0 ); uint line = kMax( c.line(), 0 ); if ((col == 0) && (line == 0)) return; int complement = 0; if (col > 0) { if (config()->configFlags() & KateDocument::cfAutoBrackets) { // if inside empty (), {}, [], '', "" delete both KateTextLine::Ptr tl = m_buffer->plainLine(line); if(!tl) return; QChar prevChar = tl->getChar(col-1); QChar nextChar = tl->getChar(col); if ( (prevChar == '"' && nextChar == '"') || (prevChar == '\'' && nextChar == '\'') || (prevChar == '(' && nextChar == ')') || (prevChar == '[' && nextChar == ']') || (prevChar == '{' && nextChar == '}') ) { complement = 1; } } if (!(config()->configFlags() & KateDocument::cfBackspaceIndents)) { // ordinary backspace //c.cursor.col--; removeText(line, col-1, line, col+complement); } else { // backspace indents: erase to next indent position KateTextLine::Ptr textLine = m_buffer->plainLine(line); // don't forget this check!!!! really!!!! if (!textLine) return; int colX = textLine->cursorX(col, config()->tabWidth()); int pos = textLine->firstChar(); if (pos > 0) pos = textLine->cursorX(pos, config()->tabWidth()); if (pos < 0 || pos >= (int)colX) { // only spaces on left side of cursor indent( view, line, -1); } else removeText(line, col-1, line, col+complement); } } else { // col == 0: wrap to previous line if (line >= 1) { KateTextLine::Ptr textLine = m_buffer->plainLine(line-1); // don't forget this check!!!! really!!!! if (!textLine) return; if (config()->wordWrap() && textLine->endingWith(QString::fromLatin1(" "))) { // gg: in hard wordwrap mode, backspace must also eat the trailing space removeText (line-1, textLine->length()-1, line, 0); } else removeText (line-1, textLine->length(), line, 0); } } emit backspacePressed(); } void KateDocument::del( KateView *view, const KateTextCursor& c ) { if ( !view->config()->persistentSelection() && view->hasSelection() ) { view->removeSelectedText(); return; } if( c.col() < (int) m_buffer->plainLine(c.line())->length()) { removeText(c.line(), c.col(), c.line(), c.col()+1); } else if ( (uint)c.line() < lastLine() ) { removeText(c.line(), c.col(), c.line()+1, 0); } } void KateDocument::paste ( KateView* view ) { QString s = QApplication::clipboard()->text(); if (s.isEmpty()) return; uint lines = s.contains (QChar ('\n')); m_undoDontMerge = true; editStart (); if (!view->config()->persistentSelection() && view->hasSelection() ) view->removeSelectedText(); uint line = view->cursorLine (); uint column = view->cursorColumnReal (); insertText ( line, column, s, view->blockSelectionMode() ); editEnd(); // move cursor right for block select, as the user is moved right internal // even in that case, but user expects other behavior in block selection // mode ! if (view->blockSelectionMode()) view->setCursorPositionInternal (line+lines, column); if (m_indenter->canProcessLine() && config()->configFlags() & KateDocumentConfig::cfIndentPastedText) { editStart(); KateDocCursor begin(line, 0, this); KateDocCursor end(line + lines, 0, this); m_indenter->processSection (begin, end); editEnd(); } if (!view->blockSelectionMode()) emit charactersSemiInteractivelyInserted (line, column, s); m_undoDontMerge = true; } void KateDocument::insertIndentChars ( KateView *view ) { editStart (); QString s; if (config()->configFlags() & KateDocument::cfSpaceIndent) { int width = config()->indentationWidth(); s.fill (' ', width - (view->cursorColumnReal() % width)); } else s.append ('\t'); insertText (view->cursorLine(), view->cursorColumnReal(), s); editEnd (); } void KateDocument::indent ( KateView *v, uint line, int change) { editStart (); if (!hasSelection()) { // single line optimizeLeadingSpace(line, config()->configFlags(), change); } else { int sl = v->selStartLine(); int el = v->selEndLine(); int ec = v->selEndCol(); if ((ec == 0) && ((el-1) >= 0)) { el--; /* */ } if (config()->configFlags() & KateDocument::cfKeepIndentProfile && change < 0) { // unindent so that the existing indent profile doesn't get screwed // if any line we may unindent is already full left, don't do anything int adjustedChange = -change; for (line = sl; (int) line <= el && adjustedChange > 0; line++) { KateTextLine::Ptr textLine = m_buffer->plainLine(line); int firstChar = textLine->firstChar(); if (firstChar >= 0 && (v->lineSelected(line) || v->lineHasSelected(line))) { int maxUnindent = textLine->cursorX(firstChar, config()->tabWidth()) / config()->indentationWidth(); if (maxUnindent < adjustedChange) adjustedChange = maxUnindent; } } change = -adjustedChange; } const bool rts = config()->configFlags() & KateDocumentConfig::cfRemoveTrailingDyn; for (line = sl; (int) line <= el; line++) { if ((v->lineSelected(line) || v->lineHasSelected(line)) && (!rts || lineLength(line) > 0)) { optimizeLeadingSpace(line, config()->configFlags(), change); } } } editEnd (); } void KateDocument::align(KateView *view, uint line) { if (m_indenter->canProcessLine()) { editStart (); if (!view->hasSelection()) { KateDocCursor curLine(line, 0, this); m_indenter->processLine (curLine); editEnd (); activeView()->setCursorPosition (line, curLine.col()); } else { m_indenter->processSection (view->selStart(), view->selEnd()); editEnd (); } } } /* Optimize the leading whitespace for a single line. If change is > 0, it adds indentation units (indentationChars) if change is == 0, it only optimizes If change is < 0, it removes indentation units This will be used to indent, unindent, and optimal-fill a line. If excess space is removed depends on the flag cfKeepExtraSpaces which has to be set by the user */ void KateDocument::optimizeLeadingSpace(uint line, int flags, int change) { KateTextLine::Ptr textline = m_buffer->plainLine(line); int first_char = textline->firstChar(); int w = 0; if (flags & KateDocument::cfSpaceIndent) w = config()->indentationWidth(); else w = config()->tabWidth(); if (first_char < 0) first_char = textline->length(); int space = textline->cursorX(first_char, config()->tabWidth()) + change * w; if (space < 0) space = 0; if (!(flags & KateDocument::cfKeepExtraSpaces)) { uint extra = space % w; space -= extra; if (extra && change < 0) { // otherwise it unindents too much (e.g. 12 chars when indentation is 8 chars wide) space += w; } } //kdDebug(13020) << "replace With Op: " << line << " " << first_char << " " << space << endl; replaceWithOptimizedSpace(line, first_char, space, flags); } void KateDocument::replaceWithOptimizedSpace(uint line, uint upto_column, uint space, int flags) { uint length; QString new_space; if (flags & KateDocument::cfSpaceIndent && ! (flags & KateDocumentConfig::cfMixedIndent) ) { length = space; new_space.fill(' ', length); } else { length = space / config()->tabWidth(); new_space.fill('\t', length); QString extra_space; extra_space.fill(' ', space % config()->tabWidth()); length += space % config()->tabWidth(); new_space += extra_space; } KateTextLine::Ptr textline = m_buffer->plainLine(line); uint change_from; for (change_from = 0; change_from < upto_column && change_from < length; change_from++) { if (textline->getChar(change_from) != new_space[change_from]) break; } editStart(); if (change_from < upto_column) removeText(line, change_from, line, upto_column); if (change_from < length) insertText(line, change_from, new_space.right(length - change_from)); editEnd(); } /* Remove a given string at the begining of the current line. */ bool KateDocument::removeStringFromBegining(int line, QString &str) { KateTextLine::Ptr textline = m_buffer->plainLine(line); int index = 0; bool there = false; if (textline->startingWith(str)) there = true; else { index = textline->firstChar (); if ((index >= 0) && (textline->length() >= (index + str.length())) && (textline->string(index, str.length()) == str)) there = true; } if (there) { // Remove some chars removeText (line, index, line, index+str.length()); } return there; } /* Remove a given string at the end of the current line. */ bool KateDocument::removeStringFromEnd(int line, QString &str) { KateTextLine::Ptr textline = m_buffer->plainLine(line); int index = 0; bool there = false; if(textline->endingWith(str)) { index = textline->length() - str.length(); there = true; } else { index = textline->lastChar ()-str.length()+1; if ((index >= 0) && (textline->length() >= (index + str.length())) && (textline->string(index, str.length()) == str)) there = true; } if (there) { // Remove some chars removeText (line, index, line, index+str.length()); } return there; } /* Add to the current line a comment line mark at the begining. */ void KateDocument::addStartLineCommentToSingleLine( int line, int attrib ) { if (highlight()->getCommentSingleLinePosition(attrib)==KateHighlighting::CSLPosColumn0) { QString commentLineMark = highlight()->getCommentSingleLineStart( attrib ) + " "; insertText (line, 0, commentLineMark); } else { QString commentLineMark=highlight()->getCommentSingleLineStart(attrib); KateTextLine::Ptr l = m_buffer->line(line); int pos=l->firstChar(); if (pos >=0) insertText(line,pos,commentLineMark); } } /* Remove from the current line a comment line mark at the begining if there is one. */ bool KateDocument::removeStartLineCommentFromSingleLine( int line, int attrib ) { QString shortCommentMark = highlight()->getCommentSingleLineStart( attrib ); QString longCommentMark = shortCommentMark + " "; editStart(); // Try to remove the long comment mark first bool removed = (removeStringFromBegining(line, longCommentMark) || removeStringFromBegining(line, shortCommentMark)); editEnd(); return removed; } /* Add to the current line a start comment mark at the begining and a stop comment mark at the end. */ void KateDocument::addStartStopCommentToSingleLine( int line, int attrib ) { QString startCommentMark = highlight()->getCommentStart( attrib ) + " "; QString stopCommentMark = " " + highlight()->getCommentEnd( attrib ); editStart(); // Add the start comment mark insertText (line, 0, startCommentMark); // Go to the end of the line int col = m_buffer->plainLine(line)->length(); // Add the stop comment mark insertText (line, col, stopCommentMark); editEnd(); } /* Remove from the current line a start comment mark at the begining and a stop comment mark at the end. */ bool KateDocument::removeStartStopCommentFromSingleLine( int line, int attrib ) { QString shortStartCommentMark = highlight()->getCommentStart( attrib ); QString longStartCommentMark = shortStartCommentMark + " "; QString shortStopCommentMark = highlight()->getCommentEnd( attrib ); QString longStopCommentMark = " " + shortStopCommentMark; editStart(); #ifdef __GNUC__ #warning "that's a bad idea, can lead to stray endings, FIXME" #endif // Try to remove the long start comment mark first bool removedStart = (removeStringFromBegining(line, longStartCommentMark) || removeStringFromBegining(line, shortStartCommentMark)); bool removedStop = false; if (removedStart) { // Try to remove the long stop comment mark first removedStop = (removeStringFromEnd(line, longStopCommentMark) || removeStringFromEnd(line, shortStopCommentMark)); } editEnd(); return (removedStart || removedStop); } /* Add to the current selection a start comment mark at the begining and a stop comment mark at the end. */ void KateDocument::addStartStopCommentToSelection( KateView *view, int attrib ) { QString startComment = highlight()->getCommentStart( attrib ); QString endComment = highlight()->getCommentEnd( attrib ); int sl = view->selStartLine(); int el = view->selEndLine(); int sc = view->selStartCol(); int ec = view->selEndCol(); if ((ec == 0) && ((el-1) >= 0)) { el--; ec = m_buffer->plainLine (el)->length(); } editStart(); insertText (el, ec, endComment); insertText (sl, sc, startComment); editEnd (); // Set the new selection ec += endComment.length() + ( (el == sl) ? startComment.length() : 0 ); view->setSelection(sl, sc, el, ec); } /* Add to the current selection a comment line mark at the begining of each line. */ void KateDocument::addStartLineCommentToSelection( KateView *view, int attrib ) { QString commentLineMark = highlight()->getCommentSingleLineStart( attrib ) + " "; int sl = view->selStartLine(); int el = view->selEndLine(); if ((view->selEndCol() == 0) && ((el-1) >= 0)) { el--; } editStart(); // For each line of the selection for (int z = el; z >= sl; z--) { //insertText (z, 0, commentLineMark); addStartLineCommentToSingleLine(z, attrib ); } editEnd (); // Set the new selection KateDocCursor end (view->selEnd()); end.setCol(view->selEndCol() + ((el == view->selEndLine()) ? commentLineMark.length() : 0) ); view->setSelection(view->selStartLine(), 0, end.line(), end.col()); } bool KateDocument::nextNonSpaceCharPos(int &line, int &col) { for(; line < (int)m_buffer->count(); line++) { KateTextLine::Ptr textLine = m_buffer->plainLine(line); if (!textLine) break; col = textLine->nextNonSpaceChar(col); if(col != -1) return true; // Next non-space char found col = 0; } // No non-space char found line = -1; col = -1; return false; } bool KateDocument::previousNonSpaceCharPos(int &line, int &col) { while(true) { KateTextLine::Ptr textLine = m_buffer->plainLine(line); if (!textLine) break; col = textLine->previousNonSpaceChar(col); if(col != -1) return true; if(line == 0) return false; --line; col = textLine->length(); } // No non-space char found line = -1; col = -1; return false; } /* Remove from the selection a start comment mark at the begining and a stop comment mark at the end. */ bool KateDocument::removeStartStopCommentFromSelection( KateView *view, int attrib ) { QString startComment = highlight()->getCommentStart( attrib ); QString endComment = highlight()->getCommentEnd( attrib ); int sl = kMax<int> (0, view->selStartLine()); int el = kMin<int> (view->selEndLine(), lastLine()); int sc = view->selStartCol(); int ec = view->selEndCol(); // The selection ends on the char before selectEnd if (ec != 0) { ec--; } else { if (el > 0) { el--; ec = m_buffer->plainLine(el)->length() - 1; } } int startCommentLen = startComment.length(); int endCommentLen = endComment.length(); // had this been perl or sed: s/^\s*$startComment(.+?)$endComment\s*/$1/ bool remove = nextNonSpaceCharPos(sl, sc) && m_buffer->plainLine(sl)->stringAtPos(sc, startComment) && previousNonSpaceCharPos(el, ec) && ( (ec - endCommentLen + 1) >= 0 ) && m_buffer->plainLine(el)->stringAtPos(ec - endCommentLen + 1, endComment); if (remove) { editStart(); removeText (el, ec - endCommentLen + 1, el, ec + 1); removeText (sl, sc, sl, sc + startCommentLen); editEnd (); // set new selection not necessary, as the selection cursors are KateSuperCursors } return remove; } bool KateDocument::removeStartStopCommentFromRegion(const KateTextCursor &start,const KateTextCursor &end,int attrib) { QString startComment = highlight()->getCommentStart( attrib ); QString endComment = highlight()->getCommentEnd( attrib ); int startCommentLen = startComment.length(); int endCommentLen = endComment.length(); bool remove = m_buffer->plainLine(start.line())->stringAtPos(start.col(), startComment) && ( (end.col() - endCommentLen ) >= 0 ) && m_buffer->plainLine(end.line())->stringAtPos(end.col() - endCommentLen , endComment); if (remove) { editStart(); removeText(end.line(),end.col()-endCommentLen,end.line(),end.col()); removeText(start.line(),start.col(),start.line(),start.col()+startCommentLen); editEnd(); } return remove; } /* Remove from the begining of each line of the selection a start comment line mark. */ bool KateDocument::removeStartLineCommentFromSelection( KateView *view, int attrib ) { QString shortCommentMark = highlight()->getCommentSingleLineStart( attrib ); QString longCommentMark = shortCommentMark + " "; int sl = view->selStartLine(); int el = view->selEndLine(); if ((view->selEndCol() == 0) && ((el-1) >= 0)) { el--; } // Find out how many char will be removed from the last line int removeLength = 0; if (m_buffer->plainLine(el)->startingWith(longCommentMark)) removeLength = longCommentMark.length(); else if (m_buffer->plainLine(el)->startingWith(shortCommentMark)) removeLength = shortCommentMark.length(); bool removed = false; editStart(); // For each line of the selection for (int z = el; z >= sl; z--) { // Try to remove the long comment mark first removed = (removeStringFromBegining(z, longCommentMark) || removeStringFromBegining(z, shortCommentMark) || removed); } editEnd(); // updating selection already done by the KateSuperCursors return removed; } /* Comment or uncomment the selection or the current line if there is no selection. */ void KateDocument::comment( KateView *v, uint line,uint column, int change) { // We need to check that we can sanely comment the selectino or region. // It is if the attribute of the first and last character of the range to // comment belongs to the same language definition. // for lines with no text, we need the attribute for the lines context. bool hassel = v->hasSelection(); int startAttrib, endAttrib; if ( hassel ) { KateTextLine::Ptr ln = kateTextLine( v->selStartLine() ); int l = v->selStartLine(), c = v->selStartCol(); startAttrib = nextNonSpaceCharPos( l, c ) ? kateTextLine( l )->attribute( c ) : 0; ln = kateTextLine( v->selEndLine() ); l = v->selEndLine(), c = v->selEndCol(); endAttrib = previousNonSpaceCharPos( l, c ) ? kateTextLine( l )->attribute( c ) : 0; } else { KateTextLine::Ptr ln = kateTextLine( line ); if ( ln->length() ) { startAttrib = ln->attribute( ln->firstChar() ); endAttrib = ln->attribute( ln->lastChar() ); } else { int l = line, c = 0; if ( nextNonSpaceCharPos( l, c ) || previousNonSpaceCharPos( l, c ) ) startAttrib = endAttrib = kateTextLine( l )->attribute( c ); else startAttrib = endAttrib = 0; } } if ( ! highlight()->canComment( startAttrib, endAttrib ) ) { kdDebug(13020)<<"canComment( "<<startAttrib<<", "<<endAttrib<<" ) returned false!"<<endl; return; } bool hasStartLineCommentMark = !(highlight()->getCommentSingleLineStart( startAttrib ).isEmpty()); bool hasStartStopCommentMark = ( !(highlight()->getCommentStart( startAttrib ).isEmpty()) && !(highlight()->getCommentEnd( endAttrib ).isEmpty()) ); bool removed = false; if (change > 0) // comment { if ( !hassel ) { if ( hasStartLineCommentMark ) addStartLineCommentToSingleLine( line, startAttrib ); else if ( hasStartStopCommentMark ) addStartStopCommentToSingleLine( line, startAttrib ); } else { // anders: prefer single line comment to avoid nesting probs // If the selection starts after first char in the first line // or ends before the last char of the last line, we may use // multiline comment markers. // TODO We should try to detect nesting. // - if selection ends at col 0, most likely she wanted that // line ignored if ( hasStartStopCommentMark && ( !hasStartLineCommentMark || ( ( v->selStartCol() > m_buffer->plainLine( v->selStartLine() )->firstChar() ) || ( v->selEndCol() < ((int)m_buffer->plainLine( v->selEndLine() )->length()) ) ) ) ) addStartStopCommentToSelection( v, startAttrib ); else if ( hasStartLineCommentMark ) addStartLineCommentToSelection( v, startAttrib ); } } else // uncomment { if ( !hassel ) { removed = ( hasStartLineCommentMark && removeStartLineCommentFromSingleLine( line, startAttrib ) ) || ( hasStartStopCommentMark && removeStartStopCommentFromSingleLine( line, startAttrib ) ); if ((!removed) && foldingTree()) { kdDebug(13020)<<"easy approach for uncommenting did not work, trying harder (folding tree)"<<endl; int commentRegion=(highlight()->commentRegion(startAttrib)); if (commentRegion){ KateCodeFoldingNode *n=foldingTree()->findNodeForPosition(line,column); if (n) { KateTextCursor start,end; if ((n->nodeType()==commentRegion) && n->getBegin(foldingTree(), &start) && n->getEnd(foldingTree(), &end)) { kdDebug(13020)<<"Enclosing region found:"<<start.col()<<"/"<<start.line()<<"-"<<end.col()<<"/"<<end.line()<<endl; removeStartStopCommentFromRegion(start,end,startAttrib); } else { kdDebug(13020)<<"Enclosing region found, but not valid"<<endl; kdDebug(13020)<<"Region found: "<<n->nodeType()<<" region needed: "<<commentRegion<<endl; } //perhaps nested regions should be hadled here too... } else kdDebug(13020)<<"No enclosing region found"<<endl; } else kdDebug(13020)<<"No comment region specified for current hl"<<endl; } } else { // anders: this seems like it will work with above changes :) removed = ( hasStartLineCommentMark && removeStartLineCommentFromSelection( v, startAttrib ) ) || ( hasStartStopCommentMark && removeStartStopCommentFromSelection( v, startAttrib ) ); } } } void KateDocument::transform( KateView *v, const KateTextCursor &c, KateDocument::TextTransform t ) { editStart(); uint cl( c.line() ), cc( c.col() ); bool selectionRestored = false; if ( hasSelection() ) { // cache the selection and cursor, so we can be sure to restore. KateTextCursor selstart = v->selStart(); KateTextCursor selend = v->selEnd(); int ln = v->selStartLine(); while ( ln <= selend.line() ) { uint start, end; start = (ln == selstart.line() || v->blockSelectionMode()) ? selstart.col() : 0; end = (ln == selend.line() || v->blockSelectionMode()) ? selend.col() : lineLength( ln ); if ( start > end ) { uint t = start; start = end; end = t; } QString s = text( ln, start, ln, end ); QString o = s; if ( t == Uppercase ) s = s.upper(); else if ( t == Lowercase ) s = s.lower(); else // Capitalize { KateTextLine::Ptr l = m_buffer->plainLine( ln ); uint p ( 0 ); while( p < s.length() ) { // If bol or the character before is not in a word, up this one: // 1. if both start and p is 0, upper char. // 2. if blockselect or first line, and p == 0 and start-1 is not in a word, upper // 3. if p-1 is not in a word, upper. if ( ( ! start && ! p ) || ( ( ln == selstart.line() || v->blockSelectionMode() ) && ! p && ! highlight()->isInWord( l->getChar( start - 1 )) ) || ( p && ! highlight()->isInWord( s.at( p-1 ) ) ) ) s[p] = s.at(p).upper(); p++; } } if ( o != s ) { removeText( ln, start, ln, end ); insertText( ln, start, s ); } ln++; } // restore selection v->setSelection( selstart, selend ); selectionRestored = true; } else { // no selection QString o = text( cl, cc, cl, cc + 1 ); QString s; int n ( cc ); switch ( t ) { case Uppercase: s = o.upper(); break; case Lowercase: s = o.lower(); break; case Capitalize: { KateTextLine::Ptr l = m_buffer->plainLine( cl ); while ( n > 0 && highlight()->isInWord( l->getChar( n-1 ), l->attribute( n-1 ) ) ) n--; o = text( cl, n, cl, n + 1 ); s = o.upper(); } break; default: break; } if ( s != o ) { removeText( cl, n, cl, n+1 ); insertText( cl, n, s ); } } editEnd(); if ( ! selectionRestored ) v->setCursorPosition( cl, cc ); } void KateDocument::joinLines( uint first, uint last ) { // if ( first == last ) last += 1; editStart(); int line( first ); while ( first < last ) { // Normalize the whitespace in the joined lines by making sure there's // always exactly one space between the joined lines // This cannot be done in editUnwrapLine, because we do NOT want this // behaviour when deleting from the start of a line, just when explicitly // calling the join command KateTextLine::Ptr l = m_buffer->line( line ); KateTextLine::Ptr tl = m_buffer->line( line + 1 ); if ( !l || !tl ) { editEnd(); return; } int pos = tl->firstChar(); if ( pos >= 0 ) { if (pos != 0) editRemoveText( line + 1, 0, pos ); if ( !( l->length() == 0 || l->getChar( l->length() - 1 ).isSpace() ) ) editInsertText( line + 1, 0, " " ); } else { // Just remove the whitespace and let Kate handle the rest editRemoveText( line + 1, 0, tl->length() ); } editUnWrapLine( line ); first++; } editEnd(); } QString KateDocument::getWord( const KateTextCursor& cursor ) { int start, end, len; KateTextLine::Ptr textLine = m_buffer->plainLine(cursor.line()); len = textLine->length(); start = end = cursor.col(); if (start > len) // Probably because of non-wrapping cursor mode. return QString(""); while (start > 0 && highlight()->isInWord(textLine->getChar(start - 1), textLine->attribute(start - 1))) start--; while (end < len && highlight()->isInWord(textLine->getChar(end), textLine->attribute(end))) end++; len = end - start; return QString(&textLine->text()[start], len); } void KateDocument::tagLines(int start, int end) { for (uint z = 0; z < m_views.count(); z++) m_views.at(z)->tagLines (start, end, true); } void KateDocument::tagLines(KateTextCursor start, KateTextCursor end) { // May need to switch start/end cols if in block selection mode if (blockSelectionMode() && start.col() > end.col()) { int sc = start.col(); start.setCol(end.col()); end.setCol(sc); } for (uint z = 0; z < m_views.count(); z++) m_views.at(z)->tagLines(start, end, true); } void KateDocument::repaintViews(bool paintOnlyDirty) { for (uint z = 0; z < m_views.count(); z++) m_views.at(z)->repaintText(paintOnlyDirty); } void KateDocument::tagAll() { for (uint z = 0; z < m_views.count(); z++) { m_views.at(z)->tagAll(); m_views.at(z)->updateView (true); } } uint KateDocument::configFlags () { return config()->configFlags(); } void KateDocument::setConfigFlags (uint flags) { config()->setConfigFlags(flags); } inline bool isStartBracket( const QChar& c ) { return c == '{' || c == '[' || c == '('; } inline bool isEndBracket ( const QChar& c ) { return c == '}' || c == ']' || c == ')'; } inline bool isBracket ( const QChar& c ) { return isStartBracket( c ) || isEndBracket( c ); } /* Bracket matching uses the following algorithm: If in overwrite mode, match the bracket currently underneath the cursor. Otherwise, if the character to the right of the cursor is an starting bracket, match it. Otherwise if the character to the left of the cursor is a ending bracket, match it. Otherwise, if the the character to the left of the cursor is an starting bracket, match it. Otherwise, if the character to the right of the cursor is an ending bracket, match it. Otherwise, don't match anything. */ void KateDocument::newBracketMark( const KateTextCursor& cursor, KateBracketRange& bm, int maxLines ) { bm.setValid(false); bm.start() = cursor; if( !findMatchingBracket( bm.start(), bm.end(), maxLines ) ) return; bm.setValid(true); const int tw = config()->tabWidth(); const int indentStart = m_buffer->plainLine(bm.start().line())->indentDepth(tw); const int indentEnd = m_buffer->plainLine(bm.end().line())->indentDepth(tw); bm.setIndentMin(kMin(indentStart, indentEnd)); } bool KateDocument::findMatchingBracket( KateTextCursor& start, KateTextCursor& end, int maxLines ) { KateTextLine::Ptr textLine = m_buffer->plainLine( start.line() ); if( !textLine ) return false; QChar right = textLine->getChar( start.col() ); QChar left = textLine->getChar( start.col() - 1 ); QChar bracket; if ( config()->configFlags() & cfOvr ) { if( isBracket( right ) ) { bracket = right; } else { return false; } } else if ( isStartBracket( right ) ) { bracket = right; } else if ( isEndBracket( left ) ) { start.setCol(start.col() - 1); bracket = left; } else if ( isBracket( left ) ) { start.setCol(start.col() - 1); bracket = left; } else if ( isBracket( right ) ) { bracket = right; } else { return false; } QChar opposite; switch( bracket ) { case '{': opposite = '}'; break; case '}': opposite = '{'; break; case '[': opposite = ']'; break; case ']': opposite = '['; break; case '(': opposite = ')'; break; case ')': opposite = '('; break; default: return false; } bool forward = isStartBracket( bracket ); int startAttr = textLine->attribute( start.col() ); uint count = 0; int lines = 0; end = start; while( true ) { /* Increment or decrement, check base cases */ if( forward ) { end.setCol(end.col() + 1); if( end.col() >= lineLength( end.line() ) ) { if( end.line() >= (int)lastLine() ) return false; end.setPos(end.line() + 1, 0); textLine = m_buffer->plainLine( end.line() ); lines++; } } else { end.setCol(end.col() - 1); if( end.col() < 0 ) { if( end.line() <= 0 ) return false; end.setLine(end.line() - 1); end.setCol(lineLength( end.line() ) - 1); textLine = m_buffer->plainLine( end.line() ); lines++; } } if ((maxLines != -1) && (lines > maxLines)) return false; /* Easy way to skip comments */ if( textLine->attribute( end.col() ) != startAttr ) continue; /* Check for match */ QChar c = textLine->getChar( end.col() ); if( c == bracket ) { count++; } else if( c == opposite ) { if( count == 0 ) return true; count--; } } } void KateDocument::guiActivateEvent( KParts::GUIActivateEvent *ev ) { KParts::ReadWritePart::guiActivateEvent( ev ); if ( ev->activated() ) emit selectionChanged(); } void KateDocument::setDocName (QString name ) { if ( name == m_docName ) return; if ( !name.isEmpty() ) { // TODO check for similarly named documents m_docName = name; updateFileType (KateFactory::self()->fileTypeManager()->fileType (this)); emit nameChanged((Kate::Document *) this); return; } // if the name is set, and starts with FILENAME, it should not be changed! if ( ! url().isEmpty() && m_docName.startsWith( url().filename() ) ) return; int count = -1; for (uint z=0; z < KateFactory::self()->documents()->count(); z++) { if ( (KateFactory::self()->documents()->at(z) != this) && (KateFactory::self()->documents()->at(z)->url().filename() == url().filename()) ) if ( KateFactory::self()->documents()->at(z)->m_docNameNumber > count ) count = KateFactory::self()->documents()->at(z)->m_docNameNumber; } m_docNameNumber = count + 1; m_docName = url().filename(); if (m_docName.isEmpty()) m_docName = i18n ("Untitled"); if (m_docNameNumber > 0) m_docName = QString(m_docName + " (%1)").arg(m_docNameNumber+1); updateFileType (KateFactory::self()->fileTypeManager()->fileType (this)); emit nameChanged ((Kate::Document *) this); } void KateDocument::slotModifiedOnDisk( Kate::View * /*v*/ ) { if ( m_isasking < 0 ) { m_isasking = 0; return; } if ( !s_fileChangedDialogsActivated || m_isasking ) return; if (m_modOnHd && !url().isEmpty()) { m_isasking = 1; KateModOnHdPrompt p( this, m_modOnHdReason, reasonedMOHString(), widget() ); switch ( p.exec() ) { case KateModOnHdPrompt::Save: { m_modOnHd = false; KEncodingFileDialog::Result res=KEncodingFileDialog::getSaveURLAndEncoding(config()->encoding(), url().url(),QString::null,widget(),i18n("Save File")); kdDebug(13020)<<"got "<<res.URLs.count()<<" URLs"<<endl; if( ! res.URLs.isEmpty() && ! res.URLs.first().isEmpty() && checkOverwrite( res.URLs.first() ) ) { setEncoding( res.encoding ); if( ! saveAs( res.URLs.first() ) ) { KMessageBox::error( widget(), i18n("Save failed") ); m_modOnHd = true; } else emit modifiedOnDisc( this, false, 0 ); } else // the save as dialog was cancelled, we are still modified on disk { m_modOnHd = true; } m_isasking = 0; break; } case KateModOnHdPrompt::Reload: m_modOnHd = false; emit modifiedOnDisc( this, false, 0 ); reloadFile(); m_isasking = 0; break; case KateModOnHdPrompt::Ignore: m_modOnHd = false; emit modifiedOnDisc( this, false, 0 ); m_isasking = 0; break; case KateModOnHdPrompt::Overwrite: m_modOnHd = false; emit modifiedOnDisc( this, false, 0 ); m_isasking = 0; save(); break; default: // cancel: ignore next focus event m_isasking = -1; } } } void KateDocument::setModifiedOnDisk( int reason ) { m_modOnHdReason = reason; m_modOnHd = (reason > 0); emit modifiedOnDisc( this, (reason > 0), reason ); } class KateDocumentTmpMark { public: QString line; KTextEditor::Mark mark; }; void KateDocument::reloadFile() { if ( !url().isEmpty() ) { if (m_modOnHd && s_fileChangedDialogsActivated) { int i = KMessageBox::warningYesNoCancel (0, reasonedMOHString() + "\n\n" + i18n("What do you want to do?"), i18n("File Was Changed on Disk"), i18n("&Reload File"), i18n("&Ignore Changes")); if ( i != KMessageBox::Yes) { if (i == KMessageBox::No) { m_modOnHd = false; m_modOnHdReason = 0; emit modifiedOnDisc (this, m_modOnHd, 0); } return; } } QValueList<KateDocumentTmpMark> tmp; for( QIntDictIterator<KTextEditor::Mark> it( m_marks ); it.current(); ++it ) { KateDocumentTmpMark m; m.line = textLine (it.current()->line); m.mark = *it.current(); tmp.append (m); } uint mode = hlMode (); bool byUser = hlSetByUser; m_storedVariables.clear(); m_reloading = true; QValueList<int> lines, cols; for ( uint i=0; i < m_views.count(); i++ ) { lines.append( m_views.at( i )->cursorLine() ); cols.append( m_views.at( i )->cursorColumn() ); } KateDocument::openURL( url() ); for ( uint i=0; i < m_views.count(); i++ ) m_views.at( i )->setCursorPositionInternal( lines[ i ], cols[ i ], m_config->tabWidth(), false ); m_reloading = false; for ( QValueList<int>::size_type z=0; z < tmp.size(); z++ ) { if (z < numLines()) { if (textLine(tmp[z].mark.line) == tmp[z].line) setMark (tmp[z].mark.line, tmp[z].mark.type); } } if (byUser) setHlMode (mode); } } void KateDocument::flush () { closeURL (); } void KateDocument::setWordWrap (bool on) { config()->setWordWrap (on); } bool KateDocument::wordWrap () { return config()->wordWrap (); } void KateDocument::setWordWrapAt (uint col) { config()->setWordWrapAt (col); } unsigned int KateDocument::wordWrapAt () { return config()->wordWrapAt (); } void KateDocument::applyWordWrap () { // dummy to make the API happy } void KateDocument::setPageUpDownMovesCursor (bool on) { config()->setPageUpDownMovesCursor (on); } bool KateDocument::pageUpDownMovesCursor () { return config()->pageUpDownMovesCursor (); } void KateDocument::dumpRegionTree() { m_buffer->foldingTree()->debugDump(); } //END //BEGIN KTextEditor::CursorInterface stuff KTextEditor::Cursor *KateDocument::createCursor ( ) { return new KateSuperCursor (this, false, 0, 0, this); } void KateDocument::tagArbitraryLines(KateView* view, KateSuperRange* range) { if (view) view->tagLines(range->start(), range->end()); else tagLines(range->start(), range->end()); } void KateDocument::lineInfo (KateLineInfo *info, unsigned int line) { m_buffer->lineInfo(info,line); } KateCodeFoldingTree *KateDocument::foldingTree () { return m_buffer->foldingTree(); } void KateDocument::setEncoding (const QString &e) { if ( m_encodingSticky ) return; QString ce = m_config->encoding().lower(); if ( e.lower() == ce ) return; m_config->setEncoding( e ); if ( ! m_loading ) reloadFile(); } QString KateDocument::encoding() const { return m_config->encoding(); } void KateDocument::updateConfig () { emit undoChanged (); tagAll(); for (KateView * view = m_views.first(); view != 0L; view = m_views.next() ) { view->updateDocumentConfig (); } // switch indenter if needed if (m_indenter->modeNumber() != m_config->indentationMode()) { delete m_indenter; m_indenter = KateAutoIndent::createIndenter ( this, m_config->indentationMode() ); } m_indenter->updateConfig(); m_buffer->setTabWidth (config()->tabWidth()); // plugins for (uint i=0; i<KateFactory::self()->plugins().count(); i++) { if (config()->plugin (i)) loadPlugin (i); else unloadPlugin (i); } } //BEGIN Variable reader // "local variable" feature by anders, 2003 /* TODO add config options (how many lines to read, on/off) add interface for plugins/apps to set/get variables add view stuff */ QRegExp KateDocument::kvLine = QRegExp("kate:(.*)"); QRegExp KateDocument::kvLineWildcard = QRegExp("kate-wildcard\\((.*)\\):(.*)"); QRegExp KateDocument::kvLineMime = QRegExp("kate-mimetype\\((.*)\\):(.*)"); QRegExp KateDocument::kvVar = QRegExp("([\\w\\-]+)\\s+([^;]+)"); void KateDocument::readVariables(bool onlyViewAndRenderer) { if (!onlyViewAndRenderer) m_config->configStart(); // views! KateView *v; for (v = m_views.first(); v != 0L; v= m_views.next() ) { v->config()->configStart(); v->renderer()->config()->configStart(); } // read a number of lines in the top/bottom of the document for (uint i=0; i < kMin( 9U, numLines() ); ++i ) { readVariableLine( textLine( i ), onlyViewAndRenderer ); } if ( numLines() > 10 ) { for ( uint i = kMax(10U, numLines() - 10); i < numLines(); ++i ) { readVariableLine( textLine( i ), onlyViewAndRenderer ); } } if (!onlyViewAndRenderer) m_config->configEnd(); for (v = m_views.first(); v != 0L; v= m_views.next() ) { v->config()->configEnd(); v->renderer()->config()->configEnd(); } } void KateDocument::readVariableLine( QString t, bool onlyViewAndRenderer ) { // simple check first, no regex // no kate inside, no vars, simple... if (t.find("kate") < 0) return; // found vars, if any QString s; if ( kvLine.search( t ) > -1 ) { s = kvLine.cap(1); kdDebug (13020) << "normal variable line kate: matched: " << s << endl; } else if (kvLineWildcard.search( t ) > -1) // regex given { QStringList wildcards (QStringList::split(';', kvLineWildcard.cap(1))); QString nameOfFile = url().fileName(); bool found = false; for (QStringList::size_type i = 0; !found && i < wildcards.size(); ++i) { QRegExp wildcard (wildcards[i], true/*Qt::CaseSensitive*/, true/*QRegExp::Wildcard*/); found = wildcard.exactMatch (nameOfFile); } // nothing usable found... if (!found) return; s = kvLineWildcard.cap(2); kdDebug (13020) << "guarded variable line kate-wildcard: matched: " << s << endl; } else if (kvLineMime.search( t ) > -1) // mime-type given { QStringList types (QStringList::split(';', kvLineMime.cap(1))); // no matching type found if (!types.contains (mimeType ())) return; s = kvLineMime.cap(2); kdDebug (13020) << "guarded variable line kate-mimetype: matched: " << s << endl; } else // nothing found { return; } QStringList vvl; // view variable names vvl << "dynamic-word-wrap" << "dynamic-word-wrap-indicators" << "line-numbers" << "icon-border" << "folding-markers" << "bookmark-sorting" << "auto-center-lines" << "icon-bar-color" // renderer << "background-color" << "selection-color" << "current-line-color" << "bracket-highlight-color" << "word-wrap-marker-color" << "font" << "font-size" << "scheme"; int p( 0 ); QString var, val; while ( (p = kvVar.search( s, p )) > -1 ) { p += kvVar.matchedLength(); var = kvVar.cap( 1 ); val = kvVar.cap( 2 ).stripWhiteSpace(); bool state; // store booleans here int n; // store ints here // only apply view & renderer config stuff if (onlyViewAndRenderer) { if ( vvl.contains( var ) ) // FIXME define above setViewVariable( var, val ); } else { // BOOL SETTINGS if ( var == "word-wrap" && checkBoolValue( val, &state ) ) setWordWrap( state ); // ??? FIXME CHECK else if ( var == "block-selection" && checkBoolValue( val, &state ) ) setBlockSelectionMode( state ); // KateConfig::configFlags // FIXME should this be optimized to only a few calls? how? else if ( var == "backspace-indents" && checkBoolValue( val, &state ) ) m_config->setConfigFlags( KateDocumentConfig::cfBackspaceIndents, state ); else if ( var == "replace-tabs" && checkBoolValue( val, &state ) ) m_config->setConfigFlags( KateDocumentConfig::cfReplaceTabsDyn, state ); else if ( var == "remove-trailing-space" && checkBoolValue( val, &state ) ) m_config->setConfigFlags( KateDocumentConfig::cfRemoveTrailingDyn, state ); else if ( var == "wrap-cursor" && checkBoolValue( val, &state ) ) m_config->setConfigFlags( KateDocumentConfig::cfWrapCursor, state ); else if ( var == "auto-brackets" && checkBoolValue( val, &state ) ) m_config->setConfigFlags( KateDocumentConfig::cfAutoBrackets, state ); else if ( var == "overwrite-mode" && checkBoolValue( val, &state ) ) m_config->setConfigFlags( KateDocumentConfig::cfOvr, state ); else if ( var == "keep-indent-profile" && checkBoolValue( val, &state ) ) m_config->setConfigFlags( KateDocumentConfig::cfKeepIndentProfile, state ); else if ( var == "keep-extra-spaces" && checkBoolValue( val, &state ) ) m_config->setConfigFlags( KateDocumentConfig::cfKeepExtraSpaces, state ); else if ( var == "tab-indents" && checkBoolValue( val, &state ) ) m_config->setConfigFlags( KateDocumentConfig::cfTabIndents, state ); else if ( var == "show-tabs" && checkBoolValue( val, &state ) ) m_config->setConfigFlags( KateDocumentConfig::cfShowTabs, state ); else if ( var == "space-indent" && checkBoolValue( val, &state ) ) m_config->setConfigFlags( KateDocumentConfig::cfSpaceIndent, state ); else if ( var == "smart-home" && checkBoolValue( val, &state ) ) m_config->setConfigFlags( KateDocumentConfig::cfSmartHome, state ); else if ( var == "replace-trailing-space-save" && checkBoolValue( val, &state ) ) m_config->setConfigFlags( KateDocumentConfig::cfRemoveSpaces, state ); else if ( var == "auto-insert-doxygen" && checkBoolValue( val, &state) ) m_config->setConfigFlags( KateDocumentConfig::cfDoxygenAutoTyping, state); else if ( var == "mixed-indent" && checkBoolValue( val, &state ) ) m_config->setConfigFlags( KateDocumentConfig::cfMixedIndent, state ); // INTEGER SETTINGS else if ( var == "tab-width" && checkIntValue( val, &n ) ) m_config->setTabWidth( n ); else if ( var == "indent-width" && checkIntValue( val, &n ) ) m_config->setIndentationWidth( n ); else if ( var == "indent-mode" ) { if ( checkIntValue( val, &n ) ) m_config->setIndentationMode( n ); else m_config->setIndentationMode( KateAutoIndent::modeNumber( val) ); } else if ( var == "word-wrap-column" && checkIntValue( val, &n ) && n > 0 ) // uint, but hard word wrap at 0 will be no fun ;) m_config->setWordWrapAt( n ); else if ( var == "undo-steps" && checkIntValue( val, &n ) && n >= 0 ) setUndoSteps( n ); // STRING SETTINGS else if ( var == "eol" || var == "end-of-line" ) { QStringList l; l << "unix" << "dos" << "mac"; if ( (n = l.findIndex( val.lower() )) != -1 ) m_config->setEol( n ); } else if ( var == "encoding" ) m_config->setEncoding( val ); else if ( var == "syntax" || var == "hl" ) { for ( uint i=0; i < hlModeCount(); i++ ) { if ( hlModeName( i ).lower() == val.lower() ) { setHlMode( i ); break; } } } // VIEW SETTINGS else if ( vvl.contains( var ) ) setViewVariable( var, val ); else { m_storedVariables.insert( var, val ); emit variableChanged( var, val ); } } } } void KateDocument::setViewVariable( QString var, QString val ) { KateView *v; bool state; int n; QColor c; for (v = m_views.first(); v != 0L; v= m_views.next() ) { if ( var == "dynamic-word-wrap" && checkBoolValue( val, &state ) ) v->config()->setDynWordWrap( state ); else if ( var == "persistent-selection" && checkBoolValue( val, &state ) ) v->config()->setPersistentSelection( state ); //else if ( var = "dynamic-word-wrap-indicators" ) else if ( var == "line-numbers" && checkBoolValue( val, &state ) ) v->config()->setLineNumbers( state ); else if (var == "icon-border" && checkBoolValue( val, &state ) ) v->config()->setIconBar( state ); else if (var == "folding-markers" && checkBoolValue( val, &state ) ) v->config()->setFoldingBar( state ); else if ( var == "auto-center-lines" && checkIntValue( val, &n ) ) v->config()->setAutoCenterLines( n ); // FIXME uint, > N ?? else if ( var == "icon-bar-color" && checkColorValue( val, c ) ) v->renderer()->config()->setIconBarColor( c ); // RENDERER else if ( var == "background-color" && checkColorValue( val, c ) ) v->renderer()->config()->setBackgroundColor( c ); else if ( var == "selection-color" && checkColorValue( val, c ) ) v->renderer()->config()->setSelectionColor( c ); else if ( var == "current-line-color" && checkColorValue( val, c ) ) v->renderer()->config()->setHighlightedLineColor( c ); else if ( var == "bracket-highlight-color" && checkColorValue( val, c ) ) v->renderer()->config()->setHighlightedBracketColor( c ); else if ( var == "word-wrap-marker-color" && checkColorValue( val, c ) ) v->renderer()->config()->setWordWrapMarkerColor( c ); else if ( var == "font" || ( var == "font-size" && checkIntValue( val, &n ) ) ) { QFont _f( *v->renderer()->config()->font( ) ); if ( var == "font" ) { _f.setFamily( val ); _f.setFixedPitch( QFont( val ).fixedPitch() ); } else _f.setPointSize( n ); v->renderer()->config()->setFont( _f ); } else if ( var == "scheme" ) { v->renderer()->config()->setSchema( KateFactory::self()->schemaManager()->number( val ) ); } } } bool KateDocument::checkBoolValue( QString val, bool *result ) { val = val.stripWhiteSpace().lower(); QStringList l; l << "1" << "on" << "true"; if ( l.contains( val ) ) { *result = true; return true; } l.clear(); l << "0" << "off" << "false"; if ( l.contains( val ) ) { *result = false; return true; } return false; } bool KateDocument::checkIntValue( QString val, int *result ) { bool ret( false ); *result = val.toInt( &ret ); return ret; } bool KateDocument::checkColorValue( QString val, QColor &c ) { c.setNamedColor( val ); return c.isValid(); } // KTextEditor::variable QString KateDocument::variable( const QString &name ) const { if ( m_storedVariables.contains( name ) ) return m_storedVariables[ name ]; return ""; } //END void KateDocument::slotModOnHdDirty (const QString &path) { if ((path == m_dirWatchFile) && (!m_modOnHd || m_modOnHdReason != 1)) { // compare md5 with the one we have (if we have one) if ( ! m_digest.isEmpty() ) { QCString tmp; if ( createDigest( tmp ) && tmp == m_digest ) return; } m_modOnHd = true; m_modOnHdReason = 1; // reenable dialog if not running atm if (m_isasking == -1) m_isasking = false; emit modifiedOnDisc (this, m_modOnHd, m_modOnHdReason); } } void KateDocument::slotModOnHdCreated (const QString &path) { if ((path == m_dirWatchFile) && (!m_modOnHd || m_modOnHdReason != 2)) { m_modOnHd = true; m_modOnHdReason = 2; // reenable dialog if not running atm if (m_isasking == -1) m_isasking = false; emit modifiedOnDisc (this, m_modOnHd, m_modOnHdReason); } } void KateDocument::slotModOnHdDeleted (const QString &path) { if ((path == m_dirWatchFile) && (!m_modOnHd || m_modOnHdReason != 3)) { m_modOnHd = true; m_modOnHdReason = 3; // reenable dialog if not running atm if (m_isasking == -1) m_isasking = false; emit modifiedOnDisc (this, m_modOnHd, m_modOnHdReason); } } bool KateDocument::createDigest( QCString &result ) { bool ret = false; result = ""; if ( url().isLocalFile() ) { QFile f ( url().path() ); if ( f.open( IO_ReadOnly) ) { KMD5 md5; ret = md5.update( f ); md5.hexDigest( result ); f.close(); ret = true; } } return ret; } QString KateDocument::reasonedMOHString() const { switch( m_modOnHdReason ) { case 1: return i18n("The file '%1' was modified by another program.").arg( url().prettyURL() ); break; case 2: return i18n("The file '%1' was created by another program.").arg( url().prettyURL() ); break; case 3: return i18n("The file '%1' was deleted by another program.").arg( url().prettyURL() ); break; default: return QString(); } } void KateDocument::removeTrailingSpace( uint line ) { // remove trailing spaces from left line if required if ( config()->configFlags() & KateDocumentConfig::cfRemoveTrailingDyn ) { KateTextLine::Ptr ln = kateTextLine( line ); if ( ! ln ) return; if ( line == activeView()->cursorLine() && activeView()->cursorColumnReal() >= (uint)kMax(0,ln->lastChar()) ) return; if ( ln->length() ) { uint p = ln->lastChar() + 1; uint l = ln->length() - p; if ( l ) editRemoveText( line, p, l); } } } void KateDocument::updateFileType (int newType, bool user) { if (user || !m_fileTypeSetByUser) { const KateFileType *t = 0; if ((newType == -1) || (t = KateFactory::self()->fileTypeManager()->fileType (newType))) { m_fileType = newType; if (t) { m_config->configStart(); // views! KateView *v; for (v = m_views.first(); v != 0L; v= m_views.next() ) { v->config()->configStart(); v->renderer()->config()->configStart(); } readVariableLine( t->varLine ); m_config->configEnd(); for (v = m_views.first(); v != 0L; v= m_views.next() ) { v->config()->configEnd(); v->renderer()->config()->configEnd(); } } } } } uint KateDocument::documentNumber () const { return KTextEditor::Document::documentNumber (); } void KateDocument::slotQueryClose_save(bool *handled, bool* abortClosing) { *handled=true; *abortClosing=true; if (m_url.isEmpty()) { KEncodingFileDialog::Result res=KEncodingFileDialog::getSaveURLAndEncoding(config()->encoding(), QString::null,QString::null,0,i18n("Save File")); if( res.URLs.isEmpty() || !checkOverwrite( res.URLs.first() ) ) { *abortClosing=true; return; } setEncoding( res.encoding ); saveAs( res.URLs.first() ); *abortClosing=false; } else { save(); *abortClosing=false; } } bool KateDocument::checkOverwrite( KURL u ) { if( !u.isLocalFile() ) return true; QFileInfo info( u.path() ); if( !info.exists() ) return true; return KMessageBox::Cancel != KMessageBox::warningContinueCancel( 0, i18n( "A file named \"%1\" already exists. " "Are you sure you want to overwrite it?" ).arg( info.fileName() ), i18n( "Overwrite File?" ), i18n( "&Overwrite" ) ); } void KateDocument::setDefaultEncoding (const QString &encoding) { s_defaultEncoding = encoding; } //BEGIN KTextEditor::TemplateInterface bool KateDocument::insertTemplateTextImplementation ( uint line, uint column, const QString &templateString, const QMap<QString,QString> &initialValues, QWidget *) { return (new KateTemplateHandler(this,line,column,templateString,initialValues))->initOk(); } void KateDocument::testTemplateCode() { int col=activeView()->cursorColumn(); int line=activeView()->cursorLine(); insertTemplateText(line,col,"for ${index} \\${NOPLACEHOLDER} ${index} ${blah} ${fullname} \\$${Placeholder} \\${${PLACEHOLDER2}}\n next line:${ANOTHERPLACEHOLDER} $${DOLLARBEFOREPLACEHOLDER} {NOTHING} {\n${cursor}\n}",QMap<QString,QString>()); } bool KateDocument::invokeTabInterceptor(KKey key) { if (m_tabInterceptor) return (*m_tabInterceptor)(key); return false; } bool KateDocument::setTabInterceptor(KateKeyInterceptorFunctor *interceptor) { if (m_tabInterceptor) return false; m_tabInterceptor=interceptor; return true; } bool KateDocument::removeTabInterceptor(KateKeyInterceptorFunctor *interceptor) { if (m_tabInterceptor!=interceptor) return false; m_tabInterceptor=0; return true; } //END KTextEditor::TemplateInterface //BEGIN DEPRECATED STUFF bool KateDocument::setSelection ( uint startLine, uint startCol, uint endLine, uint endCol ) { if (m_activeView) return m_activeView->setSelection (startLine, startCol, endLine, endCol); return false; } bool KateDocument::clearSelection () { if (m_activeView) return m_activeView->clearSelection(); return false; } bool KateDocument::hasSelection () const { if (m_activeView) return m_activeView->hasSelection (); return false; } QString KateDocument::selection () const { if (m_activeView) return m_activeView->selection (); return QString(""); } bool KateDocument::removeSelectedText () { if (m_activeView) return m_activeView->removeSelectedText (); return false; } bool KateDocument::selectAll() { if (m_activeView) return m_activeView->selectAll (); return false; } int KateDocument::selStartLine() { if (m_activeView) return m_activeView->selStartLine (); return 0; } int KateDocument::selStartCol() { if (m_activeView) return m_activeView->selStartCol (); return 0; } int KateDocument::selEndLine() { if (m_activeView) return m_activeView->selEndLine (); return 0; } int KateDocument::selEndCol() { if (m_activeView) return m_activeView->selEndCol (); return 0; } bool KateDocument::blockSelectionMode () { if (m_activeView) return m_activeView->blockSelectionMode (); return false; } bool KateDocument::setBlockSelectionMode (bool on) { if (m_activeView) return m_activeView->setBlockSelectionMode (on); return false; } bool KateDocument::toggleBlockSelectionMode () { if (m_activeView) return m_activeView->toggleBlockSelectionMode (); return false; } //END DEPRECATED //END DEPRECATED STUFF // kate: space-indent on; indent-width 2; replace-tabs on;

kate Main Page Namespace List Class Hierarchy Alphabetical List Class List File List Namespace Members Class Members Related Pages API Dox arts dcop dnssd interfaces     interface     library   kspeech   ktexteditor kabc kate kcmshell kdecore kded kdefx kdeprint kdesu kdeui kdoctools khtml kimgio kinit kio   bookmarks   httpfilter   kfile   kio   kioexec   kpasswdserver   kssl kioslave   http kjs kmdi   kmdi knewstuff kparts kresources kspell2 kunittest kutils kwallet libkmid libkscreensaver

KDE Home | KDE Accessibility Home | Description of Access Keys

Maintained by Adriaan de Groot and Allen Winter.
KDE and K Desktop Environment are trademarks of KDE e.V. | Legal