gml 1.1.0

// Copyright 2015 Creekware Inc. See the COPYRIGHT
// file at the top-level directory of this distribution.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.

//! Defines structures for geometric primitives and functions that operate
//! on them useful for manipulating elements in a 2D API.
//!
//! The structure Point represents a point in a two-dimensional coordinate
//! system.  The structure Size represents the width and height dimensions.
//! The structure Rect represents the location and dimensions of a rectangle
//! as a Point and a Size.
//!

extern crate num;

use num::traits::*;
use std::ops::*;
use vector::*;

#[derive(Debug, Clone, Copy, PartialEq)]
#[repr(C)]
/// A structure that contains a point in a two-dimensional coordinate system.
pub struct Point<T> {
    /// The x-coordinate of the point.
    pub x:T,
    /// The y-coordinate of the point.
    pub y:T }

/// A Point of `f32` types.
pub type Pointf = Point<f32>;

/// A Point of `i32` types.
pub type Pointi = Point<i32>;

impl<T:Copy> Point<T> {
    // Constructors

    /// Construct a new point from two coordinates.
    ///
    /// ```
    /// let p = gml::Point::new(2.0, 3.0);
    ///
    /// assert!(p.x == 2.0);
    /// assert!(p.y == 3.0);
    /// ```
    pub fn new(x:T, y:T ) -> Point<T> {
        Point{ x:x, y:y }
    }

    /// Construct a new point from a value.
    ///
    /// ```
    /// let p = gml::Point::new_s(10.0);
    ///
    /// assert!(p.x == 10.0);
    /// assert!(p.y == 10.0);
    /// ```
    pub fn new_s(s:T ) -> Point<T> {
        Point{ x:s, y:s }
    }

    /// Construct a new point from a Vector2.
    ///
    /// ```
    /// let v = gml::Vector2::new(2.0, 3.0);
    /// let p = gml::Point::new_v2(v);
    ///
    /// assert!(p.x == 2.0);
    /// assert!(p.y == 3.0);
    /// ```
    pub fn new_v2(v:Vector2<T> ) -> Point<T> {
        Point{ x:v.x, y:v.y }
    }

    /// Construct a new point from a Vector3.
    ///
    /// ```
    /// let v = gml::Vector3::new(2.0, 3.0, 4.0);
    /// let p = gml::Point::new_v3(v);
    ///
    /// assert!(p.x == 2.0);
    /// assert!(p.y == 3.0);
    /// ```
    pub fn new_v3(v:Vector3<T> ) -> Point<T> {
        Point{ x:v.x, y:v.y }
    }

    /// Construct a new point from a Vector4.
    ///
    /// ```
    /// let v = gml::Vector4::new(2.0, 3.0, 4.0, 5.0);
    /// let p = gml::Point::new_v4(v);
    ///
    /// assert!(p.x == 2.0);
    /// assert!(p.y == 3.0);
    /// ```
    pub fn new_v4(v:Vector4<T> ) -> Point<T> {
        Point{ x:v.x, y:v.y }
    }

    /// Converts a point to a Vector2.
    ///
    /// ```
    /// let p = gml::Point::new(2.0, 3.0);
    /// let v = p.v2_cast();
    ///
    /// assert!(v[0] == 2.0);
    /// assert!(v[1] == 3.0);
    /// ```
    pub fn v2_cast(self) -> Vector2<T> {
        Vector2{ x:self.x, y:self.y}
    }

}

impl<T:Copy + Zero + One> Default for Point<T> {

    /// Return the default (identity) point
    ///
    /// ```
    /// let p = gml::Pointf::default();
    ///
    /// assert!(p.x == 0.0);
    /// assert!(p.y == 0.0);
    ///
    /// ```
    fn default() -> Point<T> {
        Point{ x:T::zero(), 
               y:T::zero() }
    }
}

// Implementation of Zero

impl<T:Copy + Zero + PartialEq> Zero for Point<T> {

    /// Return a point with all elements initialize to zero.
    ///
    fn zero() -> Point<T> {
        Point{ x:T::zero(), 
               y:T::zero() }
    }

    /// Return true if all elements of a point are equal to zero;
    /// false otherwise.
    ///
    fn is_zero(&self) -> bool {
        self.x == T::zero() && 
        self.y == T::zero() 
    }
}

// Implementation of One

impl<T:Copy + Num> One for Point<T> {

    /// Return a point with all elements initialize to one.
    ///
    fn one() -> Point<T> {
        Point{ x: T::one(), y: T::one() }
    }
}

