Struct Factor2d

pub struct Factor2d {
    pub x: Factor,
    pub y: Factor,
}

Scale factor applied to x and y dimensions.

Fields

x: Factor

Scale factor applied in the x dimension.

y: Factor

Scale factor applied in the y dimension.

Implementations

impl Factor2d

pub fn new(x: impl Into<Factor>, y: impl Into<Factor>) -> Factor2d

New scale with different scales for each dimension.

pub fn uniform(xy: impl Into<Factor>) -> Factor2d

Uniform scale applied to both x and y.

pub fn identity() -> Factor2d

No scaling.

pub fn is_uniform(self) -> bool

If the scale is the same for both x and y.

pub fn abs(self) -> Factor2d

Computes the absolute value of x and y.

pub fn yx(self) -> Factor2d

Swap x and y.

Trait Implementations

impl Clone for Factor2d

fn clone(&self) -> Factor2d

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Factor2d

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

Formats the value using the given formatter.

impl Display for Factor2d

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

Formats the value using the given formatter.

impl Div<Factor> for Factor2d

type Output = Factor2d

The resulting type after applying the / operator.

fn div(self, rhs: Factor) -> Factor2d

Performs the / operation.

impl Div<Factor2d> for Point2D<Dip, Dip>

type Output = Point2D<Dip, Dip>

The resulting type after applying the / operator.

fn div(self, rhs: Factor2d) -> Point2D<Dip, Dip>

Performs the / operation.

impl Div<Factor2d> for Point2D<Px, Px>

type Output = Point2D<Px, Px>

The resulting type after applying the / operator.

fn div(self, rhs: Factor2d) -> Point2D<Px, Px>

Performs the / operation.

impl Div<Factor2d> for Rect<Dip, Dip>

type Output = Rect<Dip, Dip>

The resulting type after applying the / operator.

fn div(self, rhs: Factor2d) -> Rect<Dip, Dip>

Performs the / operation.

impl Div<Factor2d> for Rect<Px, Px>

type Output = Rect<Px, Px>

The resulting type after applying the / operator.

fn div(self, rhs: Factor2d) -> Rect<Px, Px>

Performs the / operation.

impl Div<Factor2d> for Size2D<Dip, Dip>

type Output = Size2D<Dip, Dip>

The resulting type after applying the / operator.

fn div(self, rhs: Factor2d) -> Size2D<Dip, Dip>

Performs the / operation.

impl Div<Factor2d> for Size2D<Px, Px>

type Output = Size2D<Px, Px>

The resulting type after applying the / operator.

fn div(self, rhs: Factor2d) -> Size2D<Px, Px>

Performs the / operation.

impl Div<Factor2d> for Vector2D<Dip, Dip>

type Output = Vector2D<Dip, Dip>

The resulting type after applying the / operator.

fn div(self, rhs: Factor2d) -> Vector2D<Dip, Dip>

Performs the / operation.

impl Div<Factor2d> for Vector2D<Px, Px>

type Output = Vector2D<Px, Px>

The resulting type after applying the / operator.

fn div(self, rhs: Factor2d) -> Vector2D<Px, Px>

Performs the / operation.

impl Div for Factor2d

type Output = Factor2d

The resulting type after applying the / operator.

fn div(self, rhs: Factor2d) -> Factor2d

Performs the / operation.

impl DivAssign<Factor> for Factor2d

fn div_assign(&mut self, rhs: Factor)

Performs the /= operation.

impl DivAssign<Factor2d> for Point2D<Dip, Dip>

fn div_assign(&mut self, rhs: Factor2d)

Performs the /= operation.

impl DivAssign<Factor2d> for Point2D<Px, Px>

fn div_assign(&mut self, rhs: Factor2d)

Performs the /= operation.

impl DivAssign<Factor2d> for Rect<Dip, Dip>

fn div_assign(&mut self, rhs: Factor2d)

Performs the /= operation.

impl DivAssign<Factor2d> for Rect<Px, Px>

