katetextline.h

/* This file is part of the KDE libraries
   Copyright (C) 2001-2003 Christoph Cullmann <cullmann@kde.org>
   Copyright (C) 2002 Joseph Wenninger <jowenn@kde.org>
 
   Based on:
     KateTextLine : Copyright (C) 1999 Jochen Wilhelmy <digisnap@cs.tu-berlin.de>
 
   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License version 2 as published by the Free Software Foundation.
 
   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 <ksharedptr.h>
 
#include <tqmemarray.h>
#include <tqstring.h>
 
class KateRenderer;
class TQTextStream;
 
class KateTextLine : public TDEShared
{
  public:
    typedef TDESharedPtr<KateTextLine> Ptr;
 
  public:
    enum Flags
    {
      flagNoOtherData = 1, // ONLY INTERNAL USE, NEVER EVER SET THAT !!!!
      flagHlContinue = 2,
      flagAutoWrapped = 4,
      flagFoldingColumnsOutdated = 8,
      flagNoIndentationBasedFolding = 16,
      flagNoIndentationBasedFoldingAtStart = 32
    };
 
  public:
    KateTextLine ();
 
    ~KateTextLine ();
 
  public:
    inline void setFoldingColumnsOutdated(bool set) { if (set) m_flags |= KateTextLine::flagFoldingColumnsOutdated; else m_flags&=
                                                      (~KateTextLine::flagFoldingColumnsOutdated);}
 
     inline bool foldingColumnsOutdated() { return m_flags & KateTextLine::flagFoldingColumnsOutdated; }
 
 
    inline uint length() const { return m_text.length(); }
 
    inline bool hlLineContinue () const { return m_flags & KateTextLine::flagHlContinue; }
 
    inline bool isAutoWrapped () const { return m_flags & KateTextLine::flagAutoWrapped; }
 
    int firstChar() const;
 
    int lastChar() const;
 
    int nextNonSpaceChar(uint pos) const;
 
    int previousNonSpaceChar(uint pos) const;
 
    inline TQChar getChar (uint pos) const { return m_text[pos]; }
 
    inline const TQChar *text() const { return m_text.unicode(); }
 
    inline uchar *attributes () const { return m_attributes.data(); }
 
    inline const TQString& string() const { return m_text; }
 
    inline TQString string(uint startCol, uint length) const
    { return m_text.mid(startCol, length); }
 
    const TQChar *firstNonSpace() const;
 
    uint indentDepth (uint tabwidth) const;
 
    int cursorX(uint pos, uint tabChars) const;
 
    uint lengthWithTabs (uint tabChars) const;
 
    bool stringAtPos(uint pos, const TQString& match) const;
 
    bool startingWith(const TQString& match) const;
 
    bool endingWith(const TQString& match) const;
 
    bool searchText (uint startCol, const TQString &text,
                     uint *foundAtCol, uint *matchLen,
                     bool casesensitive = true,
                     bool backwards = false);
 
    bool searchText (uint startCol, const TQRegExp &regexp,
                     uint *foundAtCol, uint *matchLen,
                     bool backwards = false);
 
    inline uchar attribute (uint pos) const
    {
      if (pos < m_attributes.size()) return m_attributes[pos];
      return 0;
    }
 
    inline const TQMemArray<short> &ctxArray () const { return m_ctx; };
 
    inline const bool noIndentBasedFolding() const { return m_flags & KateTextLine::flagNoIndentationBasedFolding; };
    inline const bool noIndentBasedFoldingAtStart() const { return m_flags & KateTextLine::flagNoIndentationBasedFoldingAtStart; };
    inline const TQMemArray<uint> &foldingListArray () const { return m_foldingList; };
 
    inline const TQMemArray<unsigned short> &indentationDepthArray () const { return m_indentationDepth; };
 
    void insertText (uint pos, uint insLen, const TQChar *insText, uchar *insAttribs = 0);
 
    void removeText (uint pos, uint delLen);
 
    void truncate(uint newLen);
 
    inline void setHlLineContinue (bool cont)
    {
      if (cont) m_flags = m_flags | KateTextLine::flagHlContinue;
      else m_flags = m_flags & ~ KateTextLine::flagHlContinue;
    }
 
    inline void setAutoWrapped (bool wrapped)
    {
      if (wrapped) m_flags = m_flags | KateTextLine::flagAutoWrapped;
      else m_flags = m_flags & ~ KateTextLine::flagAutoWrapped;
    }
 
    inline void setContext (TQMemArray<short> &val) { m_ctx.assign (val); }
 
    inline void setNoIndentBasedFolding(bool val)
    {
      if (val) m_flags = m_flags | KateTextLine::flagNoIndentationBasedFolding;
      else m_flags = m_flags & ~ KateTextLine::flagNoIndentationBasedFolding;
    }
 
    inline void setNoIndentBasedFoldingAtStart(bool val)
    {
      if (val) m_flags = m_flags | KateTextLine::flagNoIndentationBasedFoldingAtStart;
      else m_flags = m_flags & ~ KateTextLine::flagNoIndentationBasedFoldingAtStart;
    }
 
    inline void setFoldingList (TQMemArray<uint> &val) { m_foldingList.assign (val); m_foldingList.detach(); }
 
    inline void setIndentationDepth (TQMemArray<unsigned short> &val) { m_indentationDepth.assign (val); }
 
  public:
    inline uint dumpSize (bool withHighlighting) const
    {
      return ( 1
               + sizeof(uint)
               + (m_text.length() * sizeof(TQChar))
               + ( withHighlighting ?
                     ( (3 * sizeof(uint))
                       + (m_text.length() * sizeof(uchar))
                       + (m_ctx.size() * sizeof(short))
                       + (m_foldingList.size() * sizeof(uint))
                       + (m_indentationDepth.size() * sizeof(unsigned short))
                     ) : 0
                 )
             );
    }
 
    char *dump (char *buf, bool withHighlighting) const;
 
    char *restore (char *buf);
 
  private:
    TQString m_text;
 
    TQMemArray<uchar> m_attributes;
 
    TQMemArray<short> m_ctx;
 
    TQMemArray<uint> m_foldingList;
 
    TQMemArray<unsigned short> m_indentationDepth;
 
    uchar m_flags;
};
 
#endif