range.h

Go to the documentation of this file.

/* This file is part of the KDE project
 *  Copyright (C) 2003-2005 Hamish Rodda <rodda@kde.org>
 *  Copyright (C) 2001-2005 Christoph Cullmann <cullmann@kde.org>
 *  Copyright (C) 2002 Christian Couder <christian@kdevelop.org>
 *  Copyright (C) 2001 Joseph Wenninger <jowenn@kde.org>
 *  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 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 KDELIBS_KTEXTEDITOR_RANGE_H
#define KDELIBS_KTEXTEDITOR_RANGE_H

#include <ktexteditor/ktexteditor_export.h>
#include <ktexteditor/cursor.h>


namespace KTextEditor
{
class SmartRange;

class KTEXTEDITOR_EXPORT Range
{
  friend class Cursor;

  public:
    Range();

    Range(const Cursor& start, const Cursor& end);

    Range(const Cursor& start, int width);

    Range(const Cursor& start, int endLine, int endColumn);

    Range(int startLine, int startColumn, int endLine, int endColumn);

    Range(const Range& copy);

    //Do not remove! Needed for inheritance.
    virtual ~Range();

    virtual bool isValid() const;

    static Range invalid();

    virtual bool isSmartRange() const;

    virtual SmartRange* toSmartRange() const;

    Cursor& start();

    const Cursor& start() const;

    Cursor& end();

    const Cursor& end() const;

    void setBothLines(int line);

    void setBothColumns(int column);

    virtual void setRange(const Range& range);

    void setRange(const Cursor& start, const Cursor& end);

    virtual bool expandToRange(const Range& range);

    virtual bool confineToRange(const Range& range);

    bool onSingleLine() const;

    int numberOfLines() const;

    int columnWidth() const;

    bool isEmpty() const;

#if 0
    // TODO: KDE5 if we have consistency cecks, the following is not needed.
    //       otherwise, if start could possibly be after end, then the following
    //       is handy:
    inline bool isNormalized() const
    { return m_start <= m_end; }

    inline void normalize()
    {
      if (isValid() && start > end) {
        std::swap(m_start, m_end);
      }
    }

    KTextEditor::Range normalize() const
    {
      if (isValid()) {
        if (m_start <= m_end) {
          return *this;
        } else {
          return Range(m_end, m_start);
        }
      } else {
        return invalid();
      }
    }
#endif

    //BEGIN comparison functions
    bool contains(const Range& range) const;

    bool contains(const Cursor& cursor) const;

    bool containsLine(int line) const;

    bool containsColumn(int column) const;

    bool overlaps(const Range& range) const;

    bool overlapsLine(int line) const;

    bool overlapsColumn(int column) const;

    int positionRelativeToCursor(const Cursor& cursor) const;

    int positionRelativeToLine(int line) const;

    bool boundaryAtCursor(const Cursor& cursor) const;

    bool boundaryOnLine(int line) const;

    bool boundaryOnColumn(int column) const;
    //END

    Range intersect(const Range& range) const;

    Range encompass(const Range& range) const;

    inline Range& operator=(const Range& rhs)
      { setRange(rhs); return *this; }

    inline friend Range operator+(const Range& r1, const Range& r2)
      { return Range(r1.start() + r2.start(), r1.end() + r2.end()); }

    inline friend Range& operator+=(Range& r1, const Range& r2)
      { r1.setRange(r1.start() + r2.start(), r1.end() + r2.end()); return r1; }

    inline friend Range operator-(const Range& r1, const Range& r2)
      { return Range(r1.start() - r2.start(), r1.end() - r2.end()); }

    inline friend Range& operator-=(Range& r1, const Range& r2)
      { r1.setRange(r1.start() - r2.start(), r1.end() - r2.end()); return r1; }

    inline friend Range operator&(const Range& r1, const Range& r2)
      { return r1.intersect(r2); }

    inline friend Range& operator&=(Range& r1, const Range& r2)
      { r1.setRange(r1.intersect(r2)); return r1; }

    inline friend bool operator==(const Range& r1, const Range& r2)
      { return r1.start() == r2.start() && r1.end() == r2.end(); }

    inline friend bool operator!=(const Range& r1, const Range& r2)
      { return r1.start() != r2.start() || r1.end() != r2.end(); }

    inline friend bool operator>(const Range& r1, const Range& r2)
      { return r1.start() > r2.end(); }

    inline friend bool operator<(const Range& r1, const Range& r2)
      { return r1.end() < r2.start(); }

    inline friend QDebug operator<< (QDebug s, const Range& range) {
      if (&range)
        s << "[" << range.start() << " -> " << range.end() << "]";
      else
        s << "(null range)";
      return s;
    }

  protected:
    Range(Cursor* start, Cursor* end);

    virtual void rangeChanged(Cursor* cursor, const Range& from);

    Cursor* m_start;

    Cursor* m_end;
};

}

#endif

// kate: space-indent on; indent-width 2; replace-tabs on;