SFML/DSFML/import/dsfml/graphics/rect.d

/*
*   DSFML - SFML Library wrapper for the D programming language.
*   Copyright (C) 2008 Julien Dagorn (sirjulio13@gmail.com)
*   Copyright (C) 2010 Andreas Hollandt
*
*   This software is provided 'as-is', without any express or
*   implied warranty. In no event will the authors be held
*   liable for any damages arising from the use of this software.
*
*   Permission is granted to anyone to use this software for any purpose,
*   including commercial applications, and to alter it and redistribute
*   it freely, subject to the following restrictions:
*
*   1.  The origin of this software must not be misrepresented;
*       you must not claim that you wrote the original software.
*       If you use this software in a product, an acknowledgment
*       in the product documentation would be appreciated but
*       is not required.
*
*   2.  Altered source versions must be plainly marked as such,
*       and must not be misrepresented as being the original software.
*
*   3.  This notice may not be removed or altered from any
*       source distribution.
*/

module dsfml.graphics.rect;

struct sfFloatRect
{
    float Left;
    float Top;
    float Right;
    float Bottom;
}

struct sfIntRect
{
    int Left;
    int Top;
    int Right;
    int Bottom;
}

version (Tango)
{
    import tango.core.Traits;
}
else
{
    template isIntegerType(T)
    {
        const bool isIntegerType = 
            is (T == byte) ||
            is (T == short) ||
            is (T == int) ||
            is (T == long);
    }

    template isRealType(T)
    {
        const bool isRealType =
            is (T == float) ||
            is (T == double) ||
            is (T == real);
    }
}    
/**
*   Rect is an utility class for manipulating rectangles.
*   Template parameter defines the type of coordinates (integer float, ...)
*/

class Rect (T)
{

private:
    T m_Left;   // Left coordinate of the rectangle
    T m_Top;    // Top coordinate of the rectangle
    T m_Right;  // Right coordinate of the rectangle
    T m_Bottom; // Bottom coordinate of the rectangle

public:
	static if (!isIntegerType!(T) && !isRealType!(T))
    {
        static assert (0, "This type is not supported by Rectangle");
    }
    
    T min(T)(T i, T j)
    {
        return i < j ? i : j;
    }
    
    T max(T)(T i, T j)
    {
        return i > j ? i : j;
    }
    
    /**
    *   Default constructor
    */
    this()
    {
        m_Left = 0;
        m_Top = 0;
        m_Right = 0;
        m_Bottom = 0;
    }

    /**
    *   Construct the rectangle from its coordinates
    *
    *   Params:
    *       leftCoord = Left coordinate of the rectangle
    *       topCoord = Top coordinate of the rectangle
    *       rightCoord = Right coordinate of the rectangle
    *       bottomCoord = Bottom coordinate of the rectangle
    */
    this(T leftCoord, T topCoord, T rightCoord, T bottomCoord)
    {
        m_Left = leftCoord;
        m_Top = topCoord;
        m_Right = rightCoord;
        m_Bottom = bottomCoord;
    }

    /**
    *   Get the width of the rectangle
    *
    *   Returns:
    *       Width of rectangle
    */
    T getWidth() 
    {
        return m_Right - m_Left;
    }

    /**
    *   Get the height of the rectangle
    *
    *   Returns:
    *       Height of rectangle
    */
    T getHeight()
    {
        return m_Bottom - m_Top;
    }

    /**
    *   Move the whole rectangle by the given offset
    *
    *   Params:
    *       offsetX = Horizontal offset
    *       offsetY = Vertical offset
    */
    void offset(T offsetX, T offsetY)
    {
        m_Left   += offsetX;
        m_Right  += offsetX;
        m_Top    += offsetY;
        m_Bottom += offsetY;
    }

    /**
    *   Check if a point is inside the rectangle's area
    *
    *   Params:
    *       x = X coordinate of the point to test
    *       y = Y coordinate of the point to test
    *
    *   Returns:
    *       True if the point is inside
    */
    bool contains(T x, T y)
    {
        return (x >= m_Left) && (x <= m_Right) && (y >= m_Top) && (y <= m_Bottom);
    }

    /**
    *   Check intersection between two rectangles
    *
    *   Params:
    *       rectangle = Rectangle to test
    *       overlappingRect = Rectangle to be filled with overlapping rect (NULL by default)
    *
    *   Returns:
    *       True if rectangles overlap
    */
    bool intersects(Rect!(T) rectangle, out Rect!(T) overlappingRect = null)
    {
        // Compute overlapping rect
        Rect!(T) overlapping = new Rect!(T)(    
                                                max(m_Left,   rectangle.getLeft),
                                                max(m_Top,    rectangle.getTop),
                                                min(m_Right,  rectangle.getRight),
                                                min(m_Bottom, rectangle.getBottom)
                                            );
    
        // If overlapping rect is valid, then there is intersection
        if ((overlapping.getLeft() < overlapping.getRight() ) && (overlapping.getTop() < overlapping.getBottom()))
        {
            overlappingRect = overlapping;
            return true;
        }
        else
        {
            overlappingRect = new Rect!(T)();
            return false;
        }
    }
    
    /**
    *   Set left Coordinate   
    */     
    void setLeft(T left)
    {
        m_Left = left;
    }

    /**
    *   Set top Coordinate   
    */
    void setTop(T top)
    {
        m_Top = top;
    }

    /**
    *   Set right Coordinate   
    */
    void setRight(T right)
    {
        m_Right = right;
    }

    /**
    *   Set bottom Coordinate   
    */
    void setBottom(T bottom)
    {
        m_Bottom = bottom;
    }

    /**
    *   Get left Coordinate   
    */
    T getLeft()
    {
        return m_Left;
    }

    /**
    *   Get top Coordinate   
    */
    T getTop()
    {
        return m_Top;
    }

    /**
    *   Get right Coordinate   
    */
    T getRight()
    {
        return m_Right;
    }

    /**
    *   Get bottom Coordinate   
    */
    T getBottom()
    {
        return m_Bottom;
    }

package:
    sfFloatRect toCFloatRect()
    {
        return sfFloatRect(m_Left, m_Top, m_Right, m_Bottom);
    }
    
    sfIntRect toCIntRect()
    {
        return sfIntRect(cast(int)m_Left, cast(int)m_Top, cast(int)m_Right, cast(int)m_Bottom);
    }
}

///Alias
alias Rect!(int) IntRect;
///ditto
alias Rect!(float) FloatRect;