impl<T:Add<Output = T> + Zero + Copy> Add<Point<T>> for Point<T> {
    type Output = Point<T>;

    /// Returns a new point in which each element is the sum of
    /// the corresponding element from `self` and `rhs`.
    ///
    /// ```
    /// use gml::*;
    ///
    /// let a = Point::new(2, 4);
    /// let b = Point::new(1, 3);
    ///
    /// let r = a + b; assert!(r == Point::new(3, 7));
    /// ```
    fn add(self, rhs:Point<T>) -> Point<T> {
        Point{ x:self.x + rhs.x,
               y:self.y + rhs.y }
    }
}

impl<T:Add<Output = T> + Zero + Copy> Add<Vector2<T>> for Point<T> {
    type Output = Point<T>;

    /// Returns a new point in which each element is the sum of
    /// the corresponding element from `self` and `rhs`.
    ///
    /// ```
    /// use gml::*;
    ///
    /// let a = Point::new(2, 4);
    /// let b = Vector2::new(1, 3);
    ///
    /// let r = a + b; assert!(r == Point::new(3, 7));
    /// ```
    fn add(self, rhs:Vector2<T>) -> Point<T> {
        Point{ x:self.x + rhs.x,
               y:self.y + rhs.y }
    }
}

impl<T:Sub<Output = T> + Zero + Copy> Sub<Point<T>> for Point<T> {
    type Output = Point<T>;

    /// Returns a new point in which each element is the sum of
    /// the corresponding element from `self` and `rhs`.
    ///
    /// ```
    /// use gml::*;
    ///
    /// let a = Point::new(2, 4);
    /// let b = Point::new(1, 3);
    ///
    /// let r = a - b; assert!(r == Point::new(1, 1));
    /// ```
    fn sub(self, rhs:Point<T>) -> Point<T> {
        Point{ x:self.x - rhs.x,
               y:self.y - rhs.y }
    }
}

impl<T:Copy + Num> Mul<Point<T>> for Point<T> {
    type Output = Point<T>;

    /// Returns the product of two points, needed to implement One.
    ///
    /// ```
    /// use gml::*;
    ///
    /// let a = Point::new(2, 3);
    /// let b = Point::new(6, 7);
    /// let r = a * b;
    ///
    /// assert!(r == Point::new(12, 21));
    /// ```
    fn mul(self, rhs:Point<T>) -> Point<T> {
        Point{x: self.x * rhs.x,
              y: self.y * rhs.y }
    }
}


#[derive(Debug, Clone, Copy, PartialEq)]
#[repr(C)]
/// A structure that contains width and height values.
pub struct Size<T> {
    /// A width value.
    pub width:T,
    /// A height value.
    pub height:T }

/// A Size of `f32` types.
pub type Sizef = Size<f32>;

/// A Size of `i32` types.
pub type Sizei = Size<i32>;

impl<T:Copy> Size<T> {
    // Constructors

    /// Construct a new size from two values.
    ///
    /// ```
    /// let s = gml::Size::new(2.0, 3.0);
    ///
    /// assert!(s.width == 2.0);
    /// assert!(s.height == 3.0);
    /// ```
    pub fn new(w:T, h:T ) -> Size<T> {
        Size{ width:w, height:h }
    }

    /// Construct a new size from a value.
    ///
    /// ```
    /// let s = gml::Size::new_s(10.0);
    ///
    /// assert!(s.width == 10.0);
    /// assert!(s.height == 10.0);
    /// ```
    pub fn new_s(s:T ) -> Size<T> {
        Size{ width:s, height:s }
    }

    /// Construct a new size from a Vector2.
    ///
    /// ```
    /// let v = gml::Vector2::new(2.0, 3.0);
    /// let s = gml::Size::new_v2(v);
    ///
    /// assert!(s.width == 2.0);
    /// assert!(s.height == 3.0);
    /// ```
    pub fn new_v2(v:Vector2<T> ) -> Size<T> {
        Size{ width:v.x, height:v.y }
    }

    /// Converts a size to a Vector2.
    ///
    /// ```
    /// let p = gml::Size::new(2.0, 3.0);
    /// let v = p.v2_cast();
    ///
    /// assert!(v[0] == 2.0);
    /// assert!(v[1] == 3.0);
    /// ```
    pub fn v2_cast(self) -> Vector2<T> {
        Vector2{ x:self.width, y:self.height}
    }
}