fn div_assign(&mut self, rhs: Factor2d)

Performs the /= operation.

impl DivAssign<Factor2d> for Size2D<Dip, Dip>

fn div_assign(&mut self, rhs: Factor2d)

Performs the /= operation.

impl DivAssign<Factor2d> for Size2D<Px, Px>

fn div_assign(&mut self, rhs: Factor2d)

Performs the /= operation.

impl DivAssign<Factor2d> for Vector2D<Dip, Dip>

fn div_assign(&mut self, rhs: Factor2d)

Performs the /= operation.

impl DivAssign<Factor2d> for Vector2D<Px, Px>

fn div_assign(&mut self, rhs: Factor2d)

Performs the /= operation.

impl DivAssign for Factor2d

fn div_assign(&mut self, rhs: Factor2d)

Performs the /= operation.

impl<X, Y> From<(X, Y)> for Factor2d

where X: Into<Factor>, Y: Into<Factor>,

fn from(_: (X, Y)) -> Factor2d

Converts to this type from the input type.

impl From<Factor> for Factor2d

fn from(xy: Factor) -> Factor2d

Converts to this type from the input type.

impl From<Factor2d> for Align

fn from(factor2d: Factor2d) -> Align

Converts to this type from the input type.

impl From<Factor2d> for Size

fn from(scale: Factor2d) -> Size

To relative width and height.

impl From<FactorPercent> for Factor2d

fn from(xy: FactorPercent) -> Factor2d

Converts to this type from the input type.

impl IntoVar<Align> for Factor2d

type Var = LocalVar<Align>

Variable type that will wrap the T value.

fn into_var(self) -> <Factor2d as IntoVar<Align>>::Var

Converts the source value into a var.

fn into_boxed_var(self) -> Box<dyn VarBoxed<T>>

where Self: Sized,

Converts into BoxedVar<T>.

impl<X, Y> IntoVar<Factor2d> for (X, Y)

where X: Into<Factor>, Y: Into<Factor>,

type Var = LocalVar<Factor2d>

Variable type that will wrap the T value.

fn into_var(self) -> <(X, Y) as IntoVar<Factor2d>>::Var

Converts the source value into a var.

fn into_boxed_var(self) -> Box<dyn VarBoxed<T>>

where Self: Sized,

Converts into BoxedVar<T>.

impl IntoVar<Factor2d> for Factor

type Var = LocalVar<Factor2d>

Variable type that will wrap the T value.

fn into_var(self) -> <Factor as IntoVar<Factor2d>>::Var

Converts the source value into a var.

fn into_boxed_var(self) -> Box<dyn VarBoxed<T>>

where Self: Sized,

Converts into BoxedVar<T>.

impl IntoVar<Factor2d> for FactorPercent

type Var = LocalVar<Factor2d>

Variable type that will wrap the T value.

fn into_var(self) -> <FactorPercent as IntoVar<Factor2d>>::Var

Converts the source value into a var.

fn into_boxed_var(self) -> Box<dyn VarBoxed<T>>

where Self: Sized,

Converts into BoxedVar<T>.

impl IntoVar<Size> for Factor2d

fn into_var(self) -> <Factor2d as IntoVar<Size>>::Var

To relative width and height.

type Var = LocalVar<Size>

Variable type that will wrap the T value.

fn into_boxed_var(self) -> Box<dyn VarBoxed<T>>

where Self: Sized,

Converts into BoxedVar<T>.

impl Mul<Factor> for Factor2d

type Output = Factor2d

The resulting type after applying the * operator.

fn mul(self, rhs: Factor) -> Factor2d

Performs the * operation.

impl Mul<Factor2d> for Point2D<Dip, Dip>

type Output = Point2D<Dip, Dip>

The resulting type after applying the * operator.

fn mul(self, rhs: Factor2d) -> Point2D<Dip, Dip>

Performs the * operation.

impl Mul<Factor2d> for Point2D<Px, Px>

