katedocument.h

Go to the documentation of this file.

/* 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>
   Copyright (C) 2006 Hamish Rodda <rodda@kde.org>

   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 <QtCore/QLinkedList>
#include <QtCore/QMap>
#include <QtCore/QDate>
#include <QtGui/QClipboard>
#include <QtCore/QStack>

#include <kmimetype.h>

#include <ktexteditor/document.h>
#include <ktexteditor/sessionconfiginterface.h>
#include <ktexteditor/searchinterface.h>
#include <ktexteditor/markinterface.h>
#include <ktexteditor/variableinterface.h>
#include <ktexteditor/modificationinterface.h>
#include <ktexteditor/configinterface.h>
#include <ktexteditor/annotationinterface.h>
#include <ktexteditor/highlightinterface.h>
#include <ktexteditor/movinginterface.h>
#include <ktexteditor/recoveryinterface.h>
#include <ktexteditor/messageinterface.h>

#include "katepartprivate_export.h"
#include "katetextline.h"
#include "katetextcursor.h"
#include "katetextrange.h"

namespace KTextEditor {
  class Plugin;
  class Attribute;
  class TemplateScript;
}

namespace KIO { class TransferJob; }

namespace Kate { class SwapFile; }

class KateBuffer;
class KateView;
class KateDocumentConfig;
class KateHighlighting;
class KateUndoManager;
class KateOnTheFlyChecker;

class KateAutoIndent;


//
// Kate KTextEditor::Document class (and even KTextEditor::Editor ;)
//
class KATEPART_TESTS_EXPORT KateDocument : public KTextEditor::Document,
                     public KTextEditor::SessionConfigInterface,
                     public KTextEditor::ParameterizedSessionConfigInterface,
                     public KTextEditor::SearchInterface,
                     public KTextEditor::MarkInterface,
                     public KTextEditor::VariableInterface,
                     public KTextEditor::ModificationInterface,
                     public KTextEditor::ConfigInterface,
                     public KTextEditor::AnnotationInterface,
                     public KTextEditor::HighlightInterface,
                     public KTextEditor::MovingInterface,
                     public KTextEditor::RecoveryInterface,
                     public KTextEditor::MessageInterface,
                     private KTextEditor::MovingRangeFeedback
{
  Q_OBJECT
  Q_INTERFACES(KTextEditor::SessionConfigInterface)
  Q_INTERFACES(KTextEditor::ParameterizedSessionConfigInterface)
  Q_INTERFACES(KTextEditor::SearchInterface)
  Q_INTERFACES(KTextEditor::MarkInterface)
  Q_INTERFACES(KTextEditor::VariableInterface)
  Q_INTERFACES(KTextEditor::ModificationInterface)
  Q_INTERFACES(KTextEditor::AnnotationInterface)
  Q_INTERFACES(KTextEditor::ConfigInterface)
  Q_INTERFACES(KTextEditor::HighlightInterface)
  Q_INTERFACES(KTextEditor::MovingInterface)
  Q_INTERFACES(KTextEditor::RecoveryInterface)
  Q_INTERFACES(KTextEditor::MessageInterface)

  friend class KateDocumentTest;
  friend class KateBuffer;

  public:
    explicit KateDocument (bool bSingleViewMode=false, bool bBrowserView=false, bool bReadOnly=false,
                  QWidget *parentWidget = 0, QObject * = 0);
    ~KateDocument ();
    
    using ReadWritePart::closeUrl;
    virtual bool closeUrl();
    
    virtual bool openUrl( const KUrl &url );

    virtual KTextEditor::Editor *editor ();

    KTextEditor::Range rangeOnLine(KTextEditor::Range range, int line) const;

  private:
    void showAndSetOpeningErrorAccess();
  /*
   * Overload this to have on-demand view creation
   */
  public:
    virtual QWidget *widget();