impl<T:Copy + Zero + One> Default for Size<T> {

    /// Return the default (identity) size
    ///
    /// ```
    /// let s = gml::Sizef::default();
    ///
    /// assert!(s.width == 1.0);
    /// assert!(s.height == 1.0);
    ///
    /// ```
    fn default() -> Size<T> {
        Size{ width:  T::one(), 
              height: T::one() }
    }
}

// Implementation of Zero

impl<T:Copy + Zero + PartialEq> Zero for Size<T> {

    /// Return a size with all elements initialize to zero.
    ///
    fn zero() -> Size<T> {
        Size{ width:  T::zero(), 
              height: T::zero() }
    }

    /// Return true if all elements of a size are equal to zero;
    /// false otherwise.
    ///
    fn is_zero(&self) -> bool {
        self.width  == T::zero() && 
        self.height == T::zero() 
    }
}

// Implementation of One

impl<T:Copy + Num> One for Size<T> {

    /// Return a size with all elements initialize to one.
    ///
    fn one() -> Size<T> {
        Size{ width: T::one(), height: T::one() }
    }
}

impl<T:Add<Output = T> + Zero + Copy> Add<Size<T>> for Size<T> {
    type Output = Size<T>;

    /// Returns a new size in which each element is the sum of
    /// the corresponding element from `self` and `rhs`.
    ///
    /// ```
    /// use gml::*;
    ///
    /// let a = Size::new(2, 4);
    /// let b = Size::new(1, 3);
    ///
    /// let r = a + b; assert!(r == Size::new(3, 7));
    /// ```
    fn add(self, rhs:Size<T>) -> Size<T> {
        Size{ width:  self.width  + rhs.width,
              height: self.height + rhs.height }
    }
}

impl<T:Add<Output = T> + Zero + Copy> Add<Vector2<T>> for Size<T> {
    type Output = Size<T>;

    /// Returns a new size in which each element is the sum of
    /// the corresponding element from `self` and `rhs`.
    ///
    /// ```
    /// use gml::*;
    ///
    /// let a = Size::new(2, 4);
    /// let b = Vector2::new(1, 3);
    ///
    /// let r = a + b; assert!(r == Size::new(3, 7));
    /// ```
    fn add(self, rhs:Vector2<T>) -> Size<T> {
        Size{ width:  self.width  + rhs.x,
              height: self.height + rhs.y }
    }
}

impl<T:Sub<Output = T> + Zero + Copy> Sub<Size<T>> for Size<T> {
    type Output = Size<T>;

    /// Returns a new size in which each element is the sum of
    /// the corresponding element from `self` and `rhs`.
    ///
    /// ```
    /// use gml::*;
    ///
    /// let a = Size::new(2, 4);
    /// let b = Size::new(1, 3);
    ///
    /// let r = a - b; assert!(r == Size::new(1, 1));
    /// ```
    fn sub(self, rhs:Size<T>) -> Size<T> {
        Size{ width:  self.width  - rhs.width,
              height: self.height - rhs.height }
    }
}

impl<T:Copy + Num> Mul<Size<T>> for Size<T> {
    type Output = Size<T>;

    /// Returns the product of two sizes, needed to implement One.
    ///
    /// ```
    /// use gml::*;
    ///
    /// let a = Size::new(2, 3);
    /// let b = Size::new(6, 7);
    /// let r = a * b;
    ///
    /// assert!(r == Size::new(12, 21));
    /// ```
    fn mul(self, rhs:Size<T>) -> Size<T> {
        Size{width:  self.width  * rhs.width,
             height: self.height * rhs.height }
    }
}


#[derive(Debug, Clone, Copy, PartialEq)]
#[repr(C)]
/// A structure that contains the location and dimensions of a rectangle.
pub struct Rect<T> {
    /// A point that specifies the coordinates of the rectangle's origin.
    pub origin:Point<T>,
    /// A size that specifies the height and width of the rectangle.
    pub size:Size<T> }

/// A Size of `f32` types.
pub type Rectf = Rect<f32>;

/// A Rect of `i32` types.
pub type Recti = Rect<i32>;

/// Coordinates that establish the edges of a rectangle.
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum RectEdge {
    /// The minimum value for the x-coordinate of the rectangle.
    /// This is the left edge of the rectangle.
    MinX,
    /// The minimum value for the y-coordinate of the rectangle.
    /// This is the top edge of the rectangle.
    MinY,
    /// The maximum value for the x-coordinate of the rectangle.
    /// This is the right edge of the rectangle.
    MaxX,
    /// The maximum value for the y-coordinate of the rectangle.
    /// This is the bottom edge of the rectangle.
    MaxY
}

