kateundo.h

Go to the documentation of this file.

/* This file is part of the KDE libraries
   Copyright (C) 2011 Dominik Haumann <dhaumann@kde.org>
   Copyright (C) 2009-2010 Bernhard Beschow <bbeschow@cs.tu-berlin.de>
   Copyright (C) 2002 John Firebaugh <jfirebaugh@kde.org>
   Copyright (C) 2001 Christoph Cullmann <cullmann@kde.org>
   Copyright (C) 2001 Joseph Wenninger <jowenn@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_undo_h
#define kate_undo_h

#include <QtCore/QList>

#include <ktexteditor/range.h>
#include <QtCore/QBitArray>

class KateUndoManager;
class KateDocument;

namespace KTextEditor {
  class View;
}

class KateUndo
{
  public:
    KateUndo (KateDocument *document);

    virtual ~KateUndo();

  public:
    enum UndoType
    {
      editInsertText,
      editRemoveText,
      editWrapLine,
      editUnWrapLine,
      editInsertLine,
      editRemoveLine,
      editMarkLineAutoWrapped,
      editInvalid
    };

  public:
    virtual bool isEmpty() const;

    virtual bool mergeWith(const KateUndo* undo);

    virtual void undo() = 0;

    virtual void redo() = 0;

    virtual KateUndo::UndoType type() const = 0;

  protected:
    inline KateDocument *document() { return m_document; }

  private:
    KateDocument *m_document;

  //
  // Line modification system
  //
  public:
    enum ModificationFlag {
      UndoLine1Modified = 1,
      UndoLine2Modified = 2,
      UndoLine1Saved = 4,
      UndoLine2Saved = 8,
      RedoLine1Modified = 16,
      RedoLine2Modified = 32,
      RedoLine1Saved = 64,
      RedoLine2Saved = 128
    };

    inline void setFlag(ModificationFlag flag) {
      m_lineModFlags |= flag;
    }

    inline void unsetFlag(ModificationFlag flag) {
      m_lineModFlags &= (~flag);
    }

    inline bool isFlagSet(ModificationFlag flag) const {
      return m_lineModFlags & flag;
    }

    virtual void updateUndoSavedOnDiskFlag(QBitArray & lines) { Q_UNUSED(lines) }
    virtual void updateRedoSavedOnDiskFlag(QBitArray & lines) { Q_UNUSED(lines) }

  private:
    uchar m_lineModFlags;
};

class KateEditInsertTextUndo : public KateUndo
{
  public:
    KateEditInsertTextUndo (KateDocument *document, int line, int col, const QString &text);

    bool isEmpty() const;

    void undo();

    void redo();

    bool mergeWith (const KateUndo *undo);

    KateUndo::UndoType type() const { return KateUndo::editInsertText; }

  protected:
    inline int len() const { return m_text.length(); }
    inline int line() const { return m_line; }

  private:
    const int m_line;
    const int m_col;
    QString m_text;
};

class KateEditRemoveTextUndo : public KateUndo
{
  public:
    KateEditRemoveTextUndo (KateDocument *document, int line, int col, const QString &text);

    bool isEmpty() const;

    void undo();

    void redo();

    bool mergeWith (const KateUndo *undo);

    KateUndo::UndoType type() const { return KateUndo::editRemoveText; }

  protected:
    inline int len() const { return m_text.length(); }
    inline int line() const { return m_line; }

  private:
    const int m_line;
    int m_col;
    QString m_text;
};

class KateEditMarkLineAutoWrappedUndo : public KateUndo
{
  public:
    KateEditMarkLineAutoWrappedUndo (KateDocument *document, int line, bool autowrapped)
      : KateUndo (document)
      , m_line (line)
      , m_autowrapped (autowrapped)
    {}

    void undo();

    void redo();

    KateUndo::UndoType type() const { return KateUndo::editMarkLineAutoWrapped; }

  private:
    const int m_line;
    const bool m_autowrapped;
};

class KateEditWrapLineUndo : public KateUndo
{
  public:
    KateEditWrapLineUndo (KateDocument *document, int line, int col, int len, bool newLine);

    void undo();

    void redo();

    KateUndo::UndoType type() const { return KateUndo::editWrapLine; }

  protected:
    inline int line() const { return m_line; }

  private:
    const int m_line;
    const int m_col;
    const int m_len;
    const bool m_newLine;
};

class KateEditUnWrapLineUndo : public KateUndo
{
  public:
    KateEditUnWrapLineUndo (KateDocument *document, int line, int col, int len, bool removeLine);

    void undo();

    void redo();

    KateUndo::UndoType type() const { return KateUndo::editUnWrapLine; }

  protected:
    inline int line() const { return m_line; }

  private:
    const int m_line;
    const int m_col;
    const int m_len;
    const bool m_removeLine;
};

class KateEditInsertLineUndo : public KateUndo
{
  public:
    KateEditInsertLineUndo (KateDocument *document, int line, const QString &text);

    void undo();

    void redo();

    KateUndo::UndoType type() const { return KateUndo::editInsertLine; }

  protected:
    inline int line() const { return m_line; }

  private:
    const int m_line;
    const QString m_text;
};

class KateEditRemoveLineUndo : public KateUndo
{
  public:
    KateEditRemoveLineUndo (KateDocument *document, int line, const QString &text);

    void undo();

    void redo();

    KateUndo::UndoType type() const { return KateUndo::editRemoveLine; }

  protected:
    inline int line() const { return m_line; }

  private:
    const int m_line;
    const QString m_text;
};

class KateUndoGroup
{
  public:
    explicit KateUndoGroup (KateUndoManager *manager, const KTextEditor::Cursor &cursorPosition, const KTextEditor::Range &selectionRange);

    ~KateUndoGroup();

  public:
    void undo(KTextEditor::View *view);

    void redo(KTextEditor::View *view);

    void editEnd(const KTextEditor::Cursor &cursorPosition, const KTextEditor::Range selectionRange);

    bool merge (KateUndoGroup* newGroup,bool complex);

    void safePoint (bool safePoint=true);

    bool isEmpty() const { return m_items.isEmpty(); }

    void flagSavedAsModified();

    void markUndoAsSaved(QBitArray & lines);
    void markRedoAsSaved(QBitArray & lines);

    inline void setUndoCursor(const KTextEditor::Cursor & cursor)
    { m_undoCursor = cursor; }

    inline void setRedoCursor(const KTextEditor::Cursor & cursor)
    { m_redoCursor = cursor; }

    inline const KTextEditor::Cursor & redoCursor() const
    { return m_redoCursor; }

  private:
    KTextEditor::Document *document();

    KateUndo::UndoType singleType() const;

    bool isOnlyType(KateUndo::UndoType type) const;

  public:
    void addItem (KateUndo *u);

  private:
    KateUndoManager *const m_manager;

    QList<KateUndo*> m_items;

    bool m_safePoint;

    const KTextEditor::Range m_undoSelection;

    KTextEditor::Range m_redoSelection;

    KTextEditor::Cursor m_undoCursor;

    KTextEditor::Cursor m_redoCursor;
};

#endif

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