pub struct Memory {
    pub options: Options,
    pub data: IdTypeMap,
    pub caches: CacheStorage,
    /* private fields */
}
Expand description

The data that egui persists between frames.

This includes window positions and sizes, how far the user has scrolled in a ScrollArea etc.

If you want this to persist when closing your app you should serialize Memory and store it. For this you need to enable the persistence.

If you want to store data for your widgets, you should look at Memory::data

Fields

options: Optionsdata: IdTypeMap

This map stores some superficial state for all widgets with custom Ids.

This includes storing if a crate::CollapsingHeader is open, how far scrolled a crate::ScrollArea is, where the cursor in a crate::TextEdit is, etc.

This is NOT meant to store any important data. Store that in your own structures!

Each read clones the data, so keep your values cheap to clone. If you want to store a lot of data you should wrap it in Arc<Mutex<…>> so it is cheap to clone.

This will be saved between different program runs if you use the persistence feature.

To store a state common for all your widgets (a singleton), use Id::null as the key.

caches: CacheStorage

Can be used to cache computations from one frame to another.

This is for saving CPU when you have something that may take 1-100ms to compute. Things that are very slow (>100ms) should instead be done async (i.e. in another thread) so as not to lock the UI thread.

use egui::util::cache::{ComputerMut, FrameCache};

#[derive(Default)]
struct CharCounter {}
impl ComputerMut<&str, usize> for CharCounter {
    fn compute(&mut self, s: &str) -> usize {
        s.chars().count() // you probably want to cache something more expensive than this
    }
}
type CharCountCache<'a> = FrameCache<usize, CharCounter>;

let mut memory = ctx.memory();
let cache = memory.caches.cache::<CharCountCache<'_>>();
assert_eq!(cache.get("hello"), 5);

Implementations

Top-most layer at the given position.

An iterator over all layers. Back-to-front. Top is last.

Does this widget have keyboard focus?

This function does not consider whether the UI as a whole (e.g. window) has the keyboard focus. That makes this function suitable for deciding widget state that should not be disrupted if the user moves away from the window and back.

Which widget has keyboard focus?

Prevent keyboard focus from moving away from this widget even if users presses the tab key. You must first give focus to the widget before calling this.

Is the keyboard focus locked on this widget? If so the focus won’t move even if the user presses the tab key.

Give keyboard focus to a specific widget. See also crate::Response::request_focus.

Surrender keyboard focus for a specific widget. See also crate::Response::surrender_focus.

Stop editing of active TextEdit (if any).

Forget window positions, sizes etc. Can be used to auto-layout windows.

Popups

Popups are things like combo-boxes, color pickers, menus etc. Only one can be be open at a time.

If true, all windows, menus, tooltips etc are to be visible at once.

This is useful for testing, benchmarking, pre-caching, etc.

Experimental feature!

If true, all windows, menus, tooltips etc are to be visible at once.

This is useful for testing, benchmarking, pre-caching, etc.

Experimental feature!

Trait Implementations

Returns a copy of the value. Read more

Performs copy-assignment from source. Read more

Formats the value using the given formatter. Read more

Returns the “default value” for a type. Read more

Deserialize this value from the given Serde deserializer. Read more

Serialize this value into the given Serde serializer. Read more

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

Immutably borrows from an owned value. Read more

Mutably borrows from an owned value. Read more

Returns the argument unchanged.

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

The resulting type after obtaining ownership.

Creates owned data from borrowed data, usually by cloning. Read more

Uses borrowed data to replace owned data, usually by cloning. Read more

The type returned in the event of a conversion error.

Performs the conversion.

The type returned in the event of a conversion error.

Performs the conversion.

Attaches the provided Subscriber to this type, returning a WithDispatch wrapper. Read more

Attaches the current default Subscriber to this type, returning a WithDispatch wrapper. Read more