[][src]Struct sdl2::rect::Rect

pub struct Rect { /* fields omitted */ }

A (non-empty) rectangle.

The width and height of a Rect must always be strictly positive (never zero). In cases where empty rects may need to represented, it is recommended to use Option<Rect>, with None representing an empty rectangle (see, for example, the output of the intersection method).

Methods

impl Rect[src]

pub fn new(x: i32, y: i32, width: u32, height: u32) -> Rect[src]

Creates a new rectangle from the given values.

The width and height are clamped to ensure that the right and bottom sides of the rectangle does not exceed i32::max_value() (the value 2147483647, the maximal positive size of an i32). This means that the rect size will behave oddly if you move it very far to the right or downwards on the screen.

Rects must always be non-empty, so a width and/or height argument of 0 will be replaced with 1.

pub fn from_center<P>(center: P, width: u32, height: u32) -> Rect where
    P: Into<Point>, 
[src]

Creates a new rectangle centered on the given position.

The width and height are clamped to ensure that the right and bottom sides of the rectangle does not exceed i32::max_value() (the value 2147483647, the maximal positive size of an i32). This means that the rect size will behave oddly if you move it very far to the right or downwards on the screen.

Rects must always be non-empty, so a width and/or height argument of 0 will be replaced with 1.

pub fn x(&self) -> i32[src]

The horizontal position of this rectangle.

pub fn y(&self) -> i32[src]

The vertical position of this rectangle.

pub fn width(&self) -> u32[src]

The width of this rectangle.

pub fn height(&self) -> u32[src]

The height of this rectangle.

pub fn size(&self) -> (u32, u32)[src]

Returns the width and height of this rectangle.

pub fn set_x(&mut self, x: i32)[src]

Sets the horizontal position of this rectangle to the given value, clamped to be less than or equal to i32::max_value() / 2.

pub fn set_y(&mut self, y: i32)[src]

Sets the vertical position of this rectangle to the given value, clamped to be less than or equal to i32::max_value() / 2.

pub fn set_width(&mut self, width: u32)[src]

Sets the width of this rectangle to the given value, clamped to be less than or equal to i32::max_value() / 2.

Rects must always be non-empty, so a width argument of 0 will be replaced with 1.

pub fn set_height(&mut self, height: u32)[src]

Sets the height of this rectangle to the given value, clamped to be less than or equal to i32::max_value() / 2.

Rects must always be non-empty, so a height argument of 0 will be replaced with 1.

pub fn left(&self) -> i32[src]

Returns the x-position of the left side of this rectangle.

pub fn right(&self) -> i32[src]

Returns the x-position of the right side of this rectangle.

pub fn top(&self) -> i32[src]

Returns the y-position of the top side of this rectangle.

pub fn bottom(&self) -> i32[src]

Returns the y-position of the bottom side of this rectangle.

pub fn center(&self) -> Point[src]

Returns the center position of this rectangle.

Note that if the width or height is not a multiple of two, the center will be rounded down.

Example

use sdl2::rect::{Rect,Point};
let rect = Rect::new(1,0,2,3);
assert_eq!(Point::new(2,1),rect.center());

pub fn top_left(&self) -> Point[src]

Returns the top-left corner of this rectangle.

Example

use sdl2::rect::{Rect, Point};
let rect = Rect::new(1, 0, 2, 3);
assert_eq!(Point::new(1, 0), rect.top_left());

pub fn top_right(&self) -> Point[src]

Returns the top-right corner of this rectangle.

Example

use sdl2::rect::{Rect, Point};
let rect = Rect::new(1, 0, 2, 3);
assert_eq!(Point::new(3, 0), rect.top_right());

pub fn bottom_left(&self) -> Point[src]

Returns the bottom-left corner of this rectangle.

Example

use sdl2::rect::{Rect, Point};
let rect = Rect::new(1, 0, 2, 3);
assert_eq!(Point::new(1, 3), rect.bottom_left());

pub fn bottom_right(&self) -> Point[src]

Returns the bottom-right corner of this rectangle.

