Struct Style 

pub struct Style {

    pub display: Display,
    pub visibility: Visibility,
    pub direction: LayoutDirection,
    pub unicode_bidi: UnicodeBidi,
    pub overflow: Point<Overflow>,
    pub overflow_fade: Edges<AbsoluteLength>,
    pub scrollbar_width: AbsoluteLength,
    pub allow_concurrent_scroll: bool,
    pub restrict_scroll_to_axis: bool,
    pub position: Position,
    pub inset: Edges<Length>,
    pub size: Size<Length>,
    pub min_size: Size<Length>,
    pub max_size: Size<Length>,
    pub aspect_ratio: Option<f32>,
    pub margin: Edges<Length>,
    pub padding: Edges<DefiniteLength>,
    pub border_widths: Edges<AbsoluteLength>,
    pub align_items: Option<AlignItems>,
    pub align_self: Option<AlignSelf>,
    pub vertical_align: VerticalAlign,
    pub align_content: Option<AlignContent>,
    pub justify_content: Option<JustifyContent>,
    pub gap: Size<DefiniteLength>,
    pub flex_direction: FlexDirection,
    pub flex_wrap: FlexWrap,
    pub flex_basis: Length,
    pub flex_grow: f32,
    pub flex_shrink: f32,
    pub background: Option<Fill>,
    pub border_color: Option<Background>,
    pub border_style: BorderStyle,
    pub border_dashed_length: f32,
    pub border_dashed_gap: f32,
    pub corner_radii: Corners<AbsoluteLength>,
    pub corner_smoothing: Option<f32>,
    pub box_shadow: Vec<BoxShadow>,
    pub ring: RingStyle,
    pub inset_ring: RingStyle,
    pub filter: Vec<Filter>,
    pub backdrop_filter: Vec<Filter>,
    pub text: TextStyleRefinement,
    pub mouse_cursor: Option<CursorStyle>,
    pub opacity: Option<f32>,
    pub grid_cols: Option<GridTemplate>,
    pub grid_rows: Option<GridTemplate>,
    pub grid_location: Option<GridLocation>,
    pub debug: bool,
    pub debug_below: bool,
    /* private fields */
}

The resolved styling of an element, which GPUI uses to lay out and paint it.

You rarely build a Style yourself. The methods of Styled write into a StyleRefinement, and GPUI applies that refinement over Style::default() when it draws the element. A default Style uses Display::Block and is visible.

Examples

use gpui::{Display, Refineable, Style, StyleRefinement};

let mut style = Style::default();
assert_eq!(style.display, Display::Block);

let mut refinement = StyleRefinement::default();
refinement.display = Some(Display::Flex);
style.refine(&refinement);
assert_eq!(style.display, Display::Flex);

Fields

display: Display

What layout strategy should be used?

visibility: Visibility

Should the element be painted on screen?

direction: LayoutDirection

The inline direction of this element and its descendants.

unicode_bidi: UnicodeBidi

How this element participates in Unicode bidirectional text formatting.

overflow: Point<Overflow>

How children overflowing their container should affect layout

overflow_fade: Edges<AbsoluteLength>

Edge fade distances for overflow masking.

scrollbar_width: AbsoluteLength

How much space (in logical pixels or rems) should be reserved for the scrollbars of Overflow::Scroll nodes.

allow_concurrent_scroll: bool

Whether both x and y axis should be scrollable at the same time.

restrict_scroll_to_axis: bool

Whether scrolling should be restricted to the input gesture’s axis.

Pixel-based scroll gestures are locked to their initially dominant axis. The lock may be released when the gesture changes direction strongly. Touch phases delimit gestures when available, with a timeout fallback for platforms that only emit moved events.

This also prevents input from being remapped to another axis. For example, horizontal input will not scroll a container that only has vertical overflow enabled. Mouse wheel platforms typically report ordinary wheel input on the Y axis and Shift-modified input on the X axis.

Motivation

On the web, a vertical mouse wheel scrolls the Y axis even over a horizontally scrollable element.

The only way to scroll horizontally is to hold down Shift while scrolling, which then changes the scroll axis to the X axis.

