katetextbuffer.h

/*  SPDX-License-Identifier: LGPL-2.0-or-later

    Copyright (C) 2010 Christoph Cullmann <[email protected]>

    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 <QObject>
#include <QSet>
#include <QString>
#include <QTextCodec>
#include <QVector>

#include <ktexteditor/document.h>

#include "katedocument.h"
#include "katetextblock.h"
#include "katetextcursor.h"
#include "katetexthistory.h"
#include "katetextrange.h"
#include <ktexteditor_export.h>

// encoding prober
#include <KEncodingProber>

class KCompressionDevice;

namespace Kate
{
class KTEXTEDITOR_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 };

    explicit TextBuffer(KTextEditor::DocumentPrivate *parent, int blockSize = 64, bool alwaysUseKAuth = false);

    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, int &longestLineLoaded, 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:
    enum class SaveResult { Failed = 0, MissingPermissions, Success };

    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();

    bool saveBuffer(const QString &filename, KCompressionDevice &saveFile);

    SaveResult saveBufferUnprivileged(const QString &filename);

    bool saveBufferEscalated(const QString &filename);

public:
    KTextEditor::DocumentPrivate *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();

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

    void setDigest(const QByteArray &checksum);

private:
    QByteArray m_digest;

private:
    KTextEditor::DocumentPrivate *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;

    bool m_alwaysUseKAuthForSave;

    static const qint64 bufferLength = 4096;
};

}

#endif