Enum bevy::ui::Val

pub enum Val {
    Undefined,
    Auto,
    Px(f32),
    Percent(f32),
}

An enum that describes possible types of value in flexbox layout options

Variants

Undefined

No value defined

Auto

Automatically determine this value

Px(f32)

Set this value in pixels

Percent(f32)

Set this value in percent

Implementations

impl Val

pub const DEFAULT: Val = Self::Undefined

impl Val

pub fn try_add(&self, rhs: Val) -> Result<Val, ValArithmeticError>

Tries to add the values of two Vals. Returns ValArithmeticError::NonIdenticalVariants if two Vals are of different variants. When adding non-numeric Vals, it returns the value unchanged.

pub fn try_add_assign(&mut self, rhs: Val) -> Result<(), ValArithmeticError>

Adds rhs to self and assigns the result to self (see Val::try_add)

pub fn try_sub(&self, rhs: Val) -> Result<Val, ValArithmeticError>

Tries to subtract the values of two Vals. Returns ValArithmeticError::NonIdenticalVariants if two Vals are of different variants. When adding non-numeric Vals, it returns the value unchanged.

pub fn try_sub_assign(&mut self, rhs: Val) -> Result<(), ValArithmeticError>

Subtracts rhs from self and assigns the result to self (see Val::try_sub)

pub fn evaluate(&self, size: f32) -> Result<f32, ValArithmeticError>

A convenience function for simple evaluation of Val::Percent variant into a concrete Val::Px value. Returns a ValArithmeticError::NonEvaluateable if the Val is impossible to evaluate into Val::Px. Otherwise it returns an f32 containing the evaluated value in pixels.

Note: If a Val::Px is evaluated, it’s inner value returned unchanged.

pub fn try_add_with_size( &self, rhs: Val, size: f32 ) -> Result<f32, ValArithmeticError>

Similar to Val::try_add, but performs Val::evaluate on both values before adding. Returns an f32 value in pixels.

pub fn try_add_assign_with_size( &mut self, rhs: Val, size: f32 ) -> Result<(), ValArithmeticError>

Similar to Val::try_add_assign, but performs Val::evaluate on both values before adding. The value gets converted to Val::Px.

pub fn try_sub_with_size( &self, rhs: Val, size: f32 ) -> Result<f32, ValArithmeticError>

Similar to Val::try_sub, but performs Val::evaluate on both values before subtracting. Returns an f32 value in pixels.

pub fn try_sub_assign_with_size( &mut self, rhs: Val, size: f32 ) -> Result<(), ValArithmeticError>

Similar to Val::try_sub_assign, but performs Val::evaluate on both values before adding. The value gets converted to Val::Px.

Trait Implementations

impl Clone for Val

fn clone(&self) -> Val

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Val

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

Formats the value using the given formatter.

impl Default for Val

fn default() -> Val

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Val

fn deserialize<__D>( __deserializer: __D ) -> Result<Val, <__D as Deserializer<'de>>::Error>where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Div<f32> for Val

type Output = Val

The resulting type after applying the / operator.

fn div(self, rhs: f32) -> <Val as Div<f32>>::Output

Performs the / operation.

impl DivAssign<f32> for Val

fn div_assign(&mut self, rhs: f32)

Performs the /= operation.

impl Enum for Valwhere f32: FromReflect,