GPUI can otherwise choose either axis for mouse-wheel input. In a vertical list with horizontally scrollable children, that can send the list’s scroll gesture to a child.

Set this property to keep each gesture on its initial axis.

position: Position

What should the position value of this struct use as a base offset?

inset: Edges<Length>

How should the position of this element be tweaked relative to the layout defined?

size: Size<Length>

Sets the initial size of the item

min_size: Size<Length>

Controls the minimum size of the item

max_size: Size<Length>

Controls the maximum size of the item

aspect_ratio: Option<f32>

Sets the preferred aspect ratio for the item. The ratio is calculated as width divided by height.

margin: Edges<Length>

How large should the margin be on each side?

padding: Edges<DefiniteLength>

How large should the padding be on each side?

border_widths: Edges<AbsoluteLength>

How large should the border be on each side?

align_items: Option<AlignItems>

How this node’s children aligned in the cross/block axis?

align_self: Option<AlignSelf>

How this node should be aligned in the cross/block axis. Falls back to the parents AlignItems if not set

vertical_align: VerticalAlign

How this element aligns vertically when it participates in an inline formatting context.

align_content: Option<AlignContent>

How should content contained within this item be aligned in the cross/block axis

justify_content: Option<JustifyContent>

How should contained within this item be aligned in the main/inline axis

gap: Size<DefiniteLength>

How large should the gaps between items in a flex container be?

flex_direction: FlexDirection

Which direction does the main axis flow in?

flex_wrap: FlexWrap

Should elements wrap, or stay in a single line?

flex_basis: Length

Sets the initial main axis size of the item

flex_grow: f32

The relative rate at which this item grows when it is expanding to fill space, 0.0 is the default value, and this value must be positive.

flex_shrink: f32

The relative rate at which this item shrinks when it is contracting to fit into space, 1.0 is the default value, and this value must be positive.

background: Option<Fill>

The fill color of this element

border_color: Option<Background>

The background painted into the border of this element

border_style: BorderStyle

The border style of this element

border_dashed_length: f32

The length of each border dash, as a multiple of the border width.

border_dashed_gap: f32

The gap between border dashes, as a multiple of the border width.

corner_radii: Corners<AbsoluteLength>

The radius of the corners of this element

corner_smoothing: Option<f32>

Controls the transition from each rounded corner to the straight edges. 0.0 produces circular corners. 1.0 applies maximum smoothing.

box_shadow: Vec<BoxShadow>

Box shadow of the element

ring: RingStyle

A solid ring painted outside the element.

inset_ring: RingStyle

A solid ring painted inside the element.

filter: Vec<Filter>

Filters applied to this element’s own content and children (CSS filter).

backdrop_filter: Vec<Filter>

Filters applied to the content rendered behind this element (CSS backdrop-filter).

text: TextStyleRefinement

The text style of this element

mouse_cursor: Option<CursorStyle>

The mouse cursor style shown when the mouse pointer is over an element.

opacity: Option<f32>

Opacity applied to this element and its children after compositing them as a group.

grid_cols: Option<GridTemplate>

The grid columns of this element Roughly equivalent to the Tailwind grid-cols-<number>

grid_rows: Option<GridTemplate>

The row span of this element Equivalent to the Tailwind grid-rows-<number>

grid_location: Option<GridLocation>

The grid location of this element

debug: bool

Whether to draw a red debugging outline around this element

debug_below: bool

Whether to draw a red debugging outline around this element and all of its conforming children

Implementations

impl Style

pub fn has_opaque_background(&self) -> bool

Returns true if the style has a background that is not fully transparent. Visibility is not checked.

pub fn text_style(&self) -> Option<&TextStyleRefinement>

Get the text style in this element style.

pub fn overflow_mask( &self, bounds: Bounds<Pixels>, rem_size: Pixels, ) -> Option<ContentMask<Pixels>>

Get the content mask for this element style, based on the given bounds. If the element does not hide its overflow, this will return None.

pub fn scroll_mask( &self, bounds: Bounds<Pixels>, rem_size: Pixels, ) -> ContentMask<Pixels>