impl<T:Copy> Rect<T> {
    // Constructors

    /// Construct a new Rect from two values.
    ///
    /// ```
    /// let r = gml::Rect::new(2.0, 3.0, 4.0, 5.0);
    ///
    /// assert!(r.origin.x == 2.0);
    /// assert!(r.origin.y == 3.0);
    /// assert!(r.size.width == 4.0);
    /// assert!(r.size.height == 5.0);
    /// ```
    pub fn new(x:T, y:T, w:T, h:T ) -> Rect<T> {
        Rect{ origin: Point{x:x, y:y}, size: Size{width:w, height:h} }
    }

    /// Construct a new Rect from a point and a size.
    ///
    /// ```
    /// let p = gml::Point::new(2.0, 3.0);
    /// let s = gml::Size::new(4.0, 5.0);
    /// let r = gml::Rect::new_ps(p, s);
    ///
    /// assert!(r.origin.x == 2.0);
    /// assert!(r.origin.y == 3.0);
    /// assert!(r.size.width == 4.0);
    /// assert!(r.size.height == 5.0);
    /// ```
    pub fn new_ps(p:Point<T>, s:Size<T> ) -> Rect<T> {
        Rect{ origin: p, size: s }
    }

    /// Construct a new Rect from a Vector4.
    ///
    /// ```
    /// let v = gml::Vector4::new(2.0, 3.0, 4.0, 5.0);
    /// let r = gml::Rect::new_v4(v);
    ///
    /// assert!(r.origin.x == 2.0);
    /// assert!(r.origin.y == 3.0);
    /// assert!(r.size.width == 4.0);
    /// assert!(r.size.height == 5.0);
    /// ```
    pub fn new_v4(v:Vector4<T> ) -> Rect<T> {
        Rect{ origin: Point{x:v.x, y:v.y}, size: Size{width:v.z, height:v.w} }
    }

    /// Converts a Rect to a Vector4.
    ///
    /// ```
    /// let p = gml::Rect::new(2.0, 3.0, 4.0, 5.0);
    /// let v = p.v4_cast();
    ///
    /// assert!(v[0] == 2.0);
    /// assert!(v[1] == 3.0);
    /// assert!(v[2] == 4.0);
    /// assert!(v[3] == 5.0);
    /// ```
    pub fn v4_cast(self) -> Vector4<T> {
        Vector4{ x:self.origin.x, y:self.origin.y, z:self.size.width, w:self.size.height}
    }

    
}

impl<T:Copy + Num + Signed + PartialOrd> Rect<T> {

    /// Construct a new Rect from two corner points.
    ///
    /// ```
    /// let a = gml::Point::new(2.0, 3.0);
    /// let b = gml::Point::new(5.0, 9.0);
    /// let r = gml::Rect::new_p(a, b);
    ///
    /// assert!(r.origin.x == 2.0);
    /// assert!(r.origin.y == 3.0);
    /// assert!(r.size.width == 3.0);
    /// assert!(r.size.height == 6.0);
    /// ```
    pub fn new_p(a:Point<T>, b:Point<T> ) -> Rect<T> {
        Rect{ origin: a,
              size: Size{width:b.x - a.x, height: b.y - a.y }}.standardize()
    }

    /// Construct a new Rect from two corner points, listed by their coordinates.
    ///
    /// ```
    /// let r = gml::Rect::new_pp(2.0, 3.0, 5.0, 9.0);
    ///
    /// assert!(r.origin.x == 2.0);
    /// assert!(r.origin.y == 3.0);
    /// assert!(r.size.width == 3.0);
    /// assert!(r.size.height == 6.0);
    /// ```
    pub fn new_pp(x1:T, y1:T, x2:T, y2:T ) -> Rect<T> {
        Rect{ origin: Point{x:x1, y:y1},
              size: Size{width:x2 - x1, height: y2 - y1 }}.standardize()
    }
    
    /// Returns the minimum x value contained in a standardized Rect.
    ///
    /// ```
    /// let r = gml::Rect::new(2.0, 5.0, 12.0, 18.0);
    ///
    /// assert!(r.min_x() == 2.0);
    /// ```
    pub fn min_x(self) -> T {
        self.origin.x
    }

