selection.h

Go to the documentation of this file.

/*
    This file is part of the Okteta Gui library, made within the KDE community.

    Copyright 2003,2008-2009 Friedrich W. H. Kossebau <kossebau@kde.org>

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 of the License, or (at your option) version 3, or any
    later version accepted by the membership of KDE e.V. (or its
    successor approved by the membership of KDE e.V.), which shall
    act as a proxy defined in mRange 6 of version 3 of the license.

    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
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with this library. If not, see <http://www.gnu.org/licenses/>.
*/

#ifndef OKTETA_SELECTION_H
#define OKTETA_SELECTION_H

// lib
#include "addressrange.h"


namespace Okteta
{

class Selection
{
  public:
    explicit Selection( Address index );
    Selection();

    ~Selection();

  public:
    Selection& operator=( const Selection& other );
    Selection& operator=( const AddressRange& range );

  public: // modification access
    void setStart( Address index );
    void setEnd( Address index );
    void cancel();
    void setForward( bool forward = true );
    void reverse();

    void adaptToReplacement( Address pos, Size removedLength, Size insertedLength );
    void adaptToSwap( Address firstOffset, Address secondOffset, Size secondLength );

  public: // value access
    Address anchor() const;
    Address start() const;
    Address end() const;
    Address nextBeforeStart() const;
    Address nextBehindEnd() const;
    const AddressRange& range() const;


  public: // logic access
    bool isValid() const;
    bool started() const;
    bool justStarted() const;
    bool isForward() const;

  protected:
    AddressRange mRange;
    Address mAnchor;
};


inline Selection::Selection() : mAnchor( -1 ) {}
inline Selection::Selection( Address index ) : mAnchor( index )  {}
inline Selection::~Selection() {}

inline Selection &Selection::operator=( const Selection& other )
{
    mRange = other.mRange;
    mAnchor = other.mAnchor;
    return *this;
}

inline Selection &Selection::operator=( const AddressRange& range )
{
    mRange = range;
    mAnchor = range.start();
    return *this;
}


inline void Selection::setStart( Address index )
{
    mAnchor = index;
    mRange.unset();
}


inline void Selection::setEnd( Address index )
{
    // nothing selected?
    if( index == mAnchor )
        mRange.unset();
    // selecting forwards?
    else if( index > mAnchor )
    {
        mRange.setStart( mAnchor );
        mRange.setEnd( index-1 );
    }
    // selecting backwards
    else
    {
        mRange.setStart( index );
        mRange.setEnd( mAnchor-1 );
    }
}

inline void Selection::reverse()
{
    mAnchor = isForward() ? mRange.nextBehindEnd() : mRange.start();
}

inline void Selection::setForward( bool Forward )
{
    mAnchor = Forward ? mRange.start() : mRange.nextBehindEnd();
}

inline const AddressRange& Selection::range()   const { return mRange; }
inline Address Selection::anchor()              const { return mAnchor; }
inline Address Selection::start()               const { return mRange.start(); }
inline Address Selection::end()                 const { return mRange.end(); }
inline Address Selection::nextBeforeStart()     const { return mRange.nextBeforeStart(); }
inline Address Selection::nextBehindEnd()       const { return mRange.nextBehindEnd(); }

inline void Selection::cancel() { mAnchor = -1; mRange.unset(); }

inline bool Selection::isValid()     const { return mRange.isValid(); }
inline bool Selection::started()     const { return mAnchor != -1; }
inline bool Selection::justStarted() const { return mAnchor != -1 && mRange.start() == -1; }
inline bool Selection::isForward()   const { return mAnchor == mRange.start(); }

inline void Selection::adaptToReplacement( Address pos, Size removedLength, Size insertedLength )
{
    mRange.adaptToReplacement( pos, removedLength, insertedLength );
    mAnchor = isForward() ? mRange.start() : mRange.nextBehindEnd();
}

inline void Selection::adaptToSwap( Address firstOffset, Address secondOffset, Size secondLength )
{
    // no intersection?
    if( mRange.end() < firstOffset || mRange.start() > secondOffset+secondLength-1 )
        return;

    const AddressRange firstSection( firstOffset, secondOffset-1 );
    if( firstSection.includes(mRange) )
        mRange.moveBy( secondLength );
    else
    {
        const AddressRange secondRange = AddressRange::fromWidth( secondOffset, secondLength );
        if( secondRange.includes(mRange) )
            mRange.moveBy( -firstSection.width() );
        else
            mRange.unset();
    }
}

}

#endif