Example

use sdl2::rect::{Rect, Point};
let rect = Rect::new(1, 0, 2, 3);
assert_eq!(Point::new(3, 3), rect.bottom_right());

pub fn set_right(&mut self, right: i32)[src]

Sets the position of the right side of this rectangle to the given value, clamped to be less than or equal to i32::max_value() / 2.

pub fn set_bottom(&mut self, bottom: i32)[src]

Sets the position of the bottom side of this rectangle to the given value, clamped to be less than or equal to i32::max_value() / 2.

pub fn center_on<P>(&mut self, point: P) where
    P: Into<(i32, i32)>, 
[src]

Centers the rectangle on the given point.

pub fn offset(&mut self, x: i32, y: i32)[src]

Move this rect and clamp the positions to prevent over/underflow. This also clamps the size to prevent overflow.

pub fn reposition<P>(&mut self, point: P) where
    P: Into<(i32, i32)>, 
[src]

Moves this rect to the given position after clamping the values.

pub fn resize(&mut self, width: u32, height: u32)[src]

Resizes this rect to the given size after clamping the values.

pub fn contains<P>(&self, point: P) -> bool where
    P: Into<(i32, i32)>, 
[src]

Deprecated since 0.30.0:

use contains_point instead

Checks whether this rect contains a given point, or touches it on the right and/or bottom edges. This method is deprecated in favor of Rect::contains_point.

For historical reasons, this method differs in behavior from SDL_PointInRect by including points along the bottom and right edges of the rectangle, so that a 1-by-1 rectangle actually covers an area of four points, not one.

Examples

use sdl2::rect::{Rect, Point};
let rect = Rect::new(1, 2, 3, 4);
assert!(rect.contains(Point::new(1, 2)));
assert!(!rect.contains(Point::new(0, 1)));
assert!(rect.contains(Point::new(3, 5)));
assert!(rect.contains(Point::new(4, 6)));  // N.B.
assert!(!rect.contains(Point::new(5, 7)));

pub fn contains_point<P>(&self, point: P) -> bool where
    P: Into<(i32, i32)>, 
[src]

Checks whether this rectangle contains a given point.

Points along the right and bottom edges are not considered to be inside the rectangle; this way, a 1-by-1 rectangle contains only a single point. Another way to look at it is that this method returns true if and only if the given point would be painted by a call to Renderer::fill_rect.

Examples

use sdl2::rect::{Rect, Point};
let rect = Rect::new(1, 2, 3, 4);
assert!(rect.contains_point(Point::new(1, 2)));
assert!(!rect.contains_point(Point::new(0, 1)));
assert!(rect.contains_point(Point::new(3, 5)));
assert!(!rect.contains_point(Point::new(4, 6)));

pub fn contains_rect(&self, other: Rect) -> bool[src]

Checks whether this rectangle completely contains another rectangle.

This method returns true if and only if every point contained by other is also contained by self; in other words, if the intersection of self and other is equal to other.

Examples

use sdl2::rect::Rect;
let rect = Rect::new(1, 2, 3, 4);
assert!(rect.contains_rect(rect));
assert!(rect.contains_rect(Rect::new(3, 3, 1, 1)));
assert!(!rect.contains_rect(Rect::new(2, 1, 1, 1)));
assert!(!rect.contains_rect(Rect::new(3, 3, 2, 1)));

pub fn raw(&self) -> *const SDL_Rect[src]

Returns the underlying C Rect.

pub fn raw_mut(&mut self) -> *mut SDL_Rect[src]

pub fn raw_slice(slice: &[Rect]) -> *const SDL_Rect[src]

pub fn from_ll(raw: SDL_Rect) -> Rect[src]

pub fn from_enclose_points<R: Into<Option<Rect>>>(
    points: &[Point],
    clipping_rect: R
) -> Option<Rect> where
    R: Into<Option<Rect>>, 
[src]

Calculate a minimal rectangle enclosing a set of points. If a clipping rectangle is given, only points that are within it will be considered.

