coord.h

Go to the documentation of this file.

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

    Copyright 2003,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 Section 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_COORD_H
#define OKTETA_COORD_H

// lib
#include "lineposition.h"
#include "line.h"
// Okteta core
#include "address.h"
#include "size.h"


namespace Okteta
{

class Coord
{
  public:
    static Coord fromIndex( Address index, LinePositionSize lineWidth );
  public:
    Coord();
    Coord( LinePosition pos, Line line );
    Coord( const Coord& other );
    Coord& operator=( const Coord& other );

    ~Coord();


  public: // logic
    bool operator==( const Coord& other ) const;
    bool operator!=( const Coord& other ) const;
    bool operator<( const Coord& other ) const;
    bool operator<=( const Coord& other ) const;
    bool operator>( const Coord& other ) const;
    bool operator>=( const Coord& other ) const;

    bool isPriorInLineThan( const Coord& other ) const;
    bool isLaterInLineThan( const Coord& other ) const;
    bool isBelow( Line line ) const;
    bool isAbove( Line line ) const;
    bool isAtStart() const;
    bool isBehindLineStart() const;
    bool isBeforeLineEnd( LinePosition maxPos ) const;

    Address indexByLineWidth( LinePositionSize lineWidth ) const;

  public:
    void setByIndexNWidth( Address index, LinePositionSize lineWidth );
    void set( LinePosition pos, Line line );
    void setPos( LinePosition pos );
    void setLine( Line line );

    void goLeft();
    void goLeft( LinePositionSize positions );
    void goCLeft( LinePosition maxPos );
    void goRight();
    void goRight( LinePositionSize positions );
    void goCRight( LinePosition maxPos );
    void gotoStart();
    void gotoEndOfPreviousLine( LinePosition lastPos );
    void gotoStartOfNextLine();
    void goLineStart( const Coord& other );
    void goLineEnd( LinePosition lastPos, const Coord& other );
    void goUp();
    void goDown();
    void goUp( LineSize lines );
    void goDown( LineSize lines );

  public: // state value access
    LinePosition pos() const;
    Line line() const;
    bool isValid() const;

  private: // member variables
    LinePosition mPos;
    Line mLine;
};


inline Coord::Coord() : mPos( 0 ), mLine( 0 ) {}
inline Coord::Coord( LinePosition pos, Line line ) : mPos( pos ), mLine( line ) {}

inline Coord Coord::fromIndex( Address index, LinePositionSize lineWidth )
{
    const Line line = index / lineWidth;
    const LinePosition pos  = index - line*lineWidth;
    return Coord( pos, line );
}

inline Coord::Coord( const Coord& other ) : mPos( other.mPos ), mLine( other.mLine ) {}
inline Coord& Coord::operator=( const Coord& other ) { mPos = other.mPos; mLine = other.mLine; return *this; }
inline Coord::~Coord() {}

inline bool Coord::operator==( const Coord& other ) const { return mPos == other.mPos && mLine == other.mLine; }
inline bool Coord::operator!=( const Coord& other ) const { return !(*this == other); }

inline bool Coord::operator<( const Coord& other ) const
{ return mLine < other.mLine || (mLine == other.mLine && mPos<other.mPos); }
inline bool Coord::operator<=( const Coord& other ) const
{ return mLine < other.mLine || (mLine == other.mLine && mPos<=other.mPos); }
inline bool Coord::operator>( const Coord& other ) const
{ return mLine > other.mLine || (mLine == other.mLine && mPos>other.mPos); }
inline bool Coord::operator>=( const Coord& other ) const
{ return mLine > other.mLine || (mLine == other.mLine && mPos>=other.mPos); }

inline LinePosition  Coord::pos() const { return mPos; }
inline Line  Coord::line()        const { return mLine; }
inline bool Coord::isValid()      const { return mLine >= 0 && mPos >= 0; }

inline void Coord::setByIndexNWidth( Address index, LinePositionSize lineWidth )
{
    mLine = index / lineWidth;
    mPos  = index - mLine*lineWidth;
}

inline void Coord::set( LinePosition pos, Line line )
{
    mPos  = pos;
    mLine = line;
}
inline void Coord::setPos( LinePosition pos )  { mPos  = pos; }
inline void Coord::setLine( Line line ) { mLine = line; }

inline void Coord::goCRight( LinePosition maxPos )
{
    if( isBeforeLineEnd(maxPos) )
        goRight();
    else
        gotoStartOfNextLine();
}
inline void Coord::goCLeft( LinePosition maxPos )
{
    if( isBehindLineStart() )
        goLeft();
    else
        gotoEndOfPreviousLine( maxPos );
}

inline void Coord::goRight() { ++mPos; }
inline void Coord::goLeft()  { --mPos; }
inline void Coord::goRight( LinePositionSize positions ) { mPos += positions; }
inline void Coord::goLeft( LinePositionSize positions )  { mPos -= positions; }

inline void Coord::gotoStart() { mPos = mLine = 0; }

inline void Coord::gotoEndOfPreviousLine( LinePosition lastPos )
{
    --mLine;
    mPos = lastPos;
}

inline void Coord::gotoStartOfNextLine()
{
    ++mLine;
    mPos = 0;
}


inline void Coord::goLineStart( const Coord& other )
{
    mPos = ( mLine == other.mLine ) ? other.mPos : 0;
}

inline void Coord::goLineEnd( LinePosition lastPos, const Coord& other )
{
    mPos = ( mLine == other.mLine ) ? other.mPos : lastPos;
}

inline void Coord::goUp()           { --mLine; }
inline void Coord::goDown()         { ++mLine; }
inline void Coord::goUp( LineSize lines )    { mLine -= lines; }
inline void Coord::goDown( LineSize lines )  { mLine += lines; }


inline Address Coord::indexByLineWidth( LinePositionSize lineWidth ) const
{
    return mLine * lineWidth + mPos;
}


inline bool Coord::isPriorInLineThan( const Coord& other ) const
{
    return mLine == other.mLine && mPos < other.mPos;
}

inline bool Coord::isLaterInLineThan( const Coord& other ) const
{
    return mLine == other.mLine && mPos > other.mPos;
}

inline bool Coord::isBelow( Line line ) const { return mLine > line; }
inline bool Coord::isAbove( Line line ) const { return mLine < line; }

inline bool Coord::isBehindLineStart()           const { return mPos > 0; }
inline bool Coord::isBeforeLineEnd( LinePosition maxPos ) const { return mPos < maxPos; }

inline bool Coord::isAtStart()                   const { return mPos == 0 && mLine == 0; }

inline Coord operator+( const Coord& other, LinePosition pos )
{
    return Coord( other.pos()+pos, other.line() );
}

}

#endif