Struct nannou::ui::Range

pub struct Range {
    pub start: f64,
    pub end: f64,
}

Some start and end position along a single axis.

As an example, a Rect is made up of two Ranges; one along the x axis, and one along the y axis.

Fields

start: f64

The start of some Range along an axis.

end: f64

The end of some Range along an axis.

Methods

impl Range

pub fn new(start: f64, end: f64) -> Range

Construct a new Range from a given range, i.e. Range::new(start, end).

Examples

use conrod::Range;

assert_eq!(Range { start: 0.0, end: 10.0 }, Range::new(0.0, 10.0));

pub fn from_pos_and_len(pos: f64, len: f64) -> Range

Construct a new Range from a given length and its centered position.

Examples

use conrod::Range;

assert_eq!(Range::new(0.0, 10.0), Range::from_pos_and_len(5.0, 10.0));
assert_eq!(Range::new(-5.0, 1.0), Range::from_pos_and_len(-2.0, 6.0));
assert_eq!(Range::new(-100.0, 200.0), Range::from_pos_and_len(50.0, 300.0));

pub fn magnitude(&self) -> f64

The start value subtracted from the end value.

Examples

use conrod::Range;

assert_eq!(Range::new(-5.0, 5.0).magnitude(), 10.0);
assert_eq!(Range::new(5.0, -5.0).magnitude(), -10.0);
assert_eq!(Range::new(15.0, 10.0).magnitude(), -5.0);

pub fn len(&self) -> f64

The absolute length of the Range aka the absolute magnitude.

Examples

use conrod::Range;

assert_eq!(Range::new(-5.0, 5.0).len(), 10.0);
assert_eq!(Range::new(5.0, -5.0).len(), 10.0);
assert_eq!(Range::new(15.0, 10.0).len(), 5.0);

pub fn middle(&self) -> f64

Return the value directly between the start and end values.

Examples

use conrod::Range;

assert_eq!(Range::new(-5.0, 5.0).middle(), 0.0);
assert_eq!(Range::new(5.0, -5.0).middle(), 0.0);
assert_eq!(Range::new(10.0, 15.0).middle(), 12.5);
assert_eq!(Range::new(20.0, 40.0).middle(), 30.0);
assert_eq!(Range::new(20.0, -40.0).middle(), -10.0);

pub fn invert(self) -> Range

The current range with its start and end values swapped.

Examples

use conrod::Range;

assert_eq!(Range::new(-5.0, 5.0).invert(), Range::new(5.0, -5.0));
assert_eq!(Range::new(-10.0, 10.0).invert(), Range::new(10.0, -10.0));
assert_eq!(Range::new(0.0, 7.25).invert(), Range::new(7.25, 0.0));
assert_eq!(Range::new(5.0, 1.0).invert(), Range::new(1.0, 5.0));

pub fn map_value_to(&self, value: f64, other: &Range) -> f64

Map the given Scalar from Self to some other given Range.

Examples

use conrod::Range;

let a = Range::new(0.0, 5.0);

let b = Range::new(0.0, 10.0);
assert_eq!(a.map_value_to(2.5, &b), 5.0);
assert_eq!(a.map_value_to(0.0, &b), 0.0);
assert_eq!(a.map_value_to(5.0, &b), 10.0);
assert_eq!(a.map_value_to(-5.0, &b), -10.0);
assert_eq!(a.map_value_to(10.0, &b), 20.0);

let c = Range::new(10.0, -10.0);
assert_eq!(a.map_value_to(2.5, &c), 0.0);
assert_eq!(a.map_value_to(0.0, &c), 10.0);
assert_eq!(a.map_value_to(5.0, &c), -10.0);
assert_eq!(a.map_value_to(-5.0, &c), 30.0);
assert_eq!(a.map_value_to(10.0, &c), -30.0);

pub fn shift(self, amount: f64) -> Range

Shift the Range start and end points by a given Scalar.

Examples

use conrod::Range;

assert_eq!(Range::new(0.0, 5.0).shift(5.0), Range::new(5.0, 10.0));
assert_eq!(Range::new(0.0, 5.0).shift(-5.0), Range::new(-5.0, 0.0));
assert_eq!(Range::new(5.0, -5.0).shift(-5.0), Range::new(0.0, -10.0));

pub fn direction(&self) -> f64

The direction of the Range represented as a normalised scalar.

Examples

use conrod::Range;

assert_eq!(Range::new(0.0, 5.0).direction(), 1.0);
assert_eq!(Range::new(0.0, 0.0).direction(), 0.0);
assert_eq!(Range::new(0.0, -5.0).direction(), -1.0);

pub fn undirected(self) -> Range

Converts the Range to an undirected Range. By ensuring that start <= end.

If start > end, then the start and end points will be swapped.

Examples

use conrod::Range;

assert_eq!(Range::new(0.0, 5.0).undirected(), Range::new(0.0, 5.0));
assert_eq!(Range::new(5.0, 1.0).undirected(), Range::new(1.0, 5.0));
assert_eq!(Range::new(10.0, -10.0).undirected(), Range::new(-10.0, 10.0));

