Struct jumpy::prelude::egui::Style

pub struct Style {
    pub override_text_style: Option<TextStyle>,
    pub override_font_id: Option<FontId>,
    pub text_styles: BTreeMap<TextStyle, FontId>,
    pub drag_value_text_style: TextStyle,
    pub wrap: Option<bool>,
    pub spacing: Spacing,
    pub interaction: Interaction,
    pub visuals: Visuals,
    pub animation_time: f32,
    pub debug: DebugOptions,
    pub explanation_tooltips: bool,
}

Specifies the look and feel of egui.

You can change the visuals of a Ui with Ui::style_mut and of everything with crate::Context::set_style.

If you want to change fonts, use crate::Context::set_fonts instead.

Fields

override_text_style: Option<TextStyle>

If set this will change the default TextStyle for all widgets.

On most widgets you can also set an explicit text style, which will take precedence over this.

override_font_id: Option<FontId>

If set this will change the font family and size for all widgets.

On most widgets you can also set an explicit text style, which will take precedence over this.

text_styles: BTreeMap<TextStyle, FontId>

The FontFamily and size you want to use for a specific TextStyle.

The most convenient way to look something up in this is to use TextStyle::resolve.

If you would like to overwrite app text_styles

use egui::FontFamily::Proportional;
use egui::FontId;
use egui::TextStyle::*;

// Get current context style
let mut style = (*ctx.style()).clone();

// Redefine text_styles
style.text_styles = [
  (Heading, FontId::new(30.0, Proportional)),
  (Name("Heading2".into()), FontId::new(25.0, Proportional)),
  (Name("Context".into()), FontId::new(23.0, Proportional)),
  (Body, FontId::new(18.0, Proportional)),
  (Monospace, FontId::new(14.0, Proportional)),
  (Button, FontId::new(14.0, Proportional)),
  (Small, FontId::new(10.0, Proportional)),
].into();

// Mutate global style with above changes
ctx.set_style(style);

drag_value_text_style: TextStyle

The style to use for DragValue text.

wrap: Option<bool>

If set, labels buttons wtc will use this to determine whether or not to wrap the text at the right edge of the Ui they are in. By default this is None.

• None: follow layout
• Some(true): default on
• Some(false): default off

spacing: Spacing

Sizes and distances between widgets

interaction: Interaction

How and when interaction happens.

visuals: Visuals

Colors etc.

animation_time: f32

How many seconds a typical animation should last.

debug: DebugOptions

Options to help debug why egui behaves strangely.

Only available in debug builds.

explanation_tooltips: bool

Show tooltips explaining DragValue:s etc when hovered.

This only affects a few egui widgets.

Implementations

impl Style

pub fn interact(&self, response: &Response) -> &WidgetVisuals

Use this style for interactive things. Note that you must already have a response, i.e. you must allocate space and interact BEFORE painting the widget!

pub fn interact_selectable( &self, response: &Response, selected: bool, ) -> WidgetVisuals

pub fn noninteractive(&self) -> &WidgetVisuals

Style to use for non-interactive widgets.

pub fn text_styles(&self) -> Vec<TextStyle>

All known text styles.

impl Style

pub fn ui(&mut self, ui: &mut Ui)

Trait Implementations

impl Clone for Style

fn clone(&self) -> Style

Returns a copy 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<(), Error>

Formats the value using the given formatter.

impl Default for Style

fn default() -> Style

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Style

where Style: Default,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Style

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

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 StructuralPartialEq for Style