pub fn has_intersection(&self, other: Rect) -> bool[src]

Determines whether two rectangles intersect.

Rectangles that share an edge but don't actually overlap are not considered to intersect.

Examples

use sdl2::rect::Rect;
let rect = Rect::new(0, 0, 5, 5);
assert!(rect.has_intersection(rect));
assert!(rect.has_intersection(Rect::new(2, 2, 5, 5)));
assert!(!rect.has_intersection(Rect::new(5, 0, 5, 5)));

pub fn intersection(&self, other: Rect) -> Option<Rect>[src]

Calculates the intersection of two rectangles.

Returns None if the two rectangles don't intersect. Rectangles that share an edge but don't actually overlap are not considered to intersect.

The bitwise AND operator & can also be used.

Examples

use sdl2::rect::Rect;
let rect = Rect::new(0, 0, 5, 5);
assert_eq!(rect.intersection(rect), Some(rect));
assert_eq!(rect.intersection(Rect::new(2, 2, 5, 5)),
           Some(Rect::new(2, 2, 3, 3)));
assert_eq!(rect.intersection(Rect::new(5, 0, 5, 5)), None);

pub fn union(&self, other: Rect) -> Rect[src]

Calculates the union of two rectangles (i.e. the smallest rectangle that contains both).

The bitwise OR operator | can also be used.

Examples

use sdl2::rect::Rect;
let rect = Rect::new(0, 0, 5, 5);
assert_eq!(rect.union(rect), rect);
assert_eq!(rect.union(Rect::new(2, 2, 5, 5)), Rect::new(0, 0, 7, 7));
assert_eq!(rect.union(Rect::new(5, 0, 5, 5)), Rect::new(0, 0, 10, 5));

pub fn intersect_line(&self, start: Point, end: Point) -> Option<(Point, Point)>[src]

Calculates the intersection of a rectangle and a line segment and returns the points of their intersection.

Trait Implementations

impl Eq for Rect[src]

impl Into<SDL_Rect> for Rect[src]

impl Into<(i32, i32, u32, u32)> for Rect[src]

impl Clone for Rect[src]

impl AsMut<SDL_Rect> for Rect[src]

impl AsRef<SDL_Rect> for Rect[src]

impl PartialEq<Rect> for Rect[src]

impl From<SDL_Rect> for Rect[src]

impl From<(i32, i32, u32, u32)> for Rect[src]

impl Copy for Rect[src]

impl Deref for Rect[src]

type Target = SDL_Rect

The resulting type after dereferencing.

fn deref(&self) -> &SDL_Rect[src]

Example

use sdl2::rect::Rect;
let rect = Rect::new(2, 3, 4, 5);
assert_eq!(2, rect.x);

impl DerefMut for Rect[src]

fn deref_mut(&mut self) -> &mut SDL_Rect[src]

Example

use sdl2::rect::Rect;
let mut rect = Rect::new(2, 3, 4, 5);
rect.x = 60;
assert_eq!(60, rect.x);

impl Hash for Rect[src]

impl BitAnd<Rect> for Rect[src]

type Output = Option<Rect>

The resulting type after applying the & operator.

impl BitOr<Rect> for Rect[src]

type Output = Rect

The resulting type after applying the | operator.

impl Debug for Rect[src]

Auto Trait Implementations

impl Send for Rect

impl Unpin for Rect

impl Sync for Rect

impl RefUnwindSafe for Rect

impl UnwindSafe for Rect

Blanket Implementations

impl<T, U> Into<U> for T where
    U: From<T>, 
[src]

impl<T> ToOwned for T where
    T: Clone
[src]

type Owned = T

The resulting type after obtaining ownership.

impl<T> From<T> for T[src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, 
[src]

type Error = Infallible

The type returned in the event of a conversion error.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, 
[src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

impl<T> BorrowMut<T> for T where
    T: ?Sized
[src]

impl<T> Borrow<T> for T where
    T: ?Sized
[src]

impl<T> Any for T where
    T: 'static + ?Sized
[src]