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

#include <QtCore/QVector>
#include <QtCore/QString>
#include <QtCore/QSharedPointer>

#include "katepartprivate_export.h"

namespace Kate {

class KATEPART_TESTS_EXPORT TextLineData {
  friend class TextBuffer;
  friend class TextBlock;

  public:
    enum Flags
    {
      flagHlContinue = 1,
      flagAutoWrapped = 2,
      flagFoldingColumnsOutdated = 4,
      flagNoIndentationBasedFolding = 8,
      flagNoIndentationBasedFoldingAtStart = 16
    };

    TextLineData ();

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

    void setFoldingColumnsOutdated(bool set)
    {
      if (set) m_flags |= flagFoldingColumnsOutdated;
      else m_flags &= (~flagFoldingColumnsOutdated);
    }

    bool foldingColumnsOutdated() const { return m_flags & flagFoldingColumnsOutdated; }

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

    bool hlLineContinue () const { return m_flags & flagHlContinue; }

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

    int attribute (int pos) const
    {
      for (int i=0; i < m_attributesList.size(); i+=3)
      {
        if (pos >= m_attributesList[i] && pos < m_attributesList[i]+m_attributesList[i+1])
          return m_attributesList[i+2];

        if (pos < m_attributesList[i])
          break;
      }

      return 0;
    }

    const QVector<short> &ctxArray () const { return m_ctx; }

    bool noIndentBasedFolding() const { return m_flags & flagNoIndentationBasedFolding; }

    bool noIndentBasedFoldingAtStart() const { return m_flags & flagNoIndentationBasedFoldingAtStart; }

    const QVector<int> &foldingListArray () const { return m_foldingList; }

    const QVector<unsigned short> &indentationDepthArray () const { return m_indentationDepth; }

    void addAttribute (int start, int length, int attribute);

    void clearAttributes () { m_attributesList.clear (); }

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

    void setHlLineContinue (bool cont)
    {
      if (cont) m_flags = m_flags | flagHlContinue;
      else m_flags = m_flags & ~ flagHlContinue;
    }

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

    void setContext (QVector<short> &val) { m_ctx = val; }

    void setNoIndentBasedFolding(bool val)
    {
      if (val) m_flags = m_flags | flagNoIndentationBasedFolding;
      else m_flags = m_flags & ~ flagNoIndentationBasedFolding;
    }

    void setNoIndentBasedFoldingAtStart(bool val)
    {
      if (val) m_flags = m_flags | flagNoIndentationBasedFoldingAtStart;
      else m_flags = m_flags & ~ flagNoIndentationBasedFoldingAtStart;
    }

    void setFoldingList (QVector<int> &val) { m_foldingList = val; }

    void setIndentationDepth (QVector<unsigned short> &val) { m_indentationDepth = val; }

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

  private:
    QString m_text;

    QVector<int> m_attributesList;

    QVector<short> m_ctx;

    QVector<int> m_foldingList;

    QVector<unsigned short> m_indentationDepth;

    uchar m_flags;
};

typedef QSharedPointer<TextLineData> TextLine;

}

#endif