Struct Style

pub struct Style { /* private fields */ }

Style is a simple container for a named properties. Styles can be based off some other style, thus allowing cascaded styling. Such cascading allows to define some base style with common properties and then create any amount of derived styles. For example, you can define a style for Button widget with corner radius, font size, border thickness and then create two derived styles for light and dark themes that will define colors and brushes. Light or dark theme does not affect all of those base properties, but has different colors.

Styles can contain only specific types of properties (see StyleProperty enumeration), any more complex properties can be built using these primitives.

There are three major ways of widgets styling:

1. During widget building stage - this way involves crate::BuildContext’s style field. This field defines a style for all widgets that will be built with the context.
2. Message-based style changes - this way is based on crate::widget::WidgetMessage::Style message that can be sent to a particular widget (or hierarchy) to force them to update styled properties.
3. Global style changes - this way is based on crate::UserInterface::set_style method, that sends the specified style to all widgets, forcing them to update styled properties.

The most used methods are 1 and 3. The following examples should clarify how to use these approaches.

Examples

The following example shows how to use a style during widget building stage:

fn build_with_style(ui: &mut UserInterface) {
    // The context will use UI style by default. You can override it using `ui.set_style(..)`.
    let ctx = &mut ui.build_ctx();

    // Create a style resource first and assign it to the build context. All widgets built with
    // the context will use this style.
    let style = Style::light_style()
        .with(Button::CORNER_RADIUS, 6.0f32)
        .with(Button::BORDER_THICKNESS, Thickness::uniform(3.0));

    ctx.style = StyleResource::new_ok(ResourceKind::Embedded, style);

    // The button will have corner radius of 6.0 points and border thickness of 3.0 points on
    // each side.
    ButtonBuilder::new(WidgetBuilder::new()).build(ctx);
}

To change UI style globally after it was built, use something like this:

use fyrox_ui::{
    button::Button,
    style::{resource::StyleResource, Style},
    Thickness, UserInterface,
};
use fyrox_resource::untyped::ResourceKind;

fn apply_style(ui: &mut UserInterface) {
    let style = Style::light_style()
        .with(Button::CORNER_RADIUS, 3.0f32)
        .with(Button::BORDER_THICKNESS, Thickness::uniform(1.0));

    ui.set_style(StyleResource::new_ok(ResourceKind::Embedded, style));
}

Implementations

impl Style

pub const PARENT: &'static str = "parent"

pub const VARIABLES: &'static str = "variables"

impl Style

pub const BRUSH_DARKEST: &'static str = "Global.Brush.Darkest"

The name of the darkest brush.

pub const BRUSH_DARKER: &'static str = "Global.Brush.Darker"

The name of the darker brush.

pub const BRUSH_DARK: &'static str = "Global.Brush.Dark"

The name of the dark brush.

pub const BRUSH_PRIMARY: &'static str = "Global.Brush.Primary"

The name of the primary brush that is used for the major amount of surface.

pub const BRUSH_LIGHTER_PRIMARY: &'static str = "Global.Brush.LighterPrimary"

The name of the slightly lighter primary brush.

pub const BRUSH_LIGHT: &'static str = "Global.Brush.Light"

The name of the light brush.

pub const BRUSH_LIGHTER: &'static str = "Global.Brush.Lighter"

The name of the lighter brush.

pub const BRUSH_LIGHTEST: &'static str = "Global.Brush.Lightest"

The name of the lightest brush.

pub const BRUSH_BRIGHT: &'static str = "Global.Brush.Bright"

The name of the bright brush.

pub const BRUSH_BRIGHTEST: &'static str = "Global.Brush.Brightest"

The name of the brightest brush.

pub const BRUSH_BRIGHT_BLUE: &'static str = "Global.Brush.BrightBlue"

The name of the bright blue brush.

pub const BRUSH_DIM_BLUE: &'static str = "Global.Brush.DimBlue"

The name of the dim blue brush.

pub const BRUSH_TEXT: &'static str = "Global.Brush.Text"

The name of the text brush.

pub const BRUSH_FOREGROUND: &'static str = "Global.Brush.Foreground"

