Struct egui::memory::Areas

pub struct Areas {
    areas: IdMap<AreaState>,
    visible_areas_last_frame: HashSet<LayerId>,
    visible_areas_current_frame: HashSet<LayerId>,
    order: Vec<LayerId>,
    order_map: HashMap<LayerId, usize>,
    wants_to_be_on_top: HashSet<LayerId>,
    sublayers: HashMap<LayerId, HashSet<LayerId>>,
}

Keeps track of Areas, which are free-floating Uis. These Areas can be in any Order.

Fields

areas: IdMap<AreaState>

visible_areas_last_frame: HashSet<LayerId>

visible_areas_current_frame: HashSet<LayerId>

order: Vec<LayerId>

Back-to-front, top is last.

order_map: HashMap<LayerId, usize>

Inverse of Self::order, calculated at the end of the frame.

wants_to_be_on_top: HashSet<LayerId>

When an area wants to be on top, it is assigned here. This is used to reorder the layers at the end of the frame. If several layers want to be on top, they will keep their relative order. This means closing three windows and then reopening them all in one frame results in them being sent to the top and keeping their previous internal order.

sublayers: HashMap<LayerId, HashSet<LayerId>>

The sublayers that each layer has.

The parent sublayer is moved directly above the child sublayers in the ordering.

Implementations

impl Areas

pub(crate) fn count(&self) -> usize

pub(crate) fn get(&self, id: Id) -> Option<&AreaState>

pub(crate) fn order(&self) -> &[LayerId]

All layers back-to-front, top is last.

pub(crate) fn compare_order(&self, a: LayerId, b: LayerId) -> Ordering

Compare the order of two layers, based on the order list from last frame.

May return std::cmp::Ordering::Equal if the layers are not in the order list.

pub(crate) fn set_state(&mut self, layer_id: LayerId, state: AreaState)

pub fn layer_id_at( &self, pos: Pos2, layer_to_global: &HashMap<LayerId, TSTransform>, ) -> Option<LayerId>

Top-most layer at the given position.

pub fn visible_last_frame(&self, layer_id: &LayerId) -> bool

pub fn is_visible(&self, layer_id: &LayerId) -> bool

pub fn visible_layer_ids(&self) -> HashSet<LayerId>

pub(crate) fn visible_windows( &self, ) -> impl Iterator<Item = (LayerId, &AreaState)>

pub fn move_to_top(&mut self, layer_id: LayerId)

pub fn set_sublayer(&mut self, parent: LayerId, child: LayerId)

Mark the child layer as a sublayer of parent.

Sublayers are moved directly above the parent layer at the end of the frame. This is mainly intended for adding a new Area inside a Window.

This currently only supports one level of nesting. If parent is a sublayer of another layer, the behavior is unspecified.

The two layers must have the same LayerId::order.

pub fn top_layer_id(&self, order: Order) -> Option<LayerId>

pub fn parent_layer(&self, layer_id: LayerId) -> Option<LayerId>

If this layer is the sublayer of another layer, return the parent.

pub fn child_layers( &self, layer_id: LayerId, ) -> impl Iterator<Item = LayerId> + '_

All the child layers of this layer.

pub(crate) fn is_sublayer(&self, layer: &LayerId) -> bool

pub(crate) fn end_pass(&mut self)

Trait Implementations

impl Clone for Areas

fn clone(&self) -> Areas

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Areas

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

Formats the value using the given formatter.

impl Default for Areas

fn default() -> Areas

Returns the “default value” for a type.