katetextbuffer.h

Go to the documentation of this file.

/*  This file is part of the Kate project.
 *
 *  Copyright (C) 2010 Christoph Cullmann <cullmann@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 as published by the Free Software Foundation; either
 *  version 2 of the License, or (at your option) any later version.
 *
 *  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_TEXTBUFFER_H
#define KATE_TEXTBUFFER_H

#include <QtCore/QObject>
#include <QtCore/QString>
#include <QtCore/QVector>
#include <QtCore/QSet>
#include <QtCore/QTextCodec>

#include <ktexteditor/document.h>

#include "katedocument.h"
#include "katepartprivate_export.h"
#include "katetextblock.h"
#include "katetextcursor.h"
#include "katetextrange.h"
#include "katetexthistory.h"

// encoding prober
#include <kencodingprober.h>

namespace Kate {

class KATEPART_TESTS_EXPORT TextBuffer : public QObject {
  friend class TextCursor;
  friend class TextRange;
  friend class TextBlock;

  Q_OBJECT

  public:
    enum EndOfLineMode {
        eolUnknown = -1
      , eolUnix = 0
      , eolDos = 1
      , eolMac = 2
    };

    TextBuffer (KateDocument *parent, int blockSize = 64);

    virtual ~TextBuffer ();

    virtual void clear ();

    void setEncodingProberType (KEncodingProber::ProberType proberType) { m_encodingProberType = proberType; }

    KEncodingProber::ProberType encodingProberType () const { return m_encodingProberType; }

    void setFallbackTextCodec (QTextCodec *codec) { m_fallbackTextCodec = codec; }

    QTextCodec *fallbackTextCodec () const { return m_fallbackTextCodec; }

    void setTextCodec (QTextCodec *codec);

    QTextCodec *textCodec () const { return m_textCodec; }

    void setGenerateByteOrderMark (bool generateByteOrderMark) { m_generateByteOrderMark = generateByteOrderMark; }

    bool generateByteOrderMark () const { return m_generateByteOrderMark; }

    void setEndOfLineMode (EndOfLineMode endOfLineMode) { Q_ASSERT (endOfLineMode != eolUnknown); m_endOfLineMode = endOfLineMode; }

    EndOfLineMode endOfLineMode () const { return m_endOfLineMode; }

    void setNewLineAtEof(bool newlineAtEof) { m_newLineAtEof = newlineAtEof; }

    void setLineLengthLimit (int lineLengthLimit) { m_lineLengthLimit = lineLengthLimit; }

    virtual bool load (const QString &filename, bool &encodingErrors, bool &tooLongLinesWrapped, bool enforceTextCodec);

    virtual bool save (const QString &filename);

    int lines () const { Q_ASSERT (m_lines > 0); return m_lines; }

    qint64 revision () const { return m_revision; }

    TextLine line (int line) const;

    QString text () const;

    virtual bool startEditing ();

    virtual bool finishEditing ();

    int editingTransactions () const { return m_editingTransactions; }

    qint64 editingLastRevision () const { return m_editingLastRevision; }

    int editingLastLines () const { return m_editingLastLines; }

    bool editingChangedBuffer () const { return editingLastRevision() != revision(); }

    bool editingChangedNumberOfLines () const { return editingLastLines() != lines(); }

    int editingMinimalLineChanged () const { return m_editingMinimalLineChanged; }

    int editingMaximalLineChanged () const { return m_editingMaximalLineChanged; }

    virtual void wrapLine (const KTextEditor::Cursor &position);

    virtual void unwrapLine (int line);

    virtual void insertText (const KTextEditor::Cursor &position, const QString &text);

    virtual void removeText (const KTextEditor::Range &range);

    TextHistory &history () { return m_history; }

  Q_SIGNALS:
    void cleared ();

    void loaded (const QString &filename, bool encodingErrors);

    void saved (const QString &filename);

    void editingStarted ();

    void editingFinished ();

    void lineWrapped (const KTextEditor::Cursor &position);

    void lineUnwrapped (int line);

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

    void textRemoved (const KTextEditor::Range &range, const QString &text);

  private:
    int blockForLine (int line) const;

    void fixStartLines (int startBlock);

    void balanceBlock (int index);

    TextBlock *blockForIndex (int index) { return m_blocks[index]; }

    void notifyAboutRangeChange (KTextEditor::View *view, int startLine, int endLine, bool rangeWithAttribute);

    void markModifiedLinesAsSaved();

  public:
    KateDocument *document () const { return m_document; }

    void debugPrint (const QString &title) const;

    QList<TextRange *> rangesForLine (int line, KTextEditor::View *view, bool rangesWithAttributeOnly) const;

    bool rangePointerValid (TextRange *range) const { return m_ranges.contains (range); }

    void invalidateRanges();

  //
  // md5 checksum handling
  //
  public:
    const QByteArray &digest () const;

    void setDigest (const QByteArray & md5sum);

  private:
    QByteArray m_digest;

  private:
    KateDocument *m_document;

    TextHistory m_history;

    const int m_blockSize;

    QVector<TextBlock *> m_blocks;

    int m_lines;

    mutable int m_lastUsedBlock;

    qint64 m_revision;

    int m_editingTransactions;

    qint64 m_editingLastRevision;

    int m_editingLastLines;

    int m_editingMinimalLineChanged;

    int m_editingMaximalLineChanged;

    QSet<TextCursor *> m_invalidCursors;

    QSet<TextRange *> m_ranges;

    KEncodingProber::ProberType m_encodingProberType;

    QTextCodec *m_fallbackTextCodec;

    QTextCodec *m_textCodec;

    QString m_mimeTypeForFilterDev;

    bool m_generateByteOrderMark;

    EndOfLineMode m_endOfLineMode;

    bool m_newLineAtEof;

    int m_lineLengthLimit;
};

}

#endif