fn field(&self, __name_param: &str) -> Option<&(dyn Reflect + 'static)>

Returns a reference to the value of the field (in the current variant) with the given name.

fn field_at(&self, __index_param: usize) -> Option<&(dyn Reflect + 'static)>

Returns a reference to the value of the field (in the current variant) at the given index.

fn field_mut( &mut self, __name_param: &str ) -> Option<&mut (dyn Reflect + 'static)>

Returns a mutable reference to the value of the field (in the current variant) with the given name.

fn field_at_mut( &mut self, __index_param: usize ) -> Option<&mut (dyn Reflect + 'static)>

Returns a mutable reference to the value of the field (in the current variant) at the given index.

fn index_of(&self, __name_param: &str) -> Option<usize>

Returns the index of the field (in the current variant) with the given name.

fn name_at(&self, __index_param: usize) -> Option<&str>

Returns the name of the field (in the current variant) with the given index.

fn iter_fields(&self) -> VariantFieldIter<'_>

Returns an iterator over the values of the current variant’s fields.

fn field_len(&self) -> usize

Returns the number of fields in the current variant.

fn variant_name(&self) -> &str

The name of the current variant.

fn variant_index(&self) -> usize

The index of the current variant.

fn variant_type(&self) -> VariantType

The type of the current variant.

fn clone_dynamic(&self) -> DynamicEnum

fn is_variant(&self, variant_type: VariantType) -> bool

Returns true if the current variant’s type matches the given one.

fn variant_path(&self) -> String

Returns the full path to the current variant.

impl From<Val> for Dimension

fn from(value: Val) -> Dimension

Converts to this type from the input type.

impl From<Val> for LengthPercentage

fn from(value: Val) -> LengthPercentage

Converts to this type from the input type.

impl From<Val> for LengthPercentageAuto

fn from(value: Val) -> LengthPercentageAuto

Converts to this type from the input type.

impl GetTypeRegistration for Valwhere f32: FromReflect,

fn get_type_registration() -> TypeRegistration

impl Mul<f32> for Val

type Output = Val

The resulting type after applying the * operator.

fn mul(self, rhs: f32) -> <Val as Mul<f32>>::Output

Performs the * operation.

impl MulAssign<f32> for Val

fn mul_assign(&mut self, rhs: f32)

Performs the *= operation.

impl PartialEq<Val> for Val

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

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

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

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

impl Reflect for Valwhere f32: FromReflect,

fn type_name(&self) -> &str

Returns the type name of the underlying type.

fn get_type_info(&self) -> &'static TypeInfo

Returns the TypeInfo of the underlying type.

fn into_any(self: Box<Val, Global>) -> Box<dyn Any + 'static, Global>

Returns the value as a Box<dyn Any>.

fn as_any(&self) -> &(dyn Any + 'static)

Returns the value as a &dyn Any.

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Returns the value as a &mut dyn Any.

fn into_reflect(self: Box<Val, Global>) -> Box<dyn Reflect + 'static, Global>

Casts this type to a boxed reflected value.

fn as_reflect(&self) -> &(dyn Reflect + 'static)

Casts this type to a reflected value.

fn as_reflect_mut(&mut self) -> &mut (dyn Reflect + 'static)

Casts this type to a mutable reflected value.

fn clone_value(&self) -> Box<dyn Reflect + 'static, Global>

Clones the value as a Reflect trait object.

fn set( &mut self, __value_param: Box<dyn Reflect + 'static, Global> ) -> Result<(), Box<dyn Reflect + 'static, Global>>

Performs a type-checked assignment of a reflected value to this value.

fn apply(&mut self, __value_param: &(dyn Reflect + 'static))

Applies a reflected value to this value.

fn reflect_ref(&self) -> ReflectRef<'_>

Returns an enumeration of “kinds” of type.

fn reflect_mut(&mut self) -> ReflectMut<'_>

Returns a mutable enumeration of “kinds” of type.

fn reflect_owned(self: Box<Val, Global>) -> ReflectOwned

Returns an owned enumeration of “kinds” of type.

fn reflect_hash(&self) -> Option<u64>

Returns a hash of the value (which includes the type).

fn reflect_partial_eq(&self, value: &(dyn Reflect + 'static)) -> Option<bool>

Returns a “partial equality” comparison result.

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

Debug formatter for the value.

fn serializable(&self) -> Option<Serializable<'_>>

Returns a serializable version of the value.

impl Serialize for Val

fn serialize<__S>( &self, __serializer: __S ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Typed for Valwhere f32: FromReflect,

fn type_info() -> &'static TypeInfo

Returns the compile-time info for the underlying type.

impl Copy for Val

impl StructuralPartialEq for Val