    /// Returns the maximum x value contained in a standardized Rect.
    ///
    /// ```
    /// let r = gml::Rect::new(2.0, 5.0, 12.0, 18.0);
    ///
    /// assert!(r.max_x() == 14.0);
    /// ```
    pub fn max_x(self) -> T {
        self.origin.x + self.size.width
    }

    /// Returns the minimum y value contained in a standardized Rect.
    ///
    /// ```
    /// let r = gml::Rect::new(2.0, 5.0, 12.0, 18.0);
    ///
    /// assert!(r.min_y() == 5.0);
    /// ```
    pub fn min_y(self) -> T {
        self.origin.y
    }

    /// Returns the maximum y value contained in a standardized Rect.
    ///
    /// ```
    /// let r = gml::Rect::new(2.0, 5.0, 12.0, 18.0);
    ///
    /// assert!(r.max_y() == 23.0);
    /// ```
    pub fn max_y(self) -> T {
        self.origin.y + self.size.height
    }

    /// Returns the minimum point of a standardized Rect.
    ///
    /// ```
    /// let r = gml::Rect::new(2.0, 5.0, 12.0, 18.0);
    /// let p = r.min();
    ///
    /// assert!(p.x == 2.0 && p.y == 5.0);
    /// ```
    pub fn min(self) -> Point<T> {
        Point{ x:self.origin.x,
               y:self.origin.y }
    }

    /// Returns the maximum point of a standardized Rect.
    ///
    /// ```
    /// let r = gml::Rect::new(2.0, 5.0, 12.0, 18.0);
    /// let p = r.max();
    ///
    /// assert!(p.x == 14.0 && p.y == 23.0);
    /// ```
    pub fn max(self) -> Point<T> {
        Point{ x:self.origin.x + self.size.width,
               y:self.origin.y + self.size.height }
    }

    /// Returns the x midpoint of a Rect.
    ///
    /// ```
    /// let r = gml::Rect::new(2.0, 5.0, 12.0, 18.0);
    ///
    /// assert!(r.mid_x() == 8.0);
    /// ```
    pub fn mid_x(self) -> T {
        let two = T::one() + T::one();
        return self.origin.x + self.size.width / two;
    }

    /// Returns the y midpoint of a Rect.
    ///
    /// ```
    /// let r = gml::Rect::new(2.0, 5.0, 12.0, 18.0);
    ///
    /// assert!(r.mid_y() == 14.0);
    /// ```
    pub fn mid_y(self) -> T {
        let two = T::one() + T::one();
        return self.origin.y + self.size.height / two;
    }

    /// Returns the midpoint of a Rect.
    ///
    /// ```
    /// let r = gml::Rect::new(2.0, 5.0, 12.0, 18.0);
    /// let p = r.mid();
    ///
    /// assert!(p.x == 8.0 && p.y == 14.0);
    /// ```
    pub fn mid(self) -> Point<T> {
        let two = T::one() + T::one();
        return Point{ x:self.origin.x + self.size.width  / two,
                      y:self.origin.y + self.size.height / two }
    }

    /// Standardizes a Rect so that width and height are positive.
    ///
    /// ```
    /// let r = gml::Rect::new(10.0, 12.0, -1.0, -5.0);
    /// let n = r.standardize();
    ///
    /// assert!(n.origin.x == 9.0);
    /// assert!(n.origin.y == 7.0);
    /// assert!(n.size.width == 1.0);
    /// assert!(n.size.height == 5.0);
    /// ```
    pub fn standardize(self) -> Rect<T> {
        let mut r = self;
        if r.size.width < T::zero() {
            r.origin.x = r.origin.x + r.size.width;
            r.size.width = -r.size.width;
        }
        if r.size.height < T::zero() {
            r.origin.y = r.origin.y + r.size.height;
            r.size.height = -r.size.height;
        }
        return r;
    }

    /// Returns true if a Rect is empty.  Empty is defined as the size
    /// being zero, irregardless of the value of the origin.
    ///
    /// ```
    /// let a = gml::Rect::new(2.0, 5.0, 0.0, 0.0);
    /// let b = gml::Rect::new(0.0, 0.0, 0.0, 0.2);
    ///
    /// assert!(a.is_empty() == true);
    /// assert!(b.is_empty() == false);
    /// ```
    pub fn is_empty(self) -> bool {
        self.size.is_zero()
    }
}


impl<T:Copy + Float + Signed> Rect<T> {

