katebuffer.h

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

    Copyright (c) 2000 Waldo Bastian <[email protected]>
    Copyright (C) 2002-2004 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_BUFFER_H
#define KATE_BUFFER_H

#include "katetextbuffer.h"

#include <ktexteditor_export.h>

#include <QObject>

class KateLineInfo;
namespace KTextEditor
{
class DocumentPrivate;
}
class KateHighlighting;

class KTEXTEDITOR_EXPORT KateBuffer : public Kate::TextBuffer
{
    Q_OBJECT

public:
    explicit KateBuffer(KTextEditor::DocumentPrivate *doc);

    ~KateBuffer() override;

public:
    void editStart();

    void editEnd();

    inline bool editChanged() const
    {
        return editingChangedBuffer();
    }

    inline int editTagStart() const
    {
        return editingMinimalLineChanged();
    }

    inline int editTagEnd() const
    {
        return editingMaximalLineChanged();
    }

    inline bool editTagFrom() const
    {
        return editingChangedNumberOfLines() != 0;
    }

public:
    void clear() override;

    bool openFile(const QString &m_file, bool enforceTextCodec);

    bool brokenEncoding() const
    {
        return m_brokenEncoding;
    }

    bool tooLongLinesWrapped() const
    {
        return m_tooLongLinesWrapped;
    }

    int longestLineLoaded() const
    {
        return m_longestLineLoaded;
    }

    bool canEncode();

    bool saveFile(const QString &m_file);

public:
    inline Kate::TextLine plainLine(int lineno)
    {
        if (lineno < 0 || lineno >= lines()) {
            return Kate::TextLine();
        }

        return line(lineno);
    }

    void ensureHighlighted(int line, int lookAhead = 64);

    inline int count() const
    {
        return lines();
    }

    void unwrapLine(int line) override;

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

public:
    inline int tabWidth() const
    {
        return m_tabWidth;
    }

public:
    void setTabWidth(int w);

    void setHighlight(int hlMode);

    KateHighlighting *highlight()
    {
        return m_highlight;
    }

    void invalidateHighlighting();

    KTextEditor::Range computeFoldingRangeForStartLine(int startLine);

private:
    void doHighlight(int from, int to, bool invalidate);

Q_SIGNALS:
    void tagLines(int start, int end);
    void respellCheckBlock(int start, int end);

private:
    KTextEditor::DocumentPrivate *const m_doc;

    bool m_brokenEncoding;

    bool m_tooLongLinesWrapped;

    int m_longestLineLoaded;

    KateHighlighting *m_highlight;

    // for the scrapty indent sensitive langs
    int m_tabWidth;

    int m_lineHighlighted;

    int m_maxDynamicContexts;
};

#endif