smartrange.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) 2008 David Nolden <david.nolden.kdevelop@art-master.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 KDELIBS_KTEXTEDITOR_SMARTRANGE_H
#define KDELIBS_KTEXTEDITOR_SMARTRANGE_H

#include <ktexteditor/ktexteditor_export.h>
#include <ktexteditor/range.h>
#include <ktexteditor/smartcursor.h>
#include <ktexteditor/attribute.h>

#include <QtCore/QList>

#ifndef DOXYGEN_SHOULD_SKIP_THIS
template <class T> class QStack;
#endif

class KAction;

namespace KTextEditor
{
class SmartRangeNotifier;
class SmartRangeWatcher;

class KTEXTEDITOR_EXPORT SmartRange : public Range
{
  friend class SmartCursor;

  public:
    enum InsertBehavior {
      DoNotExpand = 0,
      ExpandLeft = 0x1,
      ExpandRight = 0x2
    };
    Q_DECLARE_FLAGS(InsertBehaviors, InsertBehavior)

    virtual ~SmartRange();

    virtual bool isSmartRange() const;

    virtual SmartRange* toSmartRange() const;

    virtual void setRange(const Range& range);

    inline SmartCursor& smartStart()
      { return *static_cast<SmartCursor*>(m_start); }

    inline const SmartCursor& smartStart() const
      { return *static_cast<const SmartCursor*>(m_start); }

    inline SmartCursor& smartEnd()
      { return *static_cast<SmartCursor*>(m_end); }

    inline const SmartCursor& smartEnd() const
      { return *static_cast<const SmartCursor*>(m_end); }

    virtual bool confineToRange(const Range& range);

    virtual bool expandToRange(const Range& range);

    //BEGIN Functionality present from having this range associated with a Document
    Document* document() const;

    virtual QStringList text(bool block = false) const;

    virtual bool replaceText(const QStringList &text, bool block = false);

    virtual bool removeText(bool block = false);
    //END

    //BEGIN Behavior
    InsertBehaviors insertBehavior() const;

    void setInsertBehavior(InsertBehaviors behavior);
    //END

    //BEGIN Relationships to other ranges
    inline SmartRange* parentRange() const
      { return m_parentRange; }

    virtual void setParentRange(SmartRange* r);

    bool hasParent(SmartRange* parent) const;

    inline int depth() const
      { return m_parentRange ? m_parentRange->depth() + 1 : 0; }

    inline SmartRange* topParentRange() const
      { return parentRange() ? parentRange()->topParentRange() : const_cast<SmartRange*>(this); }

    const QList<SmartRange*>& childRanges() const;

    void clearChildRanges();

    void deleteChildRanges();

    void clearAndDeleteChildRanges();

    SmartRange* childBefore( const SmartRange * range ) const;

    SmartRange* childAfter( const SmartRange * range ) const;

    SmartRange* mostSpecificRange(const Range& input) const;

    SmartRange* firstRangeContaining(const Cursor& pos) const;

    SmartRange* deepestRangeContaining(const Cursor& pos,
                                       QStack<SmartRange*>* rangesEntered = 0L,
                                       QStack<SmartRange*>* rangesExited = 0L) const;

    QList<SmartRange*> deepestRangesContaining(const Cursor& pos) const;
    
    int overlapCount() const;
    //END

    //BEGIN Arbitrary highlighting
    Attribute::Ptr attribute() const;

    void setAttribute(Attribute::Ptr attribute);
    //END

    //BEGIN Action binding
    void associateAction(KAction* action);

    void dissociateAction(KAction* action);

    const QList<KAction*>& associatedActions() const
      { return m_associatedActions; }

    void clearAssociatedActions();
    //END

    //BEGIN Notification methods
    SmartRangeNotifier* primaryNotifier();

    const QList<SmartRangeNotifier*> notifiers() const;

    void addNotifier(SmartRangeNotifier* notifier);

    void removeNotifier(SmartRangeNotifier* notifier);

    void deletePrimaryNotifier();

    const QList<SmartRangeWatcher*>& watchers() const;

    void addWatcher(SmartRangeWatcher* watcher);

    void removeWatcher(SmartRangeWatcher* watcher);
    //END

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

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

  protected:
    SmartRange(SmartCursor* start, SmartCursor* end, SmartRange* parent = 0L, InsertBehaviors insertBehavior = DoNotExpand);

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

    virtual void checkFeedback();

    virtual SmartRangeNotifier* createNotifier() = 0;

    void rebuildChildStructure();
    
  private:
    SmartRange(const SmartRange&);

    SmartRange* deepestRangeContainingInternal(const Cursor& pos,
                                               QStack<SmartRange*>* rangesEntered,
                                               QStack<SmartRange*>* rangesExited,
                                               bool first = false) const;

    void insertChildRange(SmartRange* newChild);

    void removeChildRange(SmartRange* newChild);

    Attribute::Ptr m_attribute;

    SmartRange* m_parentRange;

    QList<SmartRange*> m_childRanges;

    QList<KAction*> m_associatedActions;

    QList<SmartRangeNotifier*> m_notifiers;

    QList<SmartRangeWatcher*> m_watchers;

    bool m_ownsAttribute :1;
    uchar m_overlapCount:6;
};

Q_DECLARE_OPERATORS_FOR_FLAGS(SmartRange::InsertBehaviors)

}

#endif

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