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 TextBlock;

  public:
    typedef QVector<short> ContextStack;
    
    class Attribute {
      public:
        Attribute (int _offset = 0, int _length = 0, short _attributeValue = 0, short _foldingValue = 0)
          : offset (_offset)
          , length (_length)
          , attributeValue (_attributeValue)
          , foldingValue (_foldingValue)
        {
        }
        
        int offset;
        
        int length;
        
        short attributeValue;
        
        short foldingValue;
    };
    
    enum Flags
    {
      flagHlContinue = 1,
      flagAutoWrapped = 2,
      flagFoldingStartAttribute = 4,
      flagFoldingStartIndentation = 8,
      flagLineModified = 16,
      flagLineSavedOnDisk = 32
    };

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

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

    const ContextStack &contextStack () const { return m_contextStack; }

    void setContextStack (const ContextStack &val) { m_contextStack = val; }

    void addAttribute (const Attribute &attribute);

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

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

    short attribute (int pos) const
    {
      for (int i=0; i < m_attributesList.size(); ++i)
      {
        if (pos >= m_attributesList[i].offset && pos < (m_attributesList[i].offset + m_attributesList[i].length))
          return m_attributesList[i].attributeValue;

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

      return 0;
    }

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

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

  private:
    QString m_text;

    QVector<Attribute> m_attributesList;

    ContextStack m_contextStack;

    unsigned int m_flags;
};

typedef QSharedPointer<TextLineData> TextLine;

}

#endif