Struct Px

pub struct Px(pub i32);

A physical pixel coordinate value.

This type represents a single coordinate value in physical pixel space. Physical pixels correspond directly to screen pixels and are used internally by the rendering system. Unlike density-independent pixels (Dp), physical pixels are not scaled based on screen density.

Features

• Supports negative values for scrolling and off-screen positioning
• Provides arithmetic operations (addition, subtraction, multiplication, division)
• Includes saturating arithmetic to prevent overflow
• Converts to/from density-independent pixels (Dp)
• Converts to/from floating-point values with overflow protection

Examples

use tessera_ui::px::Px;

// Create pixel values
let px1 = Px::new(100);
let px2 = Px::new(-50); // Negative values supported

// Arithmetic operations
let sum = px1 + px2; // Px(50)
let doubled = px1 * 2; // Px(200)

// Saturating arithmetic prevents overflow
let max_px = Px::new(i32::MAX);
let safe_add = max_px.saturating_add(Px::new(1)); // Still Px(i32::MAX)

// Convert to absolute value for rendering
let abs_value = Px::new(-10).abs(); // 0 (negative becomes 0)

Tuple Fields

0: i32

Implementations

impl Px

pub const ZERO: Self

A constant representing zero pixels.

pub const MAX: Self

A constant representing the maximum possible pixel value.

pub fn raw(self) -> i32

Returns the raw i32 value.

This provides direct access to the underlying integer value.

Examples

use tessera_ui::px::Px;

let px = Px::new(42);
assert_eq!(px.raw(), 42);

pub const fn new(value: i32) -> Self

Creates a new Px instance from an i32 value.

Arguments

• value - The pixel value as an i32. Negative values are allowed.

Examples

use tessera_ui::px::Px;

let positive = Px::new(100);
let negative = Px::new(-50);
let zero = Px::new(0);

pub fn from_dp(dp: Dp) -> Self

Converts from density-independent pixels (Dp) to physical pixels.

This conversion uses the current scale factor to determine how many physical pixels correspond to the given Dp value. The scale factor is typically determined by the screen’s pixel density.

Arguments

• dp - The density-independent pixel value to convert

Examples

use tessera_ui::px::Px;
use tessera_ui::dp::Dp;

let dp_value = Dp::new(16.0);
let px_value = Px::from_dp(dp_value);

pub fn to_dp(self) -> Dp

Converts from physical pixels to density-independent pixels (Dp).

This conversion uses the current scale factor to determine the Dp value that corresponds to this physical pixel value.

Examples

use tessera_ui::px::Px;

let px_value = Px::new(32);
let dp_value = px_value.to_dp();

pub fn abs(self) -> u32

Returns the absolute value as a u32

This method is primarily used for coordinate conversion during rendering, where negative coordinates need to be handled appropriately.

Examples

use tessera_ui::px::Px;

assert_eq!(Px::new(10).abs(), 10);
assert_eq!(Px::new(-5).abs(), 5);
assert_eq!(Px::new(0).abs(), 0);

pub fn positive(self) -> u32

Returns only the positive value, or zero if negative.

This is useful for ensuring that pixel values are always non-negative, especially when dealing with rendering or layout calculations.

Examples

use tessera_ui::px::Px;

assert_eq!(Px::new(10).positive(), 10);
assert_eq!(Px::new(-5).positive(), 0);
assert_eq!(Px::new(0).positive(), 0);

pub fn negative(self) -> i32

Returns the negative value, or zero if positive.

This is useful for ensuring that pixel values are always non-positive, especially when dealing with rendering or layout calculations.

Examples

use tessera_ui::px::Px;

assert_eq!(Px::new(10).negative(), 0);
assert_eq!(Px::new(-5).negative(), -5);
assert_eq!(Px::new(0).negative(), 0);

pub fn to_f32(self) -> f32

Converts the pixel value to f32.

Examples

use tessera_ui::px::Px;

let px = Px::new(42);
assert_eq!(px.to_f32(), 42.0);

pub fn from_f32(value: f32) -> Self

Creates a Px from an f32 value.

Panics

This function may panic on overflow in debug builds when the f32 value cannot be represented as an i32.

Examples

use tessera_ui::px::Px;

let px = Px::from_f32(42.7);
assert_eq!(px.raw(), 42);

pub fn saturating_from_f32(value: f32) -> Self

Creates a Px from an f32 value, saturating at the numeric bounds instead of overflowing.

This is the safe alternative to from_f32 that handles overflow by clamping the value to the valid i32 range.

Examples

use tessera_ui::px::Px;

let normal = Px::saturating_from_f32(42.7);
assert_eq!(normal.raw(), 42);

let max_val = Px::saturating_from_f32(f32::MAX);
assert_eq!(max_val.raw(), i32::MAX);

let min_val = Px::saturating_from_f32(f32::MIN);
assert_eq!(min_val.raw(), i32::MIN);