Get the content mask for a container that always clips and scrolls vertically, like List and UniformList: the vertical axis always clips, the horizontal axis clips according to overflow.x, and overflow_fade distances apply on each clipped axis.

pub fn paint( &self, bounds: Bounds<Pixels>, window: &mut Window, cx: &mut App, continuation: impl FnOnce(&mut Window, &mut App), )

Paints the background of an element styled with this style.

Trait Implementations

impl Clone for Style

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Style

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

Formats the value using the given formatter.

impl Default for Style

fn default() -> Self

Returns the “default value” for a type.

impl From<StyleRefinement> for Style

where Option<Display>: Clone, Option<Visibility>: Clone, Option<LayoutDirection>: Clone, Option<UnicodeBidi>: Clone, Option<bool>: Clone, PointRefinement<Overflow>: Clone, EdgesRefinement<AbsoluteLength>: Clone, Option<AbsoluteLength>: Clone, Option<Position>: Clone, EdgesRefinement<Length>: Clone, SizeRefinement<Length>: Clone, Option<f32>: Clone, EdgesRefinement<DefiniteLength>: Clone, Option<AlignItems>: Clone, Option<AlignSelf>: Clone, Option<VerticalAlign>: Clone, Option<AlignContent>: Clone, Option<JustifyContent>: Clone, SizeRefinement<DefiniteLength>: Clone, Option<FlexDirection>: Clone, Option<FlexWrap>: Clone, Option<Length>: Clone, Option<Fill>: Clone, Option<Background>: Clone, Option<BorderStyle>: Clone, CornersRefinement<AbsoluteLength>: Clone, Option<Vec<BoxShadow>>: Clone, RingStyleRefinement: Clone, Option<Vec<Filter>>: Clone, TextStyleRefinement: Clone, Option<CursorStyle>: Clone, Option<GridTemplate>: Clone, Option<GridLocation>: Clone,

fn from(value: StyleRefinement) -> Self

Converts to this type from the input type.

impl Refineable for Style

where Option<Display>: Clone, Option<Visibility>: Clone, Option<LayoutDirection>: Clone, Option<UnicodeBidi>: Clone, Option<bool>: Clone, PointRefinement<Overflow>: Clone, EdgesRefinement<AbsoluteLength>: Clone, Option<AbsoluteLength>: Clone, Option<Position>: Clone, EdgesRefinement<Length>: Clone, SizeRefinement<Length>: Clone, Option<f32>: Clone, EdgesRefinement<DefiniteLength>: Clone, Option<AlignItems>: Clone, Option<AlignSelf>: Clone, Option<VerticalAlign>: Clone, Option<AlignContent>: Clone, Option<JustifyContent>: Clone, SizeRefinement<DefiniteLength>: Clone, Option<FlexDirection>: Clone, Option<FlexWrap>: Clone, Option<Length>: Clone, Option<Fill>: Clone, Option<Background>: Clone, Option<BorderStyle>: Clone, CornersRefinement<AbsoluteLength>: Clone, Option<Vec<BoxShadow>>: Clone, RingStyleRefinement: Clone, Option<Vec<Filter>>: Clone, TextStyleRefinement: Clone, Option<CursorStyle>: Clone, Option<GridTemplate>: Clone, Option<GridLocation>: Clone,

type Refinement = StyleRefinement

fn refine(&mut self, refinement: &Self::Refinement)

Applies the given refinement to this instance, modifying it in place.

fn refined(self, refinement: Self::Refinement) -> Self

Returns a new instance with the refinement applied, equivalent to cloning self and calling refine on it.

fn is_superset_of(&self, refinement: &Self::Refinement) -> bool

Returns true if this instance would contain all values from the refinement.

fn subtract(&self, refinement: &Self::Refinement) -> Self::Refinement

Returns a refinement that represents the difference between this instance and the given refinement.

fn from_cascade(cascade: &Cascade<Self>) -> Self

where Self: Sized + Default,

Creates an instance from a cascade by merging all refinements atop the default value.