Struct Atom 

pub struct Atom<'a> {
    pub id: Option<Id>,
    pub size: Option<Vec2>,
    pub max_size: Vec2,
    pub grow: bool,
    pub shrink: bool,
    pub align: Align2,
    pub kind: AtomKind<'a>,
}

A low-level ui building block.

This can be a piece of text, an image, or even a custom widget. It can be decorated with various layout hints, such as grow, shrink, align, and more.

Atom implements From for String, str, crate::Image and much more for convenience.

Many widgets take an impl crate::IntoAtoms parameter, which allows you to easily create atoms from tuples of text, images, and other atoms:

let image = egui::include_image!("../../../eframe/data/icon.png");
ui.button((image, "Click me!"));

You can directly call the atom_* methods on anything that implements Into<Atom>.

use egui::AtomExt as _;
let string_atom = "Hello".atom_grow(true);
let image_atom = Image::new("some_image_url").atom_size(Vec2::splat(20.0));

Fields

id: Option<Id>

See crate::AtomExt::atom_id

size: Option<Vec2>

See crate::AtomExt::atom_size

max_size: Vec2

See crate::AtomExt::atom_max_size

grow: bool

See crate::AtomExt::atom_grow

shrink: bool

See crate::AtomExt::atom_shrink

align: Align2

See crate::AtomExt::atom_align

kind: AtomKind<'a>

The atom type / content

Implementations

impl<'a> Atom<'a>

pub fn grow() -> Self

Create an empty Atom marked as grow.

This will expand in size, allowing all preceding atoms to be left-aligned, and all following atoms to be right-aligned

pub fn custom(id: Id, size: impl Into<Vec2>) -> Self

Create an AtomKind::Empty with a specific size.

Example:

let id = Id::new("my_button");
let response = Button::new(("Hi!", Atom::custom(id, Vec2::splat(18.0)))).atom_ui(ui);

let rect = response.rect(id);
if let Some(rect) = rect {
    ui.place(rect, Button::new("⏵"));
}

pub fn into_sized( self, ui: &Ui, available_size: Vec2, wrap_mode: Option<TextWrapMode>, fallback_font: FontSelection, ) -> SizedAtom<'a>

Turn this into a SizedAtom.

Trait Implementations

impl<'a> Clone for Atom<'a>

fn clone(&self) -> Atom<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Atom<'a>

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

Formats the value using the given formatter.

impl Default for Atom<'_>

fn default() -> Self

Returns the “default value” for a type.

impl<'a, T> From<T> for Atom<'a>

where T: Into<AtomKind<'a>>,

fn from(value: T) -> Self

Converts to this type from the input type.