Struct egui::Response

pub struct Response {
    pub ctx: CtxRef,
    pub layer_id: LayerId,
    pub id: Id,
    pub rect: Rect,
    pub sense: Sense,
    pub hovered: bool,
    pub clicked: bool,
    pub double_clicked: bool,
    pub active: bool,
    pub has_kb_focus: bool,
    pub lost_kb_focus: bool,
}

The result of adding a widget to a Ui.

This lets you know whether or not a widget has been clicked this frame. It also lets you easily show a tooltip on hover.

Fields

ctx: CtxRef

Used for optionally showing a tooltip and checking for more interactions.

layer_id: LayerId

Which layer the widget is part of.

id: Id

The Id of the widget/area this response pertains.

rect: Rect

The area of the screen we are talking about.

sense: Sense

The senses (click and/or drag) that the widget was interested in (if any).

hovered: bool

The mouse is hovering above this.

clicked: bool

The mouse clicked this thing this frame.

double_clicked: bool

The thing was double-clicked.

active: bool

The mouse is interacting with this thing (e.g. dragging it).

has_kb_focus: bool

This widget has the keyboard focus (i.e. is receiving key pressed).

lost_kb_focus: bool

The widget had keyboard focus and lost it, perhaps because the user pressed enter. If you want to do an action when a user presses enter in a text field, use this.

if ui.text_edit_singleline(&mut my_text).lost_kb_focus {
    do_request(&my_text);
}

Implementations

impl Response

pub fn on_hover_ui(self, add_contents: impl FnOnce(&mut Ui)) -> Self

Show this UI if the item was hovered (i.e. a tooltip). If you call this multiple times the tooltips will stack underneath the previous ones.

pub fn on_hover_text(self, text: impl Into<String>) -> Self

Show this text if the item was hovered (i.e. a tooltip). If you call this multiple times the tooltips will stack underneath the previous ones.

pub fn tooltip_text(self, text: impl Into<String>) -> Self

👎 Deprecated:

Deprecated 2020-10-01: use on_hover_text instead.

pub fn interact(&self, sense: Sense) -> Self

Check for more interactions (e.g. sense clicks on a Response returned from a label).

let response = ui.label("hello");
assert!(!response.clicked); // labels don't sense clicks
let response = response.interact(egui::Sense::click());
if response.clicked { /* … */ }

pub fn scroll_to_me(&self, align: Align)

Move the scroll to this UI with the specified alignment.

egui::ScrollArea::auto_sized().show(ui, |ui| {
    for i in 0..1000 {
        let response = ui.button(format!("Button {}", i));
        if response.clicked {
            response.scroll_to_me(Align::Center);
        }
    }
});

impl Response

pub fn union(&self, other: Self) -> Self

A logical "or" operation. For instance a.union(b).hovered means "was either a or b hovered?".

Trait Implementations

impl BitOr<Response> for Response

To summarize the response from many widgets you can use this pattern:

use egui::*;
fn draw_vec2(ui: &mut Ui, v: &mut Vec2) -> Response {
    ui.add(DragValue::f32(&mut v.x)) | ui.add(DragValue::f32(&mut v.y))
}

Now draw_vec2(ui, foo).hovered is true if either DragValue were hovered.

type Output = Self

The resulting type after applying the | operator.

pub fn bitor(self, rhs: Self) -> Self

Performs the | operation.

impl BitOrAssign<Response> for Response

To summarize the response from many widgets you can use this pattern:

let mut response = ui.add(widget_a);
response |= ui.add(widget_b);
response |= ui.add(widget_c);
if response.active { ui.label("You are interacting with one of the widgets"); }

pub fn bitor_assign(&mut self, rhs: Self)

Performs the |= operation.

impl Clone for Response

pub fn clone(&self) -> Response

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Response

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

Formats the value using the given formatter.