The name of the foreground brush.

pub const BRUSH_INFORMATION: &'static str = "Global.Brush.Information"

The name of the information brush.

pub const BRUSH_WARNING: &'static str = "Global.Brush.Warning"

The name of the warning brush.

pub const BRUSH_ERROR: &'static str = "Global.Brush.Error"

The name of the error brush.

pub const BRUSH_OK: &'static str = "Global.Brush.Ok"

The name of the ok brush.

pub const FONT_SIZE: &'static str = "Global.Font.Size"

The name of the font size property.

pub fn dark_style() -> Style

Creates a new dark style.

pub fn light_style() -> Style

Creates a new light style.

pub fn with( self, name: impl Into<ImmutableString>, property: impl Into<StyleProperty>, ) -> Style

The same as Self::set, but takes self as value and essentially allows chained calls in builder-like style:

Style::default()
    .with("SomeProperty", 0.2f32)
    .with("SomeOtherProperty", Brush::Solid(Color::WHITE));

pub fn set_parent(&mut self, parent: Option<Resource<Style>>)

Sets the parent style for this style. Parent style will be used at attempt to fetch properties that aren’t present in this style.

pub fn parent(&self) -> Option<&Resource<Style>>

Returns parent style of this style.

pub fn merge(&mut self, other: &Style) -> &mut Style

Merges current style with some other style. This method does not overwrite existing values, instead it only adds missing values from the other style.

pub fn set( &mut self, name: impl Into<ImmutableString>, property: impl Into<StyleProperty>, ) -> &mut Style

Registers a new property with the given name and value:

let mut style = Style::default();
style
    .set("SomeProperty", 0.2f32)
    .set("SomeOtherProperty", Brush::Solid(Color::WHITE));

pub fn get_raw(&self, name: impl Into<ImmutableString>) -> Option<StyleProperty>

Tries to fetch a property with the given name. If the property is not found, this method will try to search in the parent style (the search is recursive).

pub fn get<P>(&self, name: impl Into<ImmutableString>) -> Option<P>

where StyleProperty: IntoPrimitive<P>,

Tries to fetch a property with the given name and perform type casting to the requested type. If the property is not found, this method will try to search in the parent style (the search is recursive).

pub fn get_or_default<P>(&self, name: impl Into<ImmutableString>) -> P

where P: Default, StyleProperty: IntoPrimitive<P>,

Tries to fetch a property with the given name. If the property is not found, this method will try to search in the parent style (the search is recursive). If there’s no such property at all, this method will return its default value (define by Default trait).

pub fn get_or<P>(&self, name: impl Into<ImmutableString>, default: P) -> P

where StyleProperty: IntoPrimitive<P>,

Tries to fetch a property with the given name or, if not found, returns the given default value.

pub fn property<P>(&self, name: impl Into<ImmutableString>) -> StyledProperty<P>

where P: Default, StyleProperty: IntoPrimitive<P>,

Tries to find a property with the given name or takes the default value of the property’s type and wraps it into StyledProperty, essentially binding the value to the style property.