pub fn max(self, other: Range) -> Range

The Range that encompasses both self and the given Range.

The returned Range's start will always be <= its end.

Examples

use conrod::Range;

let a = Range::new(0.0, 3.0);
let b = Range::new(7.0, 10.0);
assert_eq!(a.max(b), Range::new(0.0, 10.0));

let c = Range::new(-20.0, -30.0);
let d = Range::new(5.0, -7.5);
assert_eq!(c.max(d), Range::new(-30.0, 5.0));

pub fn overlap(self, other: Range) -> Option<Range>

The Range that represents the range of the overlap between two Ranges if there is some.

Note that If one end of self aligns exactly with the opposite end of other, Some Range will be returned with a magnitude of 0.0. This is useful for algorithms that involve calculating the visibility of widgets, as it allows for including widgets whose bounding box may be a one dimensional straight line.

The returned Range's start will always be <= its end.

Examples

use conrod::Range;

let a = Range::new(0.0, 6.0);
let b = Range::new(4.0, 10.0);
assert_eq!(a.overlap(b), Some(Range::new(4.0, 6.0)));

let c = Range::new(10.0, -30.0);
let d = Range::new(-5.0, 20.0);
assert_eq!(c.overlap(d), Some(Range::new(-5.0, 10.0)));
 
let e = Range::new(0.0, 2.5);
let f = Range::new(50.0, 100.0);
assert_eq!(e.overlap(f), None);

pub fn max_directed(self, other: Range) -> Range

The Range that encompasses both self and the given Range.

The same as Range::max but retains self's original direction.

Examples

use conrod::Range;

let a = Range::new(0.0, 3.0);
let b = Range::new(7.0, 10.0);
assert_eq!(a.max_directed(b), Range::new(0.0, 10.0));

let c = Range::new(-20.0, -30.0);
let d = Range::new(5.0, -7.5);
assert_eq!(c.max_directed(d), Range::new(5.0, -30.0));

pub fn is_over(&self, pos: f64) -> bool

Is the given scalar within our range.

Examples

use conrod::Range;

let range = Range::new(0.0, 10.0);
assert!(range.is_over(5.0));
assert!(!range.is_over(12.0));
assert!(!range.is_over(-1.0));
assert!(range.is_over(0.0));
assert!(range.is_over(10.0));

pub fn round(self) -> Range

Round the values at both ends of the Range and return the result.

Examples

use conrod::Range;

assert_eq!(Range::new(0.25, 9.5).round(), Range::new(0.0, 10.0));
assert_eq!(Range::new(4.95, -5.3).round(), Range::new(5.0, -5.0));

pub fn floor(self) -> Range

Floor the values at both ends of the Range and return the result.

Examples

use conrod::Range;

assert_eq!(Range::new(0.25, 9.5).floor(), Range::new(0.0, 9.0));
assert_eq!(Range::new(4.95, -5.3).floor(), Range::new(4.0, -6.0));

pub fn pad_start(self, pad: f64) -> Range

The Range with some padding given to the start value.

Examples

use conrod::Range;

assert_eq!(Range::new(0.0, 10.0).pad_start(2.0), Range::new(2.0, 10.0));
assert_eq!(Range::new(10.0, 0.0).pad_start(2.0), Range::new(8.0, 0.0));

pub fn pad_end(self, pad: f64) -> Range

The Range with some padding given to the end value.

Examples

use conrod::Range;

assert_eq!(Range::new(0.0, 10.0).pad_end(2.0), Range::new(0.0, 8.0));
assert_eq!(Range::new(10.0, 0.0).pad_end(2.0), Range::new(10.0, 2.0));

pub fn pad(self, pad: f64) -> Range

The Range with some given padding to be applied to each end.

Examples

use conrod::Range;

assert_eq!(Range::new(0.0, 10.0).pad(2.0), Range::new(2.0, 8.0));
assert_eq!(Range::new(10.0, 0.0).pad(2.0), Range::new(8.0, 2.0));

pub fn pad_ends(self, start: f64, end: f64) -> Range

The Range with some padding given for each end.

Examples

use conrod::Range;

assert_eq!(Range::new(0.0, 10.0).pad_ends(1.0, 2.0), Range::new(1.0, 8.0));
assert_eq!(Range::new(10.0, 0.0).pad_ends(4.0, 3.0), Range::new(6.0, 3.0));

pub fn clamp_value(&self, value: f64) -> f64

Clamp the given value to the range.

Examples

use conrod::Range;

assert_eq!(Range::new(0.0, 5.0).clamp_value(7.0), 5.0);
assert_eq!(Range::new(5.0, -2.5).clamp_value(-3.0), -2.5);
assert_eq!(Range::new(5.0, 10.0).clamp_value(0.0), 5.0);

pub fn stretch_to_value(self, value: f64) -> Range

Stretch the end that is closest to the given value only if it lies outside the Range.

The resulting Range will retain the direction of the original range.

Examples

use conrod::Range;