Q_SIGNALS:
// TODO for KDE5: move to KTE::Document
  void readWriteChanged (KTextEditor::Document *document);

    
    
  public:
    bool readOnly () const { return m_bReadOnly; }
    bool browserView () const { return m_bBrowserView; }
    bool singleViewMode () const { return m_bSingleViewMode; }
    static bool simpleMode ();

  private:
    // only to make part work, don't change it !
    const bool m_bSingleViewMode;
    const bool m_bBrowserView;
    const bool m_bReadOnly;

  //
  // KTextEditor::Document stuff
  //
  public:
    virtual KTextEditor::View *createView( QWidget *parent );
    virtual const QList<KTextEditor::View*> &views () const;

    virtual KTextEditor::View* activeView() const { return m_activeView; }
    // Invalid covariant returns my a$$... for some reason gcc won't let me return a KateView above!
    KateView* activeKateView() const;

  private:
    QLinkedList<KateView*> m_views;
    QList<KTextEditor::View*> m_textEditViews;
    KTextEditor::View *m_activeView;

  //
  // KTextEditor::EditInterface stuff
  //
  public Q_SLOTS:
    virtual bool setText(const QString &);
    virtual bool setText(const QStringList& text);
    virtual bool clear ();

    virtual bool insertText ( const KTextEditor::Cursor &position, const QString &s, bool block = false );
    virtual bool insertText ( const KTextEditor::Cursor &position, const QStringList &text, bool block = false );

    virtual bool insertLine ( int line, const QString &s );
    virtual bool insertLines ( int line, const QStringList &s );

    virtual bool removeText ( const KTextEditor::Range &range, bool block = false );
    virtual bool removeLine ( int line );

    virtual bool replaceText ( const KTextEditor::Range &range, const QString &s, bool block = false );

    // unhide method...
    virtual bool replaceText (const KTextEditor::Range &r, const QStringList &l, bool b)
    { return KTextEditor::Document::replaceText (r, l, b); }

  public:
    virtual QString text ( const KTextEditor::Range &range, bool blockwise = false ) const;
    virtual QStringList textLines ( const KTextEditor::Range& range, bool block = false ) const;
    virtual QString text() const;
    virtual QString line(int line) const;
    virtual QChar character(const KTextEditor::Cursor& position) const;
    virtual int lines() const;
    virtual KTextEditor::Cursor documentEnd() const;
    virtual int totalCharacters() const;
    virtual int lineLength(int line) const;

  Q_SIGNALS:
    void charactersSemiInteractivelyInserted(const KTextEditor::Cursor& position, const QString& text);

  public:
//BEGIN editStart/editEnd (start, end, undo, cursor update, view update)
    void editStart ();

    void editBegin () { editStart(); }

    void editEnd ();

    void pushEditState();
    void popEditState();

    virtual bool startEditing () { editStart (); return true; }
    virtual bool endEditing () { editEnd (); return true; }

//END editStart/editEnd

    void inputMethodStart();
    void inputMethodEnd();

//BEGIN LINE BASED INSERT/REMOVE STUFF (editStart() and editEnd() included)
    bool editInsertText ( int line, int col, const QString &s );
    bool editRemoveText ( int line, int col, int len );

    bool editMarkLineAutoWrapped ( int line, bool autowrapped );

    bool editWrapLine ( int line, int col, bool newLine = true, bool *newLineAdded = 0 );
    bool editUnWrapLine ( int line, bool removeLine = true, int length = 0 );

    bool editInsertLine ( int line, const QString &s );
    bool editRemoveLine ( int line );

    bool editRemoveLines ( int from, int to );

    bool wrapText (int startLine, int endLine);
