katebuffer.h

/* This file is part of the KDE libraries
   Copyright (c) 2000 Waldo Bastian <bastian@kde.org>
   Copyright (C) 2002-2004 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 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_BUFFER_H__
#define __KATE_BUFFER_H__
 
#include "katetextline.h"
#include "katecodefoldinghelpers.h"
 
#include <kvmallocator.h>
 
#include <tqptrlist.h>
#include <tqobject.h>
#include <tqtimer.h>
#include <tqvaluevector.h>
 
class KateLineInfo;
class KateDocument;
class KateHighlighting;
class KateBufBlockList;
class KateBuffer;
class KateFileLoader;
 
class TQTextCodec;
 
class KateBufBlock
{
  friend class KateBufBlockList;
 
  public:
    KateBufBlock ( KateBuffer *parent, KateBufBlock *prev = 0, KateBufBlock *next = 0,
                   KateFileLoader *stream = 0 );
 
    ~KateBufBlock ();
 
  private:
    void fillBlock (KateFileLoader *stream);
 
  public:
    enum State
    {
      stateSwapped = 0,
      stateClean = 1,
      stateDirty = 2
    };
 
    State state () const { return m_state; }
 
  public:
    KateTextLine::Ptr line(uint i);
 
    void insertLine(uint i, KateTextLine::Ptr line);
 
    void removeLine(uint i);
 
    void markDirty ();
 
  public:
    inline uint startLine () const { return m_startLine; };
 
    inline void setStartLine (uint line) { m_startLine = line; }
 
    inline uint endLine () const { return m_startLine + m_lines; }
 
    inline uint lines () const { return m_lines; }
 
    inline KateBufBlock *prev () { return m_prev; }
 
    inline KateBufBlock *next () { return m_next; }
 
  private:
    void swapIn ();
 
    void swapOut ();
 
  private:
    KateBufBlock::State m_state;
 
    uint m_startLine;
 
    uint m_lines;
 
    KVMAllocator::Block *m_vmblock;
 
    uint m_vmblockSize;
 
    TQValueVector<KateTextLine::Ptr> m_stringList;
 
    KateBuffer* m_parent;
 
    KateBufBlock *m_prev;
 
    KateBufBlock *m_next;
 
  private:
    KateBufBlockList *list;
 
    KateBufBlock *listPrev;
 
    KateBufBlock *listNext;
};
 
class KateBufBlockList
{
  public:
    KateBufBlockList ();
 
  public:
    inline uint count() const { return m_count; }
 
    inline KateBufBlock *first () { return m_first; };
 
    inline KateBufBlock *last () { return m_last; };
 
    inline bool isFirst (KateBufBlock *buf) { return m_first == buf; };
 
    inline bool isLast (KateBufBlock *buf) { return m_last == buf; };
 
    void append (KateBufBlock *buf);
 
    inline static void remove (KateBufBlock *buf)
    {
      if (buf->list)
        buf->list->removeInternal (buf);
    }
 
  private:
    void removeInternal (KateBufBlock *buf);
 
  private:
    uint m_count;
 
    KateBufBlock *m_first;
 
    KateBufBlock *m_last;
};
 
class KateBuffer : public TQObject
{
  TQ_OBJECT
 
  friend class KateBufBlock;
 
  public:
    inline static uint maxLoadedBlocks () { return m_maxLoadedBlocks; }
 
    static void setMaxLoadedBlocks (uint count);
 
  private:
    static uint m_maxLoadedBlocks;
 
  public:
    KateBuffer (KateDocument *doc);
 
    ~KateBuffer ();
 
  public:
    void editStart ();
 
    void editEnd ();
 
    inline bool editChanged () const { return editChangesDone; }
 
    inline uint editTagStart () const { return editTagLineStart; }
 
    inline uint editTagEnd () const { return editTagLineEnd; }
 
    inline bool editTagFrom () const { return editTagLineFrom; }
 
  private:
    uint editSessionNumber;
 
    bool editIsRunning;
 
    uint editTagLineStart;
 
    uint editTagLineEnd;
 
    bool editTagLineFrom;
 
    bool editChangesDone;
 
  public:
    void clear();
 
    bool openFile (const TQString &m_file);
 
    bool loadingBorked () const { return m_loadingBorked; }
 
    bool binary () const { return m_binary; }
 
    bool canEncode ();
 
    bool saveFile (const TQString &m_file);
 
  public:
    inline KateTextLine::Ptr line(uint i)
    {
      KateBufBlock *buf = findBlock(i);
      if (!buf)
        return 0;
 
      if (i < m_lineHighlighted)
        return buf->line (i - buf->startLine());
 
      return line_internal (buf, i);
    }
 
  private:
     KateTextLine::Ptr line_internal (KateBufBlock *buf, uint i);
 
     inline void addIndentBasedFoldingInformation(TQMemArray<uint> &foldingList,bool addindent,uint deindent);
     inline void updatePreviousNotEmptyLine(KateBufBlock *blk,uint current_line,bool addindent,uint deindent);
  public:
    inline KateTextLine::Ptr plainLine(uint i)
    {
      KateBufBlock *buf = findBlock(i);
      if (!buf)
        return 0;
 
      return buf->line(i - buf->startLine());
    }
 
    inline uint count() const { return m_lines; }
 
  private:
    KateBufBlock *findBlock (uint i, uint *index = 0)
    {
      // out of range !
      if (i >= m_lines)
        return 0;
 
      if ((m_blocks[m_lastFoundBlock]->startLine() <= i) && (m_blocks[m_lastFoundBlock]->endLine() > i))
      {
        if (index)
          (*index) = m_lastFoundBlock;
 
        return m_blocks[m_lastFoundBlock];
      }
 
      return findBlock_internal (i, index);
    }
 
    KateBufBlock *findBlock_internal (uint i, uint *index = 0);
 
  public:
    void changeLine(uint i);
 
    void insertLine(uint i, KateTextLine::Ptr line);
 
    void removeLine(uint i);
 
  public:
    inline uint countVisible () { return m_lines - m_regionTree.getHiddenLinesCount(m_lines); }
 
    inline uint lineNumber (uint visibleLine) { return m_regionTree.getRealLine (visibleLine); }
 
    inline uint lineVisibleNumber (uint line) { return m_regionTree.getVirtualLine (line); }
 
    inline void lineInfo (KateLineInfo *info, unsigned int line) { m_regionTree.getLineInfo(info,line); }
 
    inline uint tabWidth () const { return m_tabWidth; }
 
  public:
    void setTabWidth (uint w);
 
    void setHighlight (uint hlMode);
 
    KateHighlighting *highlight () { return m_highlight; };
 
    void invalidateHighlighting();
 
    KateCodeFoldingTree *foldingTree () { return &m_regionTree; };
 
  public slots:
    void codeFoldingColumnUpdate(unsigned int lineNr);
 
  private:
    bool doHighlight (KateBufBlock *buf, uint from, uint to, bool invalidate);
 
  signals:
    void codeFoldingUpdated();
 
    void tagLines(int start, int end);
 
  private:
    KateDocument *m_doc;
 
    uint m_lines;
 
    TQValueVector<KateBufBlock*> m_blocks;
 
    uint m_lastInSyncBlock;
 
    uint m_lastFoundBlock;
 
    bool m_cacheReadError;
    bool m_cacheWriteError;
 
    bool m_loadingBorked;
 
    bool m_binary;
 
  private:
    KateHighlighting *m_highlight;
 
    KateCodeFoldingTree m_regionTree;
 
    // for the scrapty indent sensitive langs
    uint m_tabWidth;
 
    uint m_lineHighlightedMax;
    uint m_lineHighlighted;
 
    uint m_maxDynamicContexts;
 
  private:
    KateBufBlockList m_loadedBlocks;
};
 
#endif