Struct rerun::external::eframe::egui::Frame

pub struct Frame {
    pub inner_margin: Margin,
    pub fill: Color32,
    pub stroke: Stroke,
    pub corner_radius: CornerRadius,
    pub outer_margin: Margin,
    pub shadow: Shadow,
}

A frame around some content, including margin, colors, etc.

Definitions

The total (outer) size of a frame is content_size + inner_margin + 2 * stroke.width + outer_margin.

Everything within the stroke is filled with the fill color (if any).

+-----------------^-------------------------------------- -+
|                 | outer_margin                           |
|    +------------v----^------------------------------+    |
|    |                 | stroke width                 |    |
|    |    +------------v---^---------------------+    |    |
|    |    |                | inner_margin        |    |    |
|    |    |    +-----------v----------------+    |    |    |
|    |    |    |             ^              |    |    |    |
|    |    |    |             |              |    |    |    |
|    |    |    |<------ content_size ------>|    |    |    |
|    |    |    |             |              |    |    |    |
|    |    |    |             v              |    |    |    |
|    |    |    +------- content_rect -------+    |    |    |
|    |    |                                      |    |    |
|    |    +-------------fill_rect ---------------+    |    |
|    |                                                |    |
|    +----------------- widget_rect ------------------+    |
|                                                          |
+---------------------- outer_rect ------------------------+

The four rectangles, from inside to outside, are:

• content_rect: the rectangle that is made available to the inner Ui or widget.
• fill_rect: the rectangle that is filled with the fill color (inside the stroke, if any).
• widget_rect: is the interactive part of the widget (what sense clicks etc).
• outer_rect: what is allocated in the outer Ui, and is what is returned by Response::rect.

Usage

egui::Frame::none()
    .fill(egui::Color32::RED)
    .show(ui, |ui| {
        ui.label("Label with red background");
    });

Dynamic color

If you want to change the color of the frame based on the response of the widget, you need to break it up into multiple steps:

let mut frame = egui::Frame::default().inner_margin(4.0).begin(ui);
{
    let response = frame.content_ui.label("Inside the frame");
    if response.hovered() {
        frame.frame.fill = egui::Color32::RED;
    }
}
frame.end(ui); // Will "close" the frame.

You can also respond to the hovering of the frame itself:

let mut frame = egui::Frame::default().inner_margin(4.0).begin(ui);
{
    frame.content_ui.label("Inside the frame");
    frame.content_ui.label("This too");
}
let response = frame.allocate_space(ui);
if response.hovered() {
    frame.frame.fill = egui::Color32::RED;
}
frame.paint(ui);

Note that you cannot change the margins after calling begin.

Fields

inner_margin: Margin

Margin within the painted frame.

Known as padding in CSS.

fill: Color32

The background fill color of the frame, within the Self::stroke.

Known as background in CSS.

stroke: Stroke

The width and color of the outline around the frame.

The width of the stroke is part of the total margin/padding of the frame.

corner_radius: CornerRadius

The rounding of the outer corner of the Self::stroke (or, if there is no stroke, the outer corner of Self::fill).

In other words, this is the corner radius of the widget rect.

outer_margin: Margin

Margin outside the painted frame.

Similar to what is called margin in CSS. However, egui does NOT do “Margin Collapse” like in CSS, i.e. when placing two frames next to each other, the distance between their borders is the SUM of their other margins. In CSS the distance would be the MAX of their outer margins. Supporting margin collapse is difficult, and would requires complicating the already complicated egui layout code.

Consider using crate::Spacing::item_spacing for adding space between widgets.

shadow: Shadow

Optional drop-shadow behind the frame.

Implementations

impl Frame

Constructors

pub const NONE: Frame = _

No colors, no margins, no border.

This is also the default.

pub const fn new() -> Frame

No colors, no margins, no border.

Same as Frame::NONE.

pub const fn none() -> Frame

👎Deprecated: Use Frame::NONE or Frame::new() instead.

pub fn group(style: &Style) -> Frame

For when you want to group a few widgets together within a frame.

pub fn side_top_panel(style: &Style) -> Frame

pub fn central_panel(style: &Style) -> Frame

pub fn window(style: &Style) -> Frame

pub fn menu(style: &Style) -> Frame

pub fn popup(style: &Style) -> Frame

pub fn canvas(style: &Style) -> Frame

A canvas to draw on.

In bright mode this will be very bright, and in dark mode this will be very dark.

pub fn dark_canvas(style: &Style) -> Frame

A dark canvas to draw on.

impl Frame

Builders

pub fn inner_margin(self, inner_margin: impl Into<Margin>) -> Frame

Margin within the painted frame.

Known as padding in CSS.

pub fn fill(self, fill: Color32) -> Frame

The background fill color of the frame, within the Self::stroke.

Known as background in CSS.

pub fn stroke(self, stroke: impl Into<Stroke>) -> Frame

The width and color of the outline around the frame.

The width of the stroke is part of the total margin/padding of the frame.

pub fn corner_radius(self, corner_radius: impl Into<CornerRadius>) -> Frame

The rounding of the outer corner of the Self::stroke (or, if there is no stroke, the outer corner of Self::fill).

In other words, this is the corner radius of the widget rect.

pub fn rounding(self, corner_radius: impl Into<CornerRadius>) -> Frame

👎Deprecated: Renamed to corner_radius

The rounding of the outer corner of the Self::stroke (or, if there is no stroke, the outer corner of Self::fill).

In other words, this is the corner radius of the widget rect.

pub fn outer_margin(self, outer_margin: impl Into<Margin>) -> Frame

Margin outside the painted frame.

Similar to what is called margin in CSS. However, egui does NOT do “Margin Collapse” like in CSS, i.e. when placing two frames next to each other, the distance between their borders is the SUM of their other margins. In CSS the distance would be the MAX of their outer margins. Supporting margin collapse is difficult, and would requires complicating the already complicated egui layout code.

Consider using crate::Spacing::item_spacing for adding space between widgets.

pub fn shadow(self, shadow: Shadow) -> Frame

Optional drop-shadow behind the frame.

pub fn multiply_with_opacity(self, opacity: f32) -> Frame

Opacity multiplier in gamma space.

For instance, multiplying with 0.5 will make the frame half transparent.

impl Frame

Inspectors

pub fn total_margin(&self) -> Marginf

How much extra space the frame uses up compared to the content.

Self::inner_margin + [Self.stroke].width + Self::outer_margin.

pub fn fill_rect(&self, content_rect: Rect) -> Rect

Calculate the fill_rect from the content_rect.

This is the rectangle that is filled with the fill color (inside the stroke, if any).

pub fn widget_rect(&self, content_rect: Rect) -> Rect

Calculate the widget_rect from the content_rect.

This is the visible and interactive rectangle.

pub fn outer_rect(&self, content_rect: Rect) -> Rect

Calculate the outer_rect from the content_rect.

This is what is allocated in the outer Ui, and is what is returned by Response::rect.

impl Frame

pub fn begin(self, ui: &mut Ui) -> Prepared

Begin a dynamically colored frame.

This is a more advanced API. Usually you want to use Self::show instead.

See docs for Frame for an example.

pub fn show<R>( self, ui: &mut Ui, add_contents: impl FnOnce(&mut Ui) -> R, ) -> InnerResponse<R>

Show the given ui surrounded by this frame.

pub fn show_dyn<'c, R>( self, ui: &mut Ui, add_contents: Box<dyn FnOnce(&mut Ui) -> R + 'c>, ) -> InnerResponse<R>

Show using dynamic dispatch.

pub fn paint(&self, content_rect: Rect) -> Shape

Paint this frame as a shape.

Trait Implementations

impl Clone for Frame

fn clone(&self) -> Frame

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Frame

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

Formats the value using the given formatter.

impl Default for Frame

fn default() -> Frame

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Frame

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Frame

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

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 Widget for &mut Frame

fn ui(self, ui: &mut Ui) -> Response

Allocate space, interact, paint, and return a Response.

impl Copy for Frame

impl StructuralPartialEq for Frame