    /// Returns a null Rect.
    ///
    pub fn null() -> Rect<T> {
        Rect{ origin: Point {x: Float::max_value(), y: Float::max_value()},
              size:   Size  {width: T::zero(), height: T::zero()}}
    }

    /// Returns true if Rect is null, false otherwise.
    ///
    /// ```
    /// let a = gml::Rectf::null();
    /// let b = gml::Rectf::new(0.0, 0.0, 0.0, 0.0);
    ///
    /// assert!(a.is_null() == true);
    /// assert!(b.is_null() == false);
    /// ```
    pub fn is_null(self) -> bool {
        return
            self.origin.x == Float::max_value() &&
            self.origin.y == Float::max_value() &&
            self.size.width.is_zero() &&
            self.size.height.is_zero();
    }

    /// Returns a infinite Rect.
    ///
    pub fn infinite() -> Rect<T> {
        Rect{ origin: Point {x: Float::infinity(), y: Float::infinity()},
              size:   Size  {width: T::zero(), height: T::zero()}}
    }

    /// Returns true if Rect is infinite, false otherwise.
    ///
    /// ```
    /// let a = gml::Rectf::infinite();
    /// let b = gml::Rectf::new(0.0, 0.0, 0.0, 0.0);
    ///
    /// assert!(a.is_infinite() == true);
    /// assert!(b.is_infinite() == false);
    /// ```
    pub fn is_infinite(self) -> bool {
        return
            self.origin.x.is_infinite() ||
            self.origin.y.is_infinite() ||
            self.size.width.is_infinite() ||
            self.size.height.is_infinite();
    }
    
    /// Divides a source rectangle into two component rectangles.
    ///
    /// The argument _amount_ is the distance from the rectangle side
    /// that is specified in the _edge_ parameter.  This distance
    /// defines the line, parallel to the specified side, that is used
    /// to divide the source rectangle.
    ///
    /// The argument _edge_ is an edge value that specifies the side
    /// of the rectangle from which the distance passed in the
    /// _amount_ parameter is measured.  `divide` produces a "slice"
    /// rectangle that contains the specified edge and extends
    /// _amount_ distance beyond it.
    ///
    /// Two rectangles are returned, a _slice_ and a _remainder_.
    ///
    /// The first return value, the _slice_, is a rectangle filled in
    /// with the specified edge and values that extends the distance
    /// beyond the edge specified by the _amount_ parameter.
    ///
    /// The second return value, the _remainder_, is a rectangle
    /// containing the portion of the source rectangle that remains
    /// after `RectEdge` produces the "slice" rectangle.
    ///
    /// ```
    /// let r = gml::Rect::new(5.0, 8.0, 12.0, 20.0);
    /// let (slice,remainder) = r.divide(3.0, gml::RectEdge::MinY);
    /// println!("r={:?}", r);
    /// println!("slice={:?}", slice);
    /// println!("remainder={:?}", remainder);
    /// assert!(slice     == gml::Rect::new(5.0, 8.0, 12.0,  3.0));
    /// assert!(remainder == gml::Rect::new(5.0,11.0, 12.0, 17.0));
    /// ```
    pub fn divide(self, amount:T, edge:RectEdge) -> (Rect<T>, Rect<T>) {

	let rect = self.standardize();
        let mut slice = rect;
        let mut remainder = Rect::new(T::zero(), T::zero(), T::zero(), T::zero());

	if ((edge == RectEdge::MinX || edge == RectEdge::MaxX) && amount > rect.size.width ) ||
	   ((edge == RectEdge::MinY || edge == RectEdge::MaxY) && amount > rect.size.height) {
	    return (slice, remainder);
	}

	match edge {
	    RectEdge::MinX => {
		slice.origin.x = rect.origin.x;
		slice.origin.y = rect.origin.y;
		slice.size.width  = amount;
		slice.size.height = rect.size.height;

		remainder.origin.x = rect.origin.x + amount;
		remainder.origin.y = rect.origin.y;
		remainder.size.width  = rect.size.width - amount;
		remainder.size.height = rect.size.height;
            }
	    RectEdge::MinY => {
		slice.origin.x = rect.origin.x;
		slice.origin.y = rect.origin.y;
		slice.size.width  = rect.size.width;
		slice.size.height = amount;

		remainder.origin.x = rect.origin.x;
		remainder.origin.y = rect.origin.y + amount;
		remainder.size.width  = rect.size.width;
		remainder.size.height = rect.size.height - amount;
            }
	    RectEdge::MaxX => {
		slice.origin.x = rect.origin.x + rect.size.width - amount;
		slice.origin.y = rect.origin.y;
		slice.size.width  = amount;
		slice.size.height = rect.size.height;

		remainder.origin.x = rect.origin.x;
		remainder.origin.y = rect.origin.y;
		remainder.size.width = rect.size.width - amount;
		remainder.size.height = rect.size.height;
            }
	    RectEdge::MaxY => {
		slice.origin.x = rect.origin.x;
		slice.origin.y = rect.origin.y + rect.size.height - amount;
		slice.size.width  = rect.size.width;
		slice.size.height = amount;

		remainder.origin.x = rect.origin.x;
		remainder.origin.y = rect.origin.y;
		remainder.size.width = rect.size.width;
		remainder.size.height = rect.size.height - amount;
            }
	}
        return (slice, remainder);
    }

