katesupercursor.h

/* This file is part of the KDE libraries
   Copyright (C) 2003 Hamish Rodda <rodda@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 KATESUPERCURSOR_H
#define KATESUPERCURSOR_H
 
#include "katecursor.h"
 
class KateDocument;
class KateView;
 
class KateSuperCursor : public TQObject, public KateDocCursor, public Kate::Cursor
{
  TQ_OBJECT
 
public:
    KateSuperCursor(KateDocument* doc, bool privateC, const KateTextCursor& cursor, TQObject* parent = 0L, const char* name = 0L);
    KateSuperCursor(KateDocument* doc, bool privateC, int lineNum = 0, int col = 0, TQObject* parent = 0L, const char* name = 0L);
 
    ~KateSuperCursor ();
 
  public:
    // KTextEditor::Cursor interface
    void position(uint *line, uint *col) const;
    bool setPosition(uint line, uint col);
    bool insertText(const TQString& text);
    bool removeText(uint numberOfCharacters);
    TQChar currentChar() const;
 
    bool atStartOfLine() const;
 
    bool atEndOfLine() const;
 
    bool moveOnInsert() const;
 
    void setMoveOnInsert(bool moveOnInsert);
 
    operator TQString();
 
    // Reimplementations;
    virtual void setLine(int lineNum);
    virtual void setCol(int colNum);
    virtual void setPos(const KateTextCursor& pos);
    virtual void setPos(int lineNum, int colNum);
 
  signals:
    void positionDirectlyChanged();
 
    void positionChanged();
 
    void positionUnChanged();
 
    void positionDeleted();
 
    void charInsertedAt();
 
    void charDeletedBefore();
 
    void charDeletedAfter();
 
  //BEGIN METHODES TO CALL FROM KATE DOCUMENT TO KEEP CURSOR UP TO DATE
  public:
    void editTextInserted ( uint line, uint col, uint len);
    void editTextRemoved ( uint line, uint col, uint len);
 
    void editLineWrapped ( uint line, uint col, bool newLine = true );
    void editLineUnWrapped ( uint line, uint col, bool removeLine = true, uint length = 0 );
 
    void editLineInserted ( uint line );
    void editLineRemoved ( uint line );
  //END
 
  private:
    KateDocument *m_doc;
    bool m_moveOnInsert : 1;
    bool m_lineRemoved : 1;
    bool m_privateCursor : 1;
};
 
class KateSuperRange : public TQObject, public KateRange
{
              friend class KateSuperRangeList;
 
  TQ_OBJECT
 
public:
  enum InsertBehaviour {
    DoNotExpand = 0,
    ExpandLeft = 0x1,
    ExpandRight = 0x2
  };
 
  KateSuperRange(KateSuperCursor* start, KateSuperCursor* end, TQObject* parent = 0L, const char* name = 0L);
  KateSuperRange(KateDocument* doc, const KateRange& range, TQObject* parent = 0L, const char* name = 0L);
  KateSuperRange(KateDocument* doc, const KateTextCursor& start, const KateTextCursor& end, TQObject* parent = 0L, const char* name = 0L);
 
  virtual ~KateSuperRange();
 
  // fulfill KateRange requirements
  virtual KateTextCursor& start();
  virtual KateTextCursor& end();
  virtual const KateTextCursor& start() const;
  virtual const KateTextCursor& end() const;
 
  void allowZeroLength(bool yes=true){m_allowZeroLength=yes;}
  KateSuperCursor& superStart();
  const KateSuperCursor& superStart() const;
 
  KateSuperCursor& superEnd();
  const KateSuperCursor& superEnd() const;
 
  int behaviour() const;
 
  void setBehaviour(int behaviour);
 
  virtual bool isValid() const;
 
  bool owns(const KateTextCursor& cursor) const;
 
  bool includes(const KateTextCursor& cursor) const;
 
  bool includes(uint lineNum) const;
 
  bool includesWholeLine(uint lineNum) const;
 
  bool boundaryAt(const KateTextCursor& cursor) const;
 
  bool boundaryOn(uint lineNum) const;
 
signals:
  void positionChanged();
 
  void positionUnChanged();
 
  void contentsChanged();
 
  void boundaryDeleted();
 
  void eliminated();
 
  void tagRange(KateSuperRange* range);
 
public slots:
  void slotTagRange();
 
private slots:
  void slotEvaluateChanged();
  void slotEvaluateUnChanged();
 
private:
  void init();
  void evaluateEliminated();
  void evaluatePositionChanged();
 
  KateSuperCursor* m_start;
  KateSuperCursor* m_end;
  bool m_evaluate;
  bool m_startChanged;
  bool m_endChanged;
  bool m_deleteCursors;
  bool m_allowZeroLength;
};
 
class KateSuperCursorList : public TQPtrList<KateSuperCursor>
{
protected:
  virtual int compareItems(TQPtrCollection::Item item1, TQPtrCollection::Item item2);
};
 
class KateSuperRangeList : public TQObject, public TQPtrList<KateSuperRange>
{
  TQ_OBJECT
 
public:
  KateSuperRangeList(bool autoManage = true, TQObject* parent = 0L, const char* name = 0L);
 
  KateSuperRangeList(const TQPtrList<KateSuperRange>& rangeList, TQObject* parent = 0L, const char* name = 0L);
 
  virtual ~KateSuperRangeList() {}
  void appendList(const TQPtrList<KateSuperRange>& rangeList);
 
  void connectAll();
 
  virtual void clear();
 
  bool autoManage() const;
 
  void setAutoManage(bool autoManage);
 
  TQPtrList<KateSuperRange> rangesIncluding(const KateTextCursor& cursor);
  TQPtrList<KateSuperRange> rangesIncluding(uint line);
 
  bool rangesInclude(const KateTextCursor& cursor);
 
  KateSuperCursor* firstBoundary(const KateTextCursor* start = 0L);
 
  KateSuperCursor* nextBoundary();
 
  KateSuperCursor* currentBoundary();
 
signals:
  void rangeEliminated(KateSuperRange* range);
 
  void listEmpty();
 
  void tagRange(KateSuperRange* range);
 
protected:
  virtual int compareItems(TQPtrCollection::Item item1, TQPtrCollection::Item item2);
 
  virtual TQPtrCollection::Item newItem(TQPtrCollection::Item d);
 
private slots:
  void slotEliminated();
  void slotDeleted(TQObject* range);
 
private:
  bool m_autoManage;
  bool m_connect;
 
  KateSuperCursorList m_columnBoundaries;
  bool m_trackingBoundaries;
};
 
#endif