//END LINE BASED INSERT/REMOVE STUFF

  Q_SIGNALS:
    void editLineWrapped ( int line, int col, int len );

    void editLineUnWrapped ( int line, int col );

  public:
    bool isEditRunning() const;

    void setUndoMergeAllEdits(bool merge);

  private:
    int editSessionNumber;
    QStack<int> editStateStack;
    bool editIsRunning;
    bool m_undoMergeAllEdits;

  //
  // KTextEditor::UndoInterface stuff
  //
  public Q_SLOTS:
    void undo ();
    void redo ();

  public:
    uint undoCount () const;
    uint redoCount () const;

    KateUndoManager* undoManager()
    {
        return m_undoManager;
    }

  protected:
    KateUndoManager* const m_undoManager;

  Q_SIGNALS:
    void undoChanged ();

  //
  // KTextEditor::SearchInterface stuff
  //
  public:
    virtual QVector<KTextEditor::Range> searchText(
        const KTextEditor::Range & range,
        const QString & pattern,
        const KTextEditor::Search::SearchOptions options);

    virtual KTextEditor::Search::SearchOptions supportedSearchOptions() const;

  private:
    QWidget * dialogParent();

  /*
   * Access to the mode/highlighting subsystem
   */
  public:
    virtual QString mode() const;

    virtual QString highlightingMode() const;

    virtual QStringList modes() const;

    virtual QStringList highlightingModes() const;

    virtual bool setMode(const QString &name);

    virtual bool setHighlightingMode(const QString &name);
    virtual QString highlightingModeSection( int index ) const;

    virtual QString modeSection( int index ) const;

  /*
   * Helpers....
   */
  public:
    void bufferHlChanged();

    void setDontChangeHlOnSave();

    void bomSetByUser();

  //
  // KTextEditor::SessionConfigInterface and KTextEditor::ParameterizedSessionConfigInterface stuff
  //
  public:
    virtual void readSessionConfig (const KConfigGroup&);
    virtual void writeSessionConfig (KConfigGroup&);
    virtual void readParameterizedSessionConfig (const KConfigGroup&, unsigned long configParameters);
    virtual void writeParameterizedSessionConfig (KConfigGroup&, unsigned long configParameters);

  Q_SIGNALS:
    void configChanged();

  //
  // KTextEditor::MarkInterface
  //
  public Q_SLOTS:
    virtual void setMark( int line, uint markType );
    virtual void clearMark( int line );

    virtual void addMark( int line, uint markType );
    virtual void removeMark( int line, uint markType );

    virtual void clearMarks();

    void requestMarkTooltip( int line, QPoint position );

    bool handleMarkClick( int line );

    bool handleMarkContextMenu( int line, QPoint position );

    virtual void setMarkPixmap( MarkInterface::MarkTypes, const QPixmap& );

    virtual void setMarkDescription( MarkInterface::MarkTypes, const QString& );

    virtual void setEditableMarks( uint markMask );

  public:
    virtual uint mark( int line );
    virtual const QHash<int, KTextEditor::Mark*> &marks ();
    virtual QPixmap markPixmap( MarkInterface::MarkTypes ) const;
    virtual QString markDescription( MarkInterface::MarkTypes ) const;
    virtual QColor markColor( MarkInterface::MarkTypes ) const;
    virtual uint editableMarks() const;

  Q_SIGNALS:
    void markToolTipRequested( KTextEditor::Document* document, KTextEditor::Mark mark, QPoint position, bool& handled );

    void markContextMenuRequested( KTextEditor::Document* document, KTextEditor::Mark mark, QPoint pos, bool& handled );

    void markClicked( KTextEditor::Document* document, KTextEditor::Mark mark, bool& handled );

    void marksChanged( KTextEditor::Document* );
    void markChanged( KTextEditor::Document*, KTextEditor::Mark, KTextEditor::MarkInterface::MarkChangeAction );

  private:
    QHash<int, KTextEditor::Mark*> m_marks;
    QHash<int,QPixmap>           m_markPixmaps;
    QHash<int,QString>           m_markDescriptions;
    uint                        m_editableMarks;

  //
  // KTextEditor::PrintInterface
  //
  public Q_SLOTS:
    bool printDialog ();
    Q_SCRIPTABLE bool print ();

  //
  // KTextEditor::DocumentInfoInterface ( ### unfinished )
  //
  public:
    virtual QString mimeType();

    KMimeType::Ptr mimeTypeForContent();

  //
  // KTextEditor::VariableInterface
  //
  public:
    virtual QString variable( const QString &name ) const;
    // ### TODO KDE5: add to KTextEditor::VaribaleInterface
    virtual QString setVariable( const QString &name, const QString &value);

  Q_SIGNALS:
    void variableChanged( KTextEditor::Document*, const QString &, const QString & );

  private:
    QMap<QString, QString> m_storedVariables;

  //
  // MovingInterface API
  //
  public:
    virtual KTextEditor::MovingCursor *newMovingCursor (const KTextEditor::Cursor &position, KTextEditor::MovingCursor::InsertBehavior insertBehavior = KTextEditor::MovingCursor::MoveOnInsert);

    virtual KTextEditor::MovingRange *newMovingRange (const KTextEditor::Range &range, KTextEditor::MovingRange::InsertBehaviors insertBehaviors = KTextEditor::MovingRange::DoNotExpand
      , KTextEditor::MovingRange::EmptyBehavior emptyBehavior = KTextEditor::MovingRange::AllowEmpty);

    virtual qint64 revision () const;

    virtual qint64 lastSavedRevision () const;

    virtual void lockRevision (qint64 revision);

    virtual void unlockRevision (qint64 revision);

    virtual void transformCursor (KTextEditor::Cursor &cursor, KTextEditor::MovingCursor::InsertBehavior insertBehavior, qint64 fromRevision, qint64 toRevision = -1);

    virtual void transformCursor (int& line, int& column, KTextEditor::MovingCursor::InsertBehavior insertBehavior, qint64 fromRevision, qint64 toRevision = -1);

    virtual void transformRange (KTextEditor::Range &range, KTextEditor::MovingRange::InsertBehaviors insertBehaviors, KTextEditor::MovingRange::EmptyBehavior emptyBehavior, qint64 fromRevision, qint64 toRevision = -1);

  //
  // MovingInterface Signals
  //
  Q_SIGNALS:
    void aboutToDeleteMovingInterfaceContent (KTextEditor::Document *document);

    void aboutToInvalidateMovingInterfaceContent (KTextEditor::Document *document);

  //
  // Annotation Interface
  //
  public:

    virtual void setAnnotationModel( KTextEditor::AnnotationModel* model );
    virtual KTextEditor::AnnotationModel* annotationModel() const;

  Q_SIGNALS:
    void annotationModelChanged( KTextEditor::AnnotationModel*, KTextEditor::AnnotationModel* );

  private:
    KTextEditor::AnnotationModel* m_annotationModel;

  //
  // KParts::ReadWrite stuff
  //
  public:
    virtual bool openFile ();

    virtual bool saveFile ();

    virtual void setReadWrite ( bool rw = true );

    virtual void setModified( bool m );

  private:
    void activateDirWatch (const QString &useFileName = QString());
    void deactivateDirWatch ();

    QString m_dirWatchFile;

  public:
    bool typeChars ( KateView *type, const QString &realChars );

    inline int lastLine() const { return lines()-1; }

    // Repaint all of all of the views
    void repaintViews(bool paintOnlyDirty = true);

    KateHighlighting *highlight () const;

  public Q_SLOTS:
    void tagLines(int start, int end);

  private Q_SLOTS:
    void internalHlChanged();

  public:
    void addView(KTextEditor::View *);
    void removeView(KTextEditor::View *);
    void setActiveView(KTextEditor::View*);

    bool ownedView(KateView *);

    int toVirtualColumn( int line, int column ) const;
    int toVirtualColumn( const KTextEditor::Cursor& ) const;
    int fromVirtualColumn( int line, int column ) const;
    int fromVirtualColumn( const KTextEditor::Cursor& ) const;

    void newLine( KateView*view ); // Changes input
    void backspace(     KateView *view, const KTextEditor::Cursor& );
    void del(           KateView *view, const KTextEditor::Cursor& );
    void transpose(     const KTextEditor::Cursor& );
    void paste ( KateView* view, const QString &text );

  public:
    void indent ( KTextEditor::Range range, int change );
    void comment ( KateView *view, uint line, uint column, int change );
    void align ( KateView *view, const KTextEditor::Range &range );
    void insertTab( KateView *view, const KTextEditor::Cursor& );

    enum TextTransform { Uppercase, Lowercase, Capitalize };

    void transform ( KateView *view, const KTextEditor::Cursor &, TextTransform );
    void joinLines( uint first, uint last );

  private:
    bool removeStringFromBeginning(int line, const QString &str);
    bool removeStringFromEnd(int line, const 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 KTextEditor::Cursor &start, const KTextEditor::Cursor &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:
    // KDE5: rename to wordAt(), add wordRangeAt(), see ktexteditor/document.h
    QString getWord( const KTextEditor::Cursor& cursor );

  public:
    void newBracketMark( const KTextEditor::Cursor& start, KTextEditor::Range& bm, int maxLines = -1 );
    bool findMatchingBracket( KTextEditor::Range& range, int maxLines = -1 );

  public:
    virtual const QString &documentName () const { return m_docName; }

  private:
    void updateDocName ();

  public:
    bool isModifiedOnDisc() { return m_modOnHd; }

    virtual void setModifiedOnDisk( ModifiedOnDiskReason reason );

    virtual void setModifiedOnDiskWarning ( bool on );

  public Q_SLOTS:
    virtual void slotModifiedOnDisk( KTextEditor::View *v = 0 );

    virtual bool documentReload ();

    virtual bool documentSave ();
    virtual bool documentSaveAs ();

    virtual bool save();
  public:
    virtual bool saveAs( const KUrl &url );

  Q_SIGNALS:
    void modifiedOnDisk (KTextEditor::Document *doc, bool isModified, KTextEditor::ModificationInterface::ModifiedOnDiskReason reason);

  public:
    void ignoreModifiedOnDiskOnce();

  private:
    int m_isasking; // don't reenter slotModifiedOnDisk when this is true
                    // -1: ignore once, 0: false, 1: true

  public:
    virtual bool setEncoding (const QString &e);
    virtual const QString &encoding() const;


  public Q_SLOTS:
    void setWordWrap (bool on);
    void setWordWrapAt (uint col);

  public:
    bool wordWrap() const;
    uint wordWrapAt() const;

  public Q_SLOTS:
    void setPageUpDownMovesCursor(bool on);

  public:
    bool pageUpDownMovesCursor() const;

   // code folding
  public:
    Kate::TextLine kateTextLine(uint i);
    Kate::TextLine plainKateTextLine(uint i);

  Q_SIGNALS:
    void aboutToRemoveText(const KTextEditor::Range&);

  private Q_SLOTS:
    void slotModOnHdDirty (const QString &path);
    void slotModOnHdCreated (const QString &path);
    void slotModOnHdDeleted (const QString &path);

  private:
    bool createDigest ();
    
    QString reasonedMOHString() const;

    void removeTrailingSpaces();

  public:
    const QByteArray &digest () const;

    void updateFileType (const QString &newType, bool user = false);

    QString fileType () const { return m_fileType; }

    KateBuffer &buffer () { return *m_buffer; }
    
    void rememberUserDidSetIndentationMode ()
    {
      m_indenterSetByUser = true;
    }
    
    void userSetEncodingForNextReload ()
    {
      m_userSetEncodingForNextReload = true;
    }

  //
  // REALLY internal data ;)
  //
  private:
    // text buffer
    KateBuffer *const m_buffer;

    // indenter
    KateAutoIndent *const m_indenter;

    bool m_hlSetByUser;
    bool m_bomSetByUser;
    bool m_indenterSetByUser;
    bool m_userSetEncodingForNextReload;

    bool m_modOnHd;
    ModifiedOnDiskReason m_modOnHdReason;

    QString m_docName;
    int m_docNameNumber;

    // file type !!!
    QString m_fileType;
    bool m_fileTypeSetByUser;

    bool m_reloading;

  public Q_SLOTS:
    void slotQueryClose_save(bool *handled, bool* abortClosing);

  public:
    virtual bool queryClose();

    void makeAttribs (bool needInvalidate = true);

    static bool checkOverwrite( KUrl u, QWidget *parent );

  public:
    KateDocumentConfig *config() { return m_config; }
    KateDocumentConfig *config() const { return m_config; }

    void updateConfig ();

  private:
    KateDocumentConfig *const 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;

    bool m_fileChangedDialogsActivated;

  //
  // KTextEditor::ConfigInterface
  //
  public:
     virtual QStringList configKeys() const;
     virtual QVariant configValue(const QString &key);
     virtual void setConfigValue(const QString &key, const QVariant &value);

  //
  // KTextEditor::RecoveryInterface
  //
  public:
    virtual bool isDataRecoveryAvailable() const;
    virtual void recoverData();
    virtual void discardDataRecovery();

  //
  // KTextEditor::HighlightInterface
  //
  public:
    virtual KTextEditor::Attribute::Ptr defaultStyle(const KTextEditor::HighlightInterface::DefaultStyle ds) const;
    virtual QList< KTextEditor::HighlightInterface::AttributeBlock > lineAttributes(const unsigned int line);
    virtual QStringList embeddedHighlightingModes() const;
    virtual QString highlightingModeAt(const KTextEditor::Cursor& position);

  //
  //BEGIN: KTextEditor::MessageInterface
  //
  public:
    virtual bool postMessage(KTextEditor::Message* message);

  public Q_SLOTS:
    void messageDestroyed(KTextEditor::Message* message);

  private:
    QHash<KTextEditor::Message *, QList<QSharedPointer<QAction> > > m_messageHash;
  //END KTextEditor::MessageInterface

  public:
      QString defaultDictionary() const;
      QList<QPair<KTextEditor::MovingRange*, QString> > dictionaryRanges() const;
      bool isOnTheFlySpellCheckingEnabled() const;

      QString dictionaryForMisspelledRange(const KTextEditor::Range& range) const;
      void clearMisspellingForWord(const QString& word);

  public Q_SLOTS:
      void clearDictionaryRanges();
      void setDictionary(const QString& dict, const KTextEditor::Range &range);
      void revertToDefaultDictionary(const KTextEditor::Range &range);
      void setDefaultDictionary(const QString& dict);
      void onTheFlySpellCheckingEnabled(bool enable);
      void refreshOnTheFlyCheck(const KTextEditor::Range &range = KTextEditor::Range::invalid());

  Q_SIGNALS:
      void dictionaryRangesPresent(bool yesNo);
      void defaultDictionaryChanged(KateDocument *document);

  public:
      bool containsCharacterEncoding(const KTextEditor::Range& range);

      typedef QList<QPair<int, int> > OffsetList;

      int computePositionWrtOffsets(const OffsetList& offsetList, int pos);

      QString decodeCharacters(const KTextEditor::Range& range,
                               KateDocument::OffsetList& decToEncOffsetList,
                               KateDocument::OffsetList& encToDecOffsetList);
      void replaceCharactersByEncoding(const KTextEditor::Range& range);

      enum EncodedCharaterInsertionPolicy {EncodeAlways, EncodeWhenPresent, EncodeNever};

  protected:
      KateOnTheFlyChecker *m_onTheFlyChecker;
      QString m_defaultDictionary;
      QList<QPair<KTextEditor::MovingRange*, QString> > m_dictionaryRanges;

      // from KTextEditor::MovingRangeFeedback
      void rangeInvalid(KTextEditor::MovingRange *movingRange);
      void rangeEmpty(KTextEditor::MovingRange *movingRange);

      void deleteDictionaryRange(KTextEditor::MovingRange *movingRange);

  private:
    Kate::SwapFile *m_swapfile;
    
  public:
    Kate::SwapFile* swapFile();

  //helpers for scripting and codefolding
    int defStyleNum(int line, int column);
    bool isComment(int line, int column);

  private Q_SLOTS:
    void slotStarted(KIO::Job *job);
    void slotCompleted();
    void slotCanceled();
    
    void slotTriggerLoadingMessage ();
    
    void slotAbortLoading ();
    
  private:
    enum DocumentStates {
      DocumentIdle,
      
      DocumentLoading,
      
      DocumentSaving,
      
      DocumentPreSavingAs,
      
      DocumentSavingAs
    };
    
    DocumentStates m_documentState;
    
    bool m_readWriteStateBeforeLoading;
    
    bool m_isUntitled;
    QPointer<KJob> m_loadingJob;
    
    QPointer<KTextEditor::Message> m_loadingMessage;
};

#endif

// kate: space-indent on; indent-width 2; replace-tabs on;