    /// Returns a rectangle that is smaller or larger than the source rectangle,
    /// with the same center point.  The origin value is offset in the x-axis by the
    /// distance specified by the _dx_ argument and in the y-axis by the distance specified
    /// in the _dy_ argument, and its size adjusted by `(2*dx, 2*dy)`, relative to the
    /// source rectangle.  If _dx_ and _dy_ are positive values, then the rectangle's size
    /// is decreased.  If _dx_ and _dy_ are negative values, the rectangle's size is
    /// increased.
    ///
    /// The rectangle is standardized and then the inset parameters are applied.  If the
    /// resulting rectangle would have a negative height or width, a null rectangle is
    /// returned.
    ///
    /// ```
    /// let a = gml::Rect::new(5.0, 6.0, 10.0, 12.0);
    /// let b = a.inset(2.0, -4.0);
    /// let c = a.inset(6.0, 3.0);
    ///
    /// assert!(b == gml::Rect::new(3.0, 10.0, 6.0, 20.0));
    /// assert!(c.is_null());
    /// ```
    pub fn inset(self, dx:T, dy:T) -> Rect<T> {
        let mut r = self.standardize();
        r.origin.x    = r.origin.x - dx;
        r.origin.y    = r.origin.y - dy;
        r.size.width  = r.size.width  - dx * T::from(2).unwrap();
        r.size.height = r.size.height - dy * T::from(2).unwrap();
        
        if r.size.width < T::zero() || r.size.height < T::zero() {
            return Rect::null();
        }
        return r;
    }

    /// Returns the smallest rectangle that results from converting the source rectangle
    /// values to integers.  Given a rectangle with fractional origin or size values,
    /// `integral` rounds the rectangle's origin downward and its size upward to the
    /// nearest whole integers, such that the result contains the original rectangle.
    /// Returns a null rectangle if `self` is a null rectangle.
    ///
    /// ```
    /// let a = gml::Rect::new_pp(3.1, 5.9, 11.8, 14.2);
    /// let r = a.integral();
    ///
    /// let e = gml::Rect::new_pp(3.0, 5.0, 12.0, 15.0);
    /// assert!(r == e);
    /// ```
    pub fn integral(self) -> Rect<T> {
        let r = self.standardize();
        Rect::new_pp(r.min_x().floor(), r.min_y().floor(),
                     r.max_x().ceil() , r.max_y().ceil()  )
    }

    /// Returns the intersection of two rectangles.  If the two rectangles do not intersect,
    /// the null rectangle is returned.  Both rectangles are standardized prior to calculating
    /// the intersection.
    ///
    /// ```
    /// let a = gml::Rect::new_pp(3.0, 5.0, 11.0, 16.0);
    /// let b = gml::Rect::new_pp(4.0, 7.0, 15.0, 14.0);
    /// let c = gml::Rect::new_pp(23.0, 43.0, 98.0, 78.0);
    /// let r = a.intersection(b);
    /// let x = a.intersection(c);
    ///
    /// let e = gml::Rect::new_pp(4.0, 7.0, 11.0, 14.0);
    /// assert!(r == e);
    /// assert!(x.is_null());
    /// ```
    pub fn intersection(self, other:Rect<T>) -> Rect<T> {
        let r1 = self.standardize();
        let r2 = other.standardize();

        let x0 = r1.min_x().max(r2.min_x());
        let x1 = r1.max_x().min(r2.max_x());

        if x0 < x1 {
            let y0 = r1.min_y().max(r2.min_y());
            let y1 = r1.max_y().min(r2.max_y());
            if y0 < y1 {
                return Rect::new(x0, y0, x1 - x0, y1 - y0);
            }
        }
        return Rect::null();
    }