pub async fn from_file( path: &Path, io: &(dyn ResourceIo + 'static), resource_manager: ResourceManager, ) -> Result<Style, StyleResourceError>

Tries to load a style from the given path.

Trait Implementations

impl Debug for Style

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

Formats the value using the given formatter.

impl Default for Style

fn default() -> Style

Returns the “default value” for a type.

impl Reflect for Style

where Style: 'static, Option<Resource<Style>>: Reflect, HashMap<ImmutableString, StyleProperty, BuildHasherDefault<FxHasher>>: Reflect,

fn source_path() -> &'static str

fn type_name(&self) -> &'static str

fn doc(&self) -> &'static str

fn assembly_name(&self) -> &'static str

Returns a parent assembly name of the type that implements this trait. WARNING: You should use proc-macro (#[derive(Reflect)]) to ensure that this method will return correct assembly name. In other words - there’s no guarantee, that any implementation other than proc-macro will return a correct name of the assembly. Alternatively, you can use env!("CARGO_PKG_NAME") as an implementation.

fn type_assembly_name() -> &'static str

Returns a parent assembly name of the type that implements this trait. WARNING: You should use proc-macro (#[derive(Reflect)]) to ensure that this method will return correct assembly name. In other words - there’s no guarantee, that any implementation other than proc-macro will return a correct name of the assembly. Alternatively, you can use env!("CARGO_PKG_NAME") as an implementation.

fn fields_info(&self, func: &mut dyn FnMut(&[FieldInfo<'_, '_>]))

fn into_any(self: Box<Style>) -> Box<dyn Any>

fn set( &mut self, value: Box<dyn Reflect>, ) -> Result<Box<dyn Reflect>, Box<dyn Reflect>>

fn as_any(&self, func: &mut dyn FnMut(&(dyn Any + 'static)))

fn as_any_mut(&mut self, func: &mut dyn FnMut(&mut (dyn Any + 'static)))

fn as_reflect(&self, func: &mut dyn FnMut(&(dyn Reflect + 'static)))

fn as_reflect_mut(&mut self, func: &mut dyn FnMut(&mut (dyn Reflect + 'static)))

fn fields(&self, func: &mut dyn FnMut(&[&(dyn Reflect + 'static)]))

fn fields_mut( &mut self, func: &mut dyn FnMut(&mut [&mut (dyn Reflect + 'static)]), )

fn field( &self, name: &str, func: &mut dyn FnMut(Option<&(dyn Reflect + 'static)>), )

fn field_mut( &mut self, name: &str, func: &mut dyn FnMut(Option<&mut (dyn Reflect + 'static)>), )

fn set_field( &mut self, field: &str, value: Box<dyn Reflect>, func: &mut dyn FnMut(Result<Box<dyn Reflect>, Box<dyn Reflect>>), )

Calls user method specified with #[reflect(setter = ..)] or falls back to Reflect::field_mut

fn as_array(&self, func: &mut dyn FnMut(Option<&(dyn ReflectArray + 'static)>))

fn as_array_mut( &mut self, func: &mut dyn FnMut(Option<&mut (dyn ReflectArray + 'static)>), )

fn as_list(&self, func: &mut dyn FnMut(Option<&(dyn ReflectList + 'static)>))

fn as_list_mut( &mut self, func: &mut dyn FnMut(Option<&mut (dyn ReflectList + 'static)>), )

fn as_inheritable_variable( &self, func: &mut dyn FnMut(Option<&(dyn ReflectInheritableVariable + 'static)>), )

fn as_inheritable_variable_mut( &mut self, func: &mut dyn FnMut(Option<&mut (dyn ReflectInheritableVariable + 'static)>), )

fn as_hash_map( &self, func: &mut dyn FnMut(Option<&(dyn ReflectHashMap + 'static)>), )

fn as_hash_map_mut( &mut self, func: &mut dyn FnMut(Option<&mut (dyn ReflectHashMap + 'static)>), )

impl ResourceData for Style

fn type_uuid(&self) -> Uuid

Returns unique data type id.

fn save(&mut self, path: &Path) -> Result<(), Box<dyn Error>>

Saves the resource data a file at the specified path. This method is free to decide how the resource data is saved. This is needed, because there are multiple formats that defines various kinds of resources. For example, a rectangular texture could be saved into a bunch of formats, such as png, bmp, tga, jpg etc., but in the engine it is single Texture resource. In any case, produced file should be compatible with a respective resource loader.

fn can_be_saved(&self) -> bool

Returns true if the resource data can be saved to a file, false - otherwise. Not every resource type supports saving, for example there might be temporary resource type that is used only at runtime which does not need saving at all.

impl TypeUuidProvider for Style

fn type_uuid() -> Uuid

Return type UUID.

impl Visit for Style

where Option<Resource<Style>>: Visit, HashMap<ImmutableString, StyleProperty, BuildHasherDefault<FxHasher>>: Visit,

fn visit(&mut self, name: &str, visitor: &mut Visitor) -> Result<(), VisitError>

Read or write this value, depending on whether Visitor::is_reading() is true or false.