katetextline.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_TEXTLINE_H
#define KATE_TEXTLINE_H

#include <QSharedPointer>
#include <QString>
#include <QVector>

#include <ktexteditor_export.h>

#include <KSyntaxHighlighting/State>

namespace Kate
{
class KTEXTEDITOR_EXPORT TextLineData
{
    friend class TextBlock;

public:
    class Attribute
    {
    public:
        explicit Attribute(int _offset = 0, int _length = 0, short _attributeValue = 0)
            : offset(_offset)
            , length(_length)
            , attributeValue(_attributeValue)
        {
        }

        int offset;

        int length;

        short attributeValue;
    };

    class Folding
    {
    public:
        Folding(int _offset, int _foldingValue)
            : offset(_offset)
            , foldingValue(_foldingValue)
        {
        }

        int offset = 0;

        int foldingValue = 0;
    };

    enum Flags { flagAutoWrapped = 1, flagFoldingStartAttribute = 2, flagFoldingStartIndentation = 4, flagLineModified = 8, flagLineSavedOnDisk = 16 };

    TextLineData();

    explicit TextLineData(const QString &text);

    ~TextLineData();

    const QString &text() const
    {
        return m_text;
    }

    int firstChar() const;

    int lastChar() const;

    int nextNonSpaceChar(int pos) const;

    int previousNonSpaceChar(int pos) const;

    inline QChar at(int column) const
    {
        if (column >= 0 && column < m_text.length()) {
            return m_text[column];
        }

        return QChar();
    }

    inline QChar operator[](int column) const
    {
        if (column >= 0 && column < m_text.length()) {
            return m_text[column];
        }

        return QChar();
    }

    inline void markAsModified(bool modified)
    {
        if (modified) {
            m_flags |= flagLineModified;
            m_flags &= (~flagLineSavedOnDisk);
        } else {
            m_flags &= (~flagLineModified);
        }
    }

    inline bool markedAsModified() const
    {
        return m_flags & flagLineModified;
    }

    inline void markAsSavedOnDisk(bool savedOnDisk)
    {
        if (savedOnDisk) {
            m_flags |= flagLineSavedOnDisk;
            m_flags &= (~flagLineModified);
        } else {
            m_flags &= (~flagLineSavedOnDisk);
        }
    }

    inline bool markedAsSavedOnDisk() const
    {
        return m_flags & flagLineSavedOnDisk;
    }

    bool markedAsFoldingStart() const
    {
        return m_flags & (flagFoldingStartAttribute | flagFoldingStartIndentation);
    }

    void clearMarkedAsFoldingStart()
    {
        m_flags &= ~(flagFoldingStartAttribute | flagFoldingStartIndentation);
    }

    bool markedAsFoldingStartAttribute() const
    {
        return m_flags & flagFoldingStartAttribute;
    }

    bool markedAsFoldingStartIndentation() const
    {
        return m_flags & flagFoldingStartIndentation;
    }

    void markAsFoldingStartAttribute()
    {
        clearMarkedAsFoldingStart();
        m_flags |= flagFoldingStartAttribute;
    }

    void markAsFoldingStartIndentation()
    {
        clearMarkedAsFoldingStart();
        m_flags |= flagFoldingStartIndentation;
    }

    int length() const
    {
        return m_text.length();
    }

    bool isAutoWrapped() const
    {
        return m_flags & flagAutoWrapped;
    }

    const QString &string() const
    {
        return m_text;
    }

    QString string(int column, int length) const
    {
        return m_text.mid(column, length);
    }

    QString leadingWhitespace() const;

    int indentDepth(int tabWidth) const;

    int toVirtualColumn(int column, int tabWidth) const;

    int fromVirtualColumn(int column, int tabWidth) const;

    int virtualLength(int tabWidth) const;

    bool matchesAt(int column, const QString &match) const;

    bool startsWith(const QString &match) const
    {
        return m_text.startsWith(match);
    }

    bool endsWith(const QString &match) const
    {
        return m_text.endsWith(match);
    }

    const KSyntaxHighlighting::State &highlightingState() const
    {
        return m_highlightingState;
    }

    void setHighlightingState(const KSyntaxHighlighting::State &val)
    {
        m_highlightingState = val;
    }

    void addAttribute(const Attribute &attribute);

    void clearAttributesAndFoldings()
    {
        m_attributesList.clear();
        m_foldings.clear();
    }

    const QVector<Attribute> &attributesList() const
    {
        return m_attributesList;
    }

    const std::vector<Folding> &foldings() const
    {
        return m_foldings;
    }

    void addFolding(int offset, int folding)
    {
        m_foldings.emplace_back(offset, folding);
    }

    short attribute(int pos) const;

    void setAutoWrapped(bool wrapped)
    {
        if (wrapped) {
            m_flags = m_flags | flagAutoWrapped;
        } else {
            m_flags = m_flags & ~flagAutoWrapped;
        }
    }

private:
    QString &textReadWrite()
    {
        return m_text;
    }

private:
    QString m_text;

    QVector<Attribute> m_attributesList;

    std::vector<Folding> m_foldings;

    KSyntaxHighlighting::State m_highlightingState;

    unsigned int m_flags = 0;
};

typedef QSharedPointer<TextLineData> TextLine;

}

#endif