pub fn saturating_add(self, rhs: Self) -> Self

Saturating integer addition.

Computes self + rhs, saturating at the numeric bounds instead of overflowing. This prevents integer overflow by clamping the result to the valid i32 range.

Arguments

• rhs - The right-hand side value to add

Examples

use tessera_ui::px::Px;

let a = Px::new(10);
let b = Px::new(5);
assert_eq!(a.saturating_add(b), Px::new(15));

// Prevents overflow
let max = Px::new(i32::MAX);
assert_eq!(max.saturating_add(Px::new(1)), max);

pub fn saturating_sub(self, rhs: Self) -> Self

Saturating integer subtraction.

Computes self - rhs, saturating at the numeric bounds instead of overflowing. This prevents integer underflow by clamping the result to the valid i32 range.

Arguments

• rhs - The right-hand side value to subtract

Examples

use tessera_ui::px::Px;

let a = Px::new(10);
let b = Px::new(5);
assert_eq!(a.saturating_sub(b), Px::new(5));

// Prevents underflow
let min = Px::new(i32::MIN);
assert_eq!(min.saturating_sub(Px::new(1)), min);

pub fn mul_f32(self, rhs: f32) -> Self

Multiplies the pixel value by a scalar f32.

Arguments

• rhs - The scalar value to multiply by

Returns

A new Px instance with the result of the multiplication.

Examples

use tessera_ui::px::Px;

let px = Px::new(10);
let result = px.mul_f32(2.0);
assert_eq!(result, Px::new(20));

pub fn div_f32(self, rhs: f32) -> Self

Divides the pixel value by a scalar f32.

Arguments

• rhs - The scalar value to divide by

Returns

A new Px instance with the result of the division.

Panics

This function may panic if rhs is zero, as division by zero is undefined.

Examples

use tessera_ui::px::Px;

let px = Px::new(20);
let result = px.div_f32(2.0);
assert_eq!(result, Px::new(10));

Trait Implementations

impl Add<Px> for DimensionValue

type Output = DimensionValue

The resulting type after applying the + operator.

fn add(self, rhs: Px) -> Self::Output

Performs the + operation.

impl Add for Px

type Output = Px

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self::Output

Performs the + operation.

impl AddAssign<Px> for DimensionValue

fn add_assign(&mut self, rhs: Px)

Performs the += operation.

impl AddAssign for Px

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl Clone for Px

fn clone(&self) -> Px

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Px

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

Formats the value using the given formatter.

impl Default for Px

fn default() -> Px

Returns the “default value” for a type.

impl Div<i32> for Px

type Output = Px

The resulting type after applying the / operator.

fn div(self, rhs: i32) -> Self::Output

Performs the / operation.

impl Div for Px

type Output = Px

The resulting type after applying the / operator.

fn div(self, rhs: Self) -> Self::Output

Performs the / operation.

impl From<Dp> for Px

fn from(dp: Dp) -> Self

Converts to this type from the input type.

impl From<Px> for DimensionValue

fn from(value: Px) -> Self

Converts a Px value to a DimensionValue::Fixed.

impl From<Px> for Dp

fn from(px: Px) -> Self

Creates a Dp instance from a Px (physical pixels) value.

This implementation enables seamless conversion between the two pixel types used in the Tessera framework. The conversion applies the inverse of the current scale factor to convert physical pixels back to density-independent pixels.

Arguments

• px - A Px instance representing physical pixels

Examples

use tessera_ui::{Dp, Px};

let px_value = Px::from_f32(48.0);
let dp_value: Dp = px_value.into();

// Or using From::from
let dp_value2 = Dp::from(px_value);

See Also

• to_px - For the inverse conversion
• from_pixels_f64 - For direct pixel-to-dp conversion

impl From<i32> for Px

fn from(value: i32) -> Self

Converts to this type from the input type.

impl From<u32> for Px

fn from(value: u32) -> Self

Converts to this type from the input type.

impl Hash for Px

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Mul<i32> for Px

type Output = Px

The resulting type after applying the * operator.

fn mul(self, rhs: i32) -> Self::Output

Performs the * operation.

impl Mul for Px

type Output = Px

The resulting type after applying the * operator.

fn mul(self, rhs: Self) -> Self::Output

Performs the * operation.

impl Neg for Px

type Output = Px

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl Ord for Px

fn cmp(&self, other: &Px) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for Px

fn eq(&self, other: &Px) -> 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 PartialOrd for Px

fn partial_cmp(&self, other: &Px) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Sub<Px> for DimensionValue

type Output = DimensionValue

The resulting type after applying the - operator.

fn sub(self, rhs: Px) -> Self::Output

Performs the - operation.

impl Sub for Px

type Output = Px

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self::Output

Performs the - operation.

impl SubAssign<Px> for DimensionValue

fn sub_assign(&mut self, rhs: Px)

Performs the -= operation.

impl Copy for Px

impl Eq for Px

impl StructuralPartialEq for Px