    /// Returns a rectangle with an origin that is offset from that of the source rectangle.
    ///
    /// ```
    /// let a = gml::Rect::new(3.0, 5.0, 11.0, 16.0);
    /// let r = a.offset(-5.0, 8.0);
    ///
    /// let e = gml::Rect::new(-2.0, 13.0, 11.0, 16.0);
    /// assert!(r == e);
    /// ```
    pub fn offset(self, dx:T, dy:T) -> Rect<T> {
        Rect::new(self.origin.x + dx,
                  self.origin.y + dy,
                  self.size.width,
                  self.size.height)
    }

    /// Returns the smallest rectangle that contains the two source rectangles.
    ///
    /// ```
    /// let a = gml::Rect::new_pp(3.0, 5.0, 11.0, 16.0);
    /// let b = gml::Rect::new_pp(2.0, 6.0, 13.0, 14.0);
    /// let r = a.union(b);
    ///
    /// let e = gml::Rect::new_pp(3.0, 6.0, 11.0, 14.0);
    /// assert!(r == e);
    /// ```
    pub fn union(self, other:Rect<T>) -> Rect<T> {
        if self.is_null() { return other; }
        if other.is_null() { return self; }

        let r1 = self.standardize();
        let r2 = other.standardize();

        let x1 = r1.min_x().max(r2.min_x());
        let y1 = r1.min_y().max(r2.min_y());

        let x2 = r1.max_x().min(r2.max_x());
        let y2 = r1.max_y().min(r2.max_y());

        return Rect::new_pp(x1, y1, x2, y2);
    }

    /// Returns true if a rectangle contains a specified point, otherwise false.
    ///
    /// ```
    /// let a  = gml::Rect::new_pp(3.0, 5.0, 11.0, 16.0);
    /// let p1 = gml::Point::new(4.0, 7.0);
    /// let p2 = gml::Point::new(3.0, 5.0);
    /// let p3 = gml::Point::new(11.0, 16.0);
    /// let p4 = gml::Point::new(23.0, 98.0);
    ///
    /// assert!(a.contains_point(p1) == true);
    /// assert!(a.contains_point(p2) == true);
    /// assert!(a.contains_point(p3) == false);
    /// assert!(a.contains_point(p4) == false);
    /// ```
    pub fn contains_point(self, p:Point<T>) -> bool {
        let r = self.standardize();
        return
            p.x >= r.min_x() &&
            p.y >= r.min_y() &&
            p.x <  r.max_x() &&
            p.y <  r.max_y();
    }

    /// Returns whether the first rectangle contains the second rectangle.
    ///
    /// ```
    /// let a = gml::Rect::new_pp(3.0, 5.0, 11.0, 16.0);
    /// let b = gml::Rect::new_pp(4.0, 7.0, 9.0, 14.0);
    /// let c = gml::Rect::new_pp(10.0, 12.0, 18.0, 42.0);
    ///
    /// assert!(a.contains_rect(b) == true);
    /// assert!(a.contains_rect(c) == false);
    /// ```
    pub fn contains_rect(self, other:Rect<T>) -> bool {
        let r1 = self.standardize();
        let r2 = other.standardize();
        let a = r2.min_x() >= r1.min_x();
        let b = r2.max_x() <= r1.max_x();
        let c = r2.min_y() >= r1.min_y();
        let d = r2.max_y() <= r1.max_y();
        return a && b && c && d;
    }

    /// Returns true if the two rectangles intersect, false otherwise.
    ///
    /// ```
    /// let a = gml::Rect::new_pp(3.0, 5.0, 11.0, 16.0);
    /// let b = gml::Rect::new_pp(1.0, 2.0, 7.0, 14.0);
    /// let c = gml::Rect::new_pp(12.0, 17.0, 18.0, 42.0);
    ///
    /// assert!(a.intersects_rect(b) == true);
    /// assert!(a.intersects_rect(c) == false);
    /// ```
    pub fn intersects_rect(self, other:Rect<T>) -> bool {
        let r1 = self.standardize();
        let r2 = other.standardize();
        let outside = ( r1.max_x() <= r2.min_x() || r1.max_x() <= r2.min_x() ) ||
                      ( r1.max_y() <= r2.min_y() || r1.max_y() <= r2.min_y() );
        return !outside;
    }
}