type Output = Point2D<Px, Px>

The resulting type after applying the * operator.

fn mul(self, rhs: Factor2d) -> Point2D<Px, Px>

Performs the * operation.

impl Mul<Factor2d> for Rect<Dip, Dip>

type Output = Rect<Dip, Dip>

The resulting type after applying the * operator.

fn mul(self, rhs: Factor2d) -> Rect<Dip, Dip>

Performs the * operation.

impl Mul<Factor2d> for Rect<Px, Px>

type Output = Rect<Px, Px>

The resulting type after applying the * operator.

fn mul(self, rhs: Factor2d) -> Rect<Px, Px>

Performs the * operation.

impl Mul<Factor2d> for Size2D<Dip, Dip>

type Output = Size2D<Dip, Dip>

The resulting type after applying the * operator.

fn mul(self, rhs: Factor2d) -> Size2D<Dip, Dip>

Performs the * operation.

impl Mul<Factor2d> for Size2D<Px, Px>

type Output = Size2D<Px, Px>

The resulting type after applying the * operator.

fn mul(self, rhs: Factor2d) -> Size2D<Px, Px>

Performs the * operation.

impl Mul<Factor2d> for Vector2D<Dip, Dip>

type Output = Vector2D<Dip, Dip>

The resulting type after applying the * operator.

fn mul(self, rhs: Factor2d) -> Vector2D<Dip, Dip>

Performs the * operation.

impl Mul<Factor2d> for Vector2D<Px, Px>

type Output = Vector2D<Px, Px>

The resulting type after applying the * operator.

fn mul(self, rhs: Factor2d) -> Vector2D<Px, Px>

Performs the * operation.

impl Mul for Factor2d

type Output = Factor2d

The resulting type after applying the * operator.

fn mul(self, rhs: Factor2d) -> Factor2d

Performs the * operation.

impl MulAssign<Factor> for Factor2d

fn mul_assign(&mut self, rhs: Factor)

Performs the *= operation.

impl MulAssign<Factor2d> for Point2D<Dip, Dip>

fn mul_assign(&mut self, rhs: Factor2d)

Performs the *= operation.

impl MulAssign<Factor2d> for Point2D<Px, Px>

fn mul_assign(&mut self, rhs: Factor2d)

Performs the *= operation.

impl MulAssign<Factor2d> for Rect<Dip, Dip>

fn mul_assign(&mut self, rhs: Factor2d)

Performs the *= operation.

impl MulAssign<Factor2d> for Rect<Px, Px>

fn mul_assign(&mut self, rhs: Factor2d)

Performs the *= operation.

impl MulAssign<Factor2d> for Size2D<Dip, Dip>

fn mul_assign(&mut self, rhs: Factor2d)

Performs the *= operation.

impl MulAssign<Factor2d> for Size2D<Px, Px>

fn mul_assign(&mut self, rhs: Factor2d)

Performs the *= operation.

impl MulAssign<Factor2d> for Vector2D<Dip, Dip>

fn mul_assign(&mut self, rhs: Factor2d)

Performs the *= operation.

impl MulAssign<Factor2d> for Vector2D<Px, Px>

fn mul_assign(&mut self, rhs: Factor2d)

Performs the *= operation.

impl MulAssign for Factor2d

fn mul_assign(&mut self, rhs: Factor2d)

Performs the *= operation.

impl Neg for Factor2d

type Output = Factor2d

The resulting type after applying the - operator.

fn neg(self) -> <Factor2d as Neg>::Output

Performs the unary - operation.

impl PartialEq for Factor2d

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for Factor2d

impl IntoValue<Align> for Factor2d

impl<X, Y> IntoValue<Factor2d> for (X, Y)

where X: Into<Factor>, Y: Into<Factor>,

impl IntoValue<Factor2d> for Factor

impl IntoValue<Factor2d> for FactorPercent

impl IntoValue<Size> for Factor2d

impl StructuralPartialEq for Factor2d