let a = Range::new(2.5, 5.0);
assert_eq!(a.stretch_to_value(10.0), Range::new(2.5, 10.0));
assert_eq!(a.stretch_to_value(0.0), Range::new(0.0, 5.0));

let b = Range::new(0.0, -5.0);
assert_eq!(b.stretch_to_value(10.0), Range::new(10.0, -5.0));
assert_eq!(b.stretch_to_value(-10.0), Range::new(0.0, -10.0));

pub fn has_same_direction(self, other: Range) -> bool

Does self have the same direction as other.

Examples

use conrod::Range;

assert!(Range::new(0.0, 1.0).has_same_direction(Range::new(100.0, 200.0)));
assert!(Range::new(0.0, -5.0).has_same_direction(Range::new(-2.5, -6.0)));
assert!(!Range::new(0.0, 5.0).has_same_direction(Range::new(2.5, -2.5)));

pub fn align_start_of(self, other: Range) -> Range

Align the start of self to the start of the other Range.

If the direction of other is different to self, self's end will be aligned to the start of other instead.

Examples

use conrod::Range;

let a = Range::new(2.5, 7.5);
let b = Range::new(0.0, 10.0);
assert_eq!(a.align_start_of(b), Range::new(0.0, 5.0));
assert_eq!(b.align_start_of(a), Range::new(2.5, 12.5));

let c = Range::new(2.5, -2.5);
let d = Range::new(-5.0, 5.0);
assert_eq!(c.align_start_of(d), Range::new(0.0, -5.0));
assert_eq!(d.align_start_of(c), Range::new(-7.5, 2.5));

pub fn align_end_of(self, other: Range) -> Range

Align the end of self to the end of the other Range.

If the direction of other is different to self, self's start will be aligned to the end of other instead.

Examples

use conrod::Range;

let a = Range::new(2.5, 7.5);
let b = Range::new(0.0, 10.0);
assert_eq!(a.align_end_of(b), Range::new(5.0, 10.0));
assert_eq!(b.align_end_of(a), Range::new(-2.5, 7.5));

let c = Range::new(2.5, -2.5);
let d = Range::new(-5.0, 5.0);
assert_eq!(c.align_end_of(d), Range::new(5.0, 0.0));
assert_eq!(d.align_end_of(c), Range::new(-2.5, 7.5));

pub fn align_middle_of(self, other: Range) -> Range

Align the middle of self to the middle of the other Range.

Examples

use conrod::Range;

let a = Range::new(0.0, 5.0);
let b = Range::new(0.0, 10.0);
assert_eq!(a.align_middle_of(b), Range::new(2.5, 7.5));
assert_eq!(b.align_middle_of(a), Range::new(-2.5, 7.5));

let c = Range::new(2.5, -2.5);
let d = Range::new(-10.0, 0.0);
assert_eq!(c.align_middle_of(d), Range::new(-2.5, -7.5));
assert_eq!(d.align_middle_of(c), Range::new(-5.0, 5.0));

pub fn align_after(self, other: Range) -> Range

Aligns the start of self with the end of other.

If the directions are opposite, aligns the end of self with the end of other.

Examples

use conrod::Range;

let a = Range::new(2.5, 7.5);
let b = Range::new(0.0, 10.0);
assert_eq!(a.align_after(b), Range::new(10.0, 15.0));
assert_eq!(b.align_after(a), Range::new(7.5, 17.5));

let c = Range::new(2.5, -2.5);
let d = Range::new(-5.0, 5.0);
assert_eq!(c.align_after(d), Range::new(10.0, 5.0));
assert_eq!(d.align_after(c), Range::new(-12.5, -2.5));

pub fn align_before(self, other: Range) -> Range

Aligns the end of self with the start of other.

If the directions are opposite, aligns the start of self with the start of other.

Examples

use conrod::Range;

let a = Range::new(2.5, 7.5);
let b = Range::new(0.0, 10.0);
assert_eq!(a.align_before(b), Range::new(-5.0, 0.0));
assert_eq!(b.align_before(a), Range::new(-7.5, 2.5));

let c = Range::new(2.5, -2.5);
let d = Range::new(-5.0, 5.0);
assert_eq!(c.align_before(d), Range::new(-5.0, -10.0));
assert_eq!(d.align_before(c), Range::new(2.5, 12.5));

pub fn align_to(self, align: Align, other: Range) -> Range

Align self to other along the x axis in accordance with the given Align variant.

pub fn closest_edge(&self, scalar: f64) -> Edge

The closest Edge of self to the given scalar.

Returns Start if the distance between both Edges is equal.

Examples

use conrod::position::{Edge, Range};

assert_eq!(Range::new(0.0, 10.0).closest_edge(4.0), Edge::Start);
assert_eq!(Range::new(0.0, 10.0).closest_edge(7.0), Edge::End);
assert_eq!(Range::new(0.0, 10.0).closest_edge(5.0), Edge::Start);

Trait Implementations

impl Clone for Range

fn clone(&self) -> Range

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Range

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

Formats the value using the given formatter.

impl Copy for Range

impl PartialEq<Range> for Range

fn eq(&self, other: &Range) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Range) -> bool

This method tests for !=.