Struct egui_modal::Modal

pub struct Modal { /* private fields */ }

A Modal is created using Modal::new(). Make sure to use a let binding when using Modal::new() to ensure you can call things like Modal::open() later on.

let modal = Modal::new(ctx, "my_modal");
modal.show(|ui| {
    ui.label("Hello world!")
});
if ui.button("modal").clicked() {
    modal.open();
}

Helper functions are also available to use that help apply margins based on the modal’s ModalStyle. They are not necessary to use, but may help reduce boilerplate.

let other_modal = Modal::new(ctx, "another_modal");
other_modal.show(|ui| {
    other_modal.frame(ui, |ui| {
        other_modal.body(ui, "Hello again, world!");
    });
    other_modal.buttons(ui, |ui| {
        other_modal.button(ui, "Close");
    });
});
if ui.button("open the other modal").clicked() {
    other_modal.open();
}

Implementations

impl Modal

pub fn new(ctx: &Context, id_source: impl Display) -> Self

Creates a new Modal. Can use constructor functions like Modal::with_style to modify upon creation.

pub fn was_outside_clicked(&self) -> bool

Was the outer overlay clicked this frame?

pub fn is_open(&self) -> bool

Is the modal currently open?

pub fn open(&self)

Open the modal; make it visible. The modal prevents user input to other parts of the application.

pub fn close(&self)

Close the modal so that it is no longer visible, allowing input to flow back into the application.

pub fn with_close_on_outside_click(self, do_close_on_click_ouside: bool) -> Self

If set to true, the modal will close itself if the user clicks outside on the modal window (onto the overlay).

pub fn with_style(self, style: &ModalStyle) -> Self

Change the ModalStyle of the modal upon creation.

pub fn title(&self, ui: &mut Ui, text: impl Into<RichText>)

Helper function for styling the title of the modal.

let modal = Modal::new(ctx, "modal");
modal.show(|ui| {
    modal.title(ui, "my title");
});

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

Helper function for styling the icon of the modal.

let modal = Modal::new(ctx, "modal");
modal.show(|ui| {
    modal.frame(ui, |ui| {
        modal.icon(ui, Icon::Info);
    });
});

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

Helper function for styling the container the of body and icon.

let modal = Modal::new(ctx, "modal");
modal.show(|ui| {
    modal.title(ui, "my title");
    modal.frame(ui, |ui| {
        // inner modal contents go here
    });
    modal.buttons(ui, |ui| {
        // button contents go here
    });
});

pub fn body_and_icon( &self, ui: &mut Ui, text: impl Into<WidgetText>, icon: Icon )

Helper function that should be used when using a body and icon together.

let modal = Modal::new(ctx, "modal");
modal.show(|ui| {
    modal.frame(ui, |ui| {
        modal.body_and_icon(ui, "my modal body", Icon::Warning);
    });
});

pub fn body(&self, ui: &mut Ui, text: impl Into<WidgetText>)

Helper function for styling the body of the modal.

let modal = Modal::new(ctx, "modal");
modal.show(|ui| {
    modal.frame(ui, |ui| {
        modal.body(ui, "my modal body");
    });
});

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

Helper function for styling the button container of the modal.

let modal = Modal::new(ctx, "modal");
modal.show(|ui| {
    modal.buttons(ui, |ui| {
        modal.button(ui, "my modal button");
    });
});

pub fn button(&self, ui: &mut Ui, text: impl Into<WidgetText>) -> Response

Helper function for creating a normal button for the modal. Automatically closes the modal on click.

pub fn caution_button( &self, ui: &mut Ui, text: impl Into<WidgetText> ) -> Response

Helper function for creating a “cautioned” button for the modal. Automatically closes the modal on click.

pub fn suggested_button( &self, ui: &mut Ui, text: impl Into<WidgetText> ) -> Response

Helper function for creating a “suggested” button for the modal. Automatically closes the modal on click.

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

The ui contained in this function will be shown within the modal window. The modal will only actually show when Modal::open is used.

pub fn open_dialog( &self, title: Option<impl Display>, body: Option<impl Display>, icon: Option<Icon> )

Open the modal as a dialog. This is a shorthand way of defining a Modal::show once, for example, if a function returns an Error. This should be used in conjunction with Modal::show_dialog. This function should be put AFTER any calls to

pub fn show_dialog(&mut self)

Needed in order to use Modal::open_dialog. Make sure this is called every frame, as it renders the necessary ui when using a modal as a dialog.