katedocument.h
/* 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 02110-1301, USA.
*/
#ifndef _KATE_DOCUMENT_H_
#define _KATE_DOCUMENT_H_
#include "katesupercursor.h"
#include "katetextline.h"
#include "kateundo.h"
#include "katebuffer.h"
#include "katecodefoldinghelpers.h"
#include "../interfaces/document.h"
#include <ktexteditor/configinterfaceextension.h>
#include <ktexteditor/encodinginterface.h>
#include <ktexteditor/sessionconfiginterface.h>
#include <ktexteditor/editinterfaceext.h>
#include <ktexteditor/templateinterface.h>
#include <dcopobject.h>
#include <kmimetype.h>
#include <klocale.h>
#include <qintdict.h>
#include <qmap.h>
#include <qdatetime.h>
namespace KTextEditor { class Plugin; }
namespace KIO { class TransferJob; }
class KateUndoGroup;
class KateCmd;
class KateAttribute;
class KateAutoIndent;
class KateCodeFoldingTree;
class KateBuffer;
class KateView;
class KateViewInternal;
class KateArbitraryHighlight;
class KateSuperRange;
class KateLineInfo;
class KateBrowserExtension;
class KateDocumentConfig;
class KateHighlighting;
class KatePartPluginItem;
class KatePartPluginInfo;
class KTempFile;
class QTimer;
class KateKeyInterceptorFunctor;
//
// Kate KTextEditor::Document class (and even KTextEditor::Editor ;)
//
class KateDocument : public Kate::Document,
public Kate::DocumentExt,
public KTextEditor::ConfigInterfaceExtension,
public KTextEditor::EncodingInterface,
public KTextEditor::SessionConfigInterface,
public KTextEditor::EditInterfaceExt,
public KTextEditor::TemplateInterface,
public DCOPObject
{
K_DCOP
Q_OBJECT
friend class KateViewInternal;
friend class KateRenderer;
public:
KateDocument (bool bSingleViewMode=false, bool bBrowserView=false, bool bReadOnly=false,
QWidget *parentWidget = 0, const char *widgetName = 0, QObject * = 0, const char * = 0);
~KateDocument ();
bool closeURL();
//
// Plugins section
//
public:
void unloadAllPlugins ();
void enableAllPluginsGUI (KateView *view);
void disableAllPluginsGUI (KateView *view);
void loadPlugin (uint pluginIndex);
void unloadPlugin (uint pluginIndex);
void enablePluginGUI (KTextEditor::Plugin *plugin, KateView *view);
void enablePluginGUI (KTextEditor::Plugin *plugin);
void disablePluginGUI (KTextEditor::Plugin *plugin, KateView *view);
void disablePluginGUI (KTextEditor::Plugin *plugin);
private:
QMemArray<KTextEditor::Plugin *> m_plugins;
public:
bool readOnly () const { return m_bReadOnly; }
bool browserView () const { return m_bBrowserView; }
bool singleViewMode () const { return m_bSingleViewMode; }
KateBrowserExtension *browserExtension () { return m_extension; }
private:
// only to make part work, don't change it !
bool m_bSingleViewMode;
bool m_bBrowserView;
bool m_bReadOnly;
KateBrowserExtension *m_extension;
//
// KTextEditor::Document stuff
//
public:
KTextEditor::View *createView( QWidget *parent, const char *name );
QPtrList<KTextEditor::View> views () const;
inline KateView *activeView () const { return m_activeView; }
private:
QPtrList<KateView> m_views;
QPtrList<KTextEditor::View> m_textEditViews;
KateView *m_activeView;
void setActiveView( KateView *view );
//
// KTextEditor::ConfigInterfaceExtension stuff
//
public slots:
uint configPages () const;
KTextEditor::ConfigPage *configPage (uint number = 0, QWidget *parent = 0, const char *name=0 );
QString configPageName (uint number = 0) const;
QString configPageFullName (uint number = 0) const;
QPixmap configPagePixmap (uint number = 0, int size = KIcon::SizeSmall) const;
//
// KTextEditor::EditInterface stuff
//
public slots:
QString text() const;
QString text ( uint startLine, uint startCol, uint endLine, uint endCol ) const;
QString text ( uint startLine, uint startCol, uint endLine, uint endCol, bool blockwise ) const;
QString textLine ( uint line ) const;
bool setText(const QString &);
bool clear ();
bool insertText ( uint line, uint col, const QString &s );
bool insertText ( uint line, uint col, const QString &s, bool blockwise );
bool removeText ( uint startLine, uint startCol, uint endLine, uint endCol );
bool removeText ( uint startLine, uint startCol, uint endLine, uint endCol, bool blockwise );
bool insertLine ( uint line, const QString &s );
bool removeLine ( uint line );
uint numLines() const;
uint numVisLines() const;
uint length () const;
int lineLength ( uint line ) const;
signals:
void textChanged ();
void charactersInteractivelyInserted(int ,int ,const QString&);
void charactersSemiInteractivelyInserted(int ,int ,const QString&);
void backspacePressed();
public:
//BEGIN editStart/editEnd (start, end, undo, cursor update, view update)
void editStart (bool withUndo = true);
void editBegin () { editStart(); }
void editEnd ();
private:
bool m_isInUndo;
//END editStart/editEnd
//BEGIN LINE BASED INSERT/REMOVE STUFF (editStart() and editEnd() included)
public:
bool editInsertText ( uint line, uint col, const QString &s );
bool editRemoveText ( uint line, uint col, uint len );
bool editMarkLineAutoWrapped ( uint line, bool autowrapped );
bool editWrapLine ( uint line, uint col, bool newLine = true, bool *newLineAdded = 0 );
bool editUnWrapLine ( uint line, bool removeLine = true, uint length = 0 );
bool editInsertLine ( uint line, const QString &s );
bool editRemoveLine ( uint line );
bool wrapText (uint startLine, uint endLine);
//END LINE BASED INSERT/REMOVE STUFF
signals:
void editTextInserted ( uint line, uint col, uint len);
void editTextRemoved ( uint line, uint col, uint len);
void editLineWrapped ( uint line, uint col, uint len );
void editLineUnWrapped ( uint line, uint col );
void editLineInserted ( uint line );
void editLineRemoved ( uint line );
private:
void undoStart();
void undoEnd();
void undoSafePoint();
private slots:
void undoCancel();
private:
void editAddUndo (KateUndoGroup::UndoType type, uint line, uint col, uint len, const QString &text);
uint editSessionNumber;
bool editIsRunning;
bool editWithUndo;
bool m_undoComplexMerge;
KateUndoGroup* m_editCurrentUndo;
//
// KTextEditor::UndoInterface stuff
//
public slots:
void undo ();
void redo ();
void clearUndo ();
void clearRedo ();
uint undoCount () const;
uint redoCount () const;
uint undoSteps () const;
void setUndoSteps ( uint steps );
private:
friend class KateTemplateHandler;
private:
QPtrList<KateSuperCursor> m_superCursors;
//
// some internals for undo/redo
//
QPtrList<KateUndoGroup> undoItems;
QPtrList<KateUndoGroup> redoItems;
bool m_undoDontMerge; //create a setter later on and remove the friend declaration
bool m_undoIgnoreCancel;
QTimer* m_undoMergeTimer;
// these two variables are for resetting the document to
// non-modified if all changes have been undone...
KateUndoGroup* lastUndoGroupWhenSaved;
KateUndoGroup* lastRedoGroupWhenSaved;
bool docWasSavedWhenUndoWasEmpty;
bool docWasSavedWhenRedoWasEmpty;
// this sets
void updateModified();
signals:
void undoChanged ();
void textInserted(int line,int column);
//
// KTextEditor::CursorInterface stuff
//
public slots:
KTextEditor::Cursor *createCursor ();
QPtrList<KTextEditor::Cursor> cursors () const;
private:
QPtrList<KTextEditor::Cursor> myCursors;
//
// KTextEditor::SearchInterface stuff
//
public slots:
bool searchText (unsigned int startLine, unsigned int startCol,
const QString &text, unsigned int *foundAtLine, unsigned int *foundAtCol,
unsigned int *matchLen, bool casesensitive = true, bool backwards = false);
bool searchText (unsigned int startLine, unsigned int startCol,
const QRegExp &regexp, unsigned int *foundAtLine, unsigned int *foundAtCol,
unsigned int *matchLen, bool backwards = false);
//
// KTextEditor::HighlightingInterface stuff
//
public slots:
uint hlMode ();
bool setHlMode (uint mode);
uint hlModeCount ();
QString hlModeName (uint mode);
QString hlModeSectionName (uint mode);
public:
void bufferHlChanged ();
private:
void setDontChangeHlOnSave();
signals:
void hlChanged ();
//
// Kate::ArbitraryHighlightingInterface stuff
//
public:
KateArbitraryHighlight* arbitraryHL() const { return m_arbitraryHL; };
private slots:
void tagArbitraryLines(KateView* view, KateSuperRange* range);
//
// KTextEditor::ConfigInterface stuff
//
public slots:
void readConfig ();
void writeConfig ();
void readConfig (KConfig *);
void writeConfig (KConfig *);
void readSessionConfig (KConfig *);
void writeSessionConfig (KConfig *);
void configDialog ();
//
// KTextEditor::MarkInterface and MarkInterfaceExtension
//
public slots:
uint mark( uint line );
void setMark( uint line, uint markType );
void clearMark( uint line );
void addMark( uint line, uint markType );
void removeMark( uint line, uint markType );
QPtrList<KTextEditor::Mark> marks();
void clearMarks();
void setPixmap( MarkInterface::MarkTypes, const QPixmap& );
void setDescription( MarkInterface::MarkTypes, const QString& );
QString markDescription( MarkInterface::MarkTypes );
QPixmap *markPixmap( MarkInterface::MarkTypes );
QColor markColor( MarkInterface::MarkTypes );
void setMarksUserChangable( uint markMask );
uint editableMarks();
signals:
void marksChanged();
void markChanged( KTextEditor::Mark, KTextEditor::MarkInterfaceExtension::MarkChangeAction );
private:
QIntDict<KTextEditor::Mark> m_marks;
QIntDict<QPixmap> m_markPixmaps;
QIntDict<QString> m_markDescriptions;
uint m_editableMarks;
//
// KTextEditor::PrintInterface
//
public slots:
bool printDialog ();
bool print ();
//
// KTextEditor::DocumentInfoInterface ( ### unfinished )
//
public:
QString mimeType();
long fileSize();
QString niceFileSize();
KMimeType::Ptr mimeTypeForContent();
//
// KTextEditor::VariableInterface
//
public:
QString variable( const QString &name ) const;
signals:
void variableChanged( const QString &, const QString & );
private:
QMap<QString, QString> m_storedVariables;
//
// KParts::ReadWrite stuff
//
public:
bool openURL( const KURL &url );
/* Anders:
I reimplemented this, since i need to check if backup succeeded
if requested */
bool save();
/* Anders: Reimplemented to do kate specific stuff */
bool saveAs( const KURL &url );
bool openFile (KIO::Job * job);
bool openFile ();
bool saveFile ();
void setReadWrite ( bool readwrite = true );
void setModified( bool m );
private slots:
void slotDataKate ( KIO::Job* kio_job, const QByteArray &data );
void slotFinishedKate ( KIO::Job * job );
private:
void abortLoadKate();
void activateDirWatch ();
void deactivateDirWatch ();
QString m_dirWatchFile;
//
// Kate::Document stuff, this is all deprecated!!!!!!!!!!
//
public:
Kate::ConfigPage *colorConfigPage (QWidget *) { return 0; }
Kate::ConfigPage *fontConfigPage (QWidget *) { return 0; }
Kate::ConfigPage *indentConfigPage (QWidget *) { return 0; }
Kate::ConfigPage *selectConfigPage (QWidget *) { return 0; }
Kate::ConfigPage *editConfigPage (QWidget *) { return 0; }
Kate::ConfigPage *keysConfigPage (QWidget *) { return 0; }
Kate::ConfigPage *hlConfigPage (QWidget *) { return 0; }
Kate::ConfigPage *viewDefaultsConfigPage (QWidget *) { return 0; }
Kate::ConfigPage *saveConfigPage( QWidget * ) { return 0; }
Kate::ActionMenu *hlActionMenu (const QString& /* text */, QObject* /* parent */ = 0, const char* /* name */ = 0) { return 0; }
Kate::ActionMenu *exportActionMenu (const QString& /* text */, QObject* /* parent */ = 0, const char* /* name */ = 0) { return 0; }
public:
bool typeChars ( KateView *type, const QString &chars );
inline uint lastLine() const { return numLines()-1; }
uint configFlags ();
void setConfigFlags (uint flags);
// Repaint all of all of the views
void repaintViews(bool paintOnlyDirty = true);
inline KateHighlighting *highlight () { return m_buffer->highlight(); }
inline KateHighlighting *highlight () const { return m_buffer->highlight(); }
public slots: //please keep prototypes and implementations in same order
void tagLines(int start, int end);
void tagLines(KateTextCursor start, KateTextCursor end);
//export feature, obsolute
public slots:
void exportAs(const QString&) { };
signals:
void modifiedChanged ();
void preHighlightChanged(uint);
private slots:
void internalHlChanged();
public:
void addView(KTextEditor::View *);
void removeView(KTextEditor::View *);
void addSuperCursor(class KateSuperCursor *, bool privateC);
void removeSuperCursor(class KateSuperCursor *, bool privateC);
bool ownedView(KateView *);
bool isLastView(int numViews);
uint currentColumn( const KateTextCursor& );
void newLine( KateTextCursor&, KateViewInternal * ); // Changes input
void backspace( KateView *view, const KateTextCursor& );
void del( KateView *view, const KateTextCursor& );
void transpose( const KateTextCursor& );
void paste ( KateView* view );
public:
void insertIndentChars ( KateView *view );
void indent ( KateView *view, uint line, int change );
void comment ( KateView *view, uint line, uint column, int change );
void align ( KateView *view, uint line );
enum TextTransform { Uppercase, Lowercase, Capitalize };
void transform ( KateView *view, const KateTextCursor &, TextTransform );
void joinLines( uint first, uint last );
private:
void optimizeLeadingSpace( uint line, int flags, int change );
void replaceWithOptimizedSpace( uint line, uint upto_column, uint space, int flags );
bool removeStringFromBegining(int line, QString &str);
bool removeStringFromEnd(int line, QString &str);
bool nextNonSpaceCharPos(int &line, int &col);
bool previousNonSpaceCharPos(int &line, int &col);
void addStartLineCommentToSingleLine(int line, int attrib=0);
bool removeStartLineCommentFromSingleLine(int line, int attrib=0);
void addStartStopCommentToSingleLine(int line, int attrib=0);
bool removeStartStopCommentFromSingleLine(int line, int attrib=0);
bool removeStartStopCommentFromRegion(const KateTextCursor &start, const KateTextCursor &end, int attrib=0);
void addStartStopCommentToSelection( KateView *view, int attrib=0 );
void addStartLineCommentToSelection( KateView *view, int attrib=0 );
bool removeStartStopCommentFromSelection( KateView *view, int attrib=0 );
bool removeStartLineCommentFromSelection( KateView *view, int attrib=0 );
public:
QString getWord( const KateTextCursor& cursor );
public:
void tagAll();
void newBracketMark( const KateTextCursor& start, KateBracketRange& bm, int maxLines = -1 );
bool findMatchingBracket( KateTextCursor& start, KateTextCursor& end, int maxLines = -1 );
private:
void guiActivateEvent( KParts::GUIActivateEvent *ev );
public:
QString docName () {return m_docName;};
void setDocName (QString docName);
void lineInfo (KateLineInfo *info, unsigned int line);
KateCodeFoldingTree *foldingTree ();
public:
bool isModifiedOnDisc() { return m_modOnHd; };
void isModOnHD( bool =false ) {};
void setModifiedOnDisk( int reason );
public slots:
void slotModifiedOnDisk( Kate::View *v=0 );
void reloadFile();
private:
int m_isasking; // don't reenter slotModifiedOnDisk when this is true
// -1: ignore once, 0: false, 1: true
public slots:
void setEncoding (const QString &e);
QString encoding() const;
public slots:
void setWordWrap (bool on);
bool wordWrap ();
void setWordWrapAt (uint col);
uint wordWrapAt ();
public slots:
void setPageUpDownMovesCursor(bool on);
bool pageUpDownMovesCursor();
signals:
void modStateChanged (Kate::Document *doc);
void nameChanged (Kate::Document *doc);
public slots:
// clear buffer/filename - update the views
void flush ();
signals:
void fileNameChanged ();
public slots:
void applyWordWrap ();
// code folding
public:
inline uint getRealLine(unsigned int virtualLine)
{
return m_buffer->lineNumber (virtualLine);
}
inline uint getVirtualLine(unsigned int realLine)
{
return m_buffer->lineVisibleNumber (realLine);
}
inline uint visibleLines ()
{
return m_buffer->countVisible ();
}
inline KateTextLine::Ptr kateTextLine(uint i)
{
return m_buffer->line (i);
}
inline KateTextLine::Ptr plainKateTextLine(uint i)
{
return m_buffer->plainLine (i);
}
signals:
void codeFoldingUpdated();
void aboutToRemoveText(const KateTextRange&);
void textRemoved();
private slots:
void slotModOnHdDirty (const QString &path);
void slotModOnHdCreated (const QString &path);
void slotModOnHdDeleted (const QString &path);
private:
bool createDigest ( QCString &result );
QString reasonedMOHString() const;
void removeTrailingSpace( uint line );
public:
void updateFileType (int newType, bool user = false);
int fileType () const { return m_fileType; };
//
// REALLY internal data ;)
//
private:
// text buffer
KateBuffer *m_buffer;
KateArbitraryHighlight* m_arbitraryHL;
KateAutoIndent *m_indenter;
bool hlSetByUser;
bool m_modOnHd;
unsigned char m_modOnHdReason;
QCString m_digest; // MD5 digest, updated on load/save
QString m_docName;
int m_docNameNumber;
// file type !!!
int m_fileType;
bool m_fileTypeSetByUser;
bool m_reloading;
bool m_loading;
bool m_encodingSticky;
public slots:
void slotQueryClose_save(bool *handled, bool* abortClosing);
public:
void makeAttribs (bool needInvalidate = true);
static bool checkOverwrite( KURL u );
static void setDefaultEncoding (const QString &encoding);
void setEncodingSticky( bool e ) { m_encodingSticky = e; }
public:
inline KateDocumentConfig *config () { return m_config; };
void updateConfig ();
private:
KateDocumentConfig *m_config;
private:
void readDirConfig ();
void readVariables(bool onlyViewAndRenderer = false);
void readVariableLine( QString t, bool onlyViewAndRenderer = false );
void setViewVariable( QString var, QString val );
static bool checkBoolValue( QString value, bool *result );
static bool checkIntValue( QString value, int *result );
static bool checkColorValue( QString value, QColor &col );
static QRegExp kvLine;
static QRegExp kvLineWildcard;
static QRegExp kvLineMime;
static QRegExp kvVar;
KIO::TransferJob *m_job;
KTempFile *m_tempFile;
// TemplateInterface
public:
bool setTabInterceptor(KateKeyInterceptorFunctor *interceptor); /* perhaps make it moregeneral like an eventfilter*/
bool removeTabInterceptor(KateKeyInterceptorFunctor *interceptor);
bool invokeTabInterceptor(KKey);
protected:
virtual bool insertTemplateTextImplementation ( uint line, uint column, const QString &templateString, const QMap<QString,QString> &initialValues, QWidget *parentWindow=0 );
KateKeyInterceptorFunctor *m_tabInterceptor;
protected slots:
void testTemplateCode();
void dumpRegionTree();
//BEGIN DEPRECATED
//
// KTextEditor::SelectionInterface stuff
// DEPRECATED, this will be removed for KDE 4.x !!!!!!!!!!!!!!!!!!!!
//
public slots:
bool setSelection ( uint startLine, uint startCol, uint endLine, uint endCol );
bool clearSelection ();
bool hasSelection () const;
QString selection () const;
bool removeSelectedText ();
bool selectAll();
//
// KTextEditor::SelectionInterfaceExt
//
int selStartLine();
int selStartCol();
int selEndLine();
int selEndCol();
// hack, only there to still support the deprecated stuff, will be removed for KDE 4.x
#undef signals
#define signals public
signals:
#undef signals
#define signals protected
void selectionChanged ();
//
// KTextEditor::BlockSelectionInterface stuff
// DEPRECATED, this will be removed for KDE 4.x !!!!!!!!!!!!!!!!!!!!
//
public slots:
bool blockSelectionMode ();
bool setBlockSelectionMode (bool on);
bool toggleBlockSelectionMode ();
private:
//END DEPRECATED
k_dcop:
uint documentNumber () const;
};
#endif
// kate: space-indent on; indent-width 2; replace-tabs on;
KStdAction::saveAs
KAction * saveAs(const QObject *recvr, const char *slot, KActionCollection *parent, const char *name=0)
KateBrowserExtension
Interface for embedding KateDocument into a browser.
Definition: katedocumenthelpers.h:36
KURL
KateTextCursor
Simple cursor class with no document pointer.
Definition: katecursor.h:33
KateAttribute
The Attribute class incorporates all text decorations supported by Kate.
Definition: kateattribute.h:32
KSharedPtr
flush
kndbgstream & flush(kndbgstream &s)
KateSuperRange
Represents a range of text, from the start() to the end().
Definition: katesupercursor.h:168
KStdAccel::paste
const KShortcut & paste()
Kate::Document
This interface provides access to the Kate Document class.
Definition: document.h:182
Kate::Document::docName
virtual QString docName()
Returns the document name.
Definition: document.h:217
Kate::View
The Kate::View text editor interface.
Definition: view.h:42
Kate::DocumentExt
Extensions to the Document Interface.
Definition: document.h:347
klocale.h
KateUndoGroup
Class to manage a group of undo items.
Definition: kateundo.h:33
KateRenderer
Handles all of the work of rendering the text (used for the views and printing)
Definition: katerenderer.h:42
KStdAccel::save
const KShortcut & save()
KIcon::SizeSmall
KateAutoIndent
Provides Auto-Indent functionality for katepart.
Definition: kateautoindent.h:70
KStdAccel::redo
const KShortcut & redo()
Kate::Document::editConfigPage
virtual ConfigPage * editConfigPage(QWidget *)=0
Kate::Document::hlConfigPage
virtual ConfigPage * hlConfigPage(QWidget *)=0
KStdAction::clear
KAction * clear(const QObject *recvr, const char *slot, KActionCollection *parent, const char *name=0)
KParts::GUIActivateEvent
Kate::Document::isModOnHD
virtual void isModOnHD(bool=false)
deprecated for KDE 4.0, just does reloadFile, which will ask the normal "do you want it really" quest...
Definition: document.h:212
KStdAccel::selectAll
const KShortcut & selectAll()
KTempFile
Kate::Document::keysConfigPage
virtual ConfigPage * keysConfigPage(QWidget *)=0
KateUndoGroup::UndoType
UndoType
Types for undo items.
Definition: kateundo.h:62
Kate::Document::indentConfigPage
virtual ConfigPage * indentConfigPage(QWidget *)=0
KConfig
KKey
Kate::Document::colorConfigPage
virtual ConfigPage * colorConfigPage(QWidget *)=0
Kate::Document::selectConfigPage
virtual ConfigPage * selectConfigPage(QWidget *)=0
Kate::DocumentExt::slotModifiedOnDisk
virtual void slotModifiedOnDisk(View *v=0)=0
These stuff is implemented as slots in the real document.
Kate::Document::reloadFile
virtual void reloadFile()=0
Reloads the current document from disk if possible.
Kate::Document::setDocName
virtual void setDocName(QString)
Sets the document name.
Definition: document.h:225
KStdAccel::undo
const KShortcut & undo()
KateSuperCursor
Possible additional features:
Definition: katesupercursor.h:45
DCOPObject
Kate::Document::fontConfigPage
virtual ConfigPage * fontConfigPage(QWidget *)=0
KStdAccel::print
const KShortcut & print()
KateArbitraryHighlight
An arbitrary highlighting interface for Kate.
Definition: katearbitraryhighlight.h:60
KateBuffer
The KateBuffer class maintains a collections of lines.
Definition: katebuffer.h:341
Kate::DocumentExt::setModifiedOnDisk
virtual void setModifiedOnDisk(int reason)=0
For client apps that want to deal with files modified on disk, it is nessecary to reset this property...

KDE Home | KDE Accessibility Home | Description of Access Keys