Struct egui::Response

pub struct Response {
    pub ctx: CtxRef,
    pub layer_id: LayerId,
    pub id: Id,
    pub rect: Rect,
    pub sense: Sense,
    // some fields omitted
}

The result of adding a widget to a Ui.

A Response lets you know whether or not a widget is being hovered, clicked or dragged. It also lets you easily show a tooltip on hover.

Whenever something gets added to a Ui, a Response object is returned. [ui.add] returns a Response, as does [ui.button], and all similar shortcuts.

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).

Implementations

impl Response

pub fn clicked(&self) -> bool

Returns true if this widget was clicked this frame by the primary button.

Note that the widget must be sensing clicks with Sense::click. crate::Button senses clicks; crate::Label does not (unless you call crate::Label::sense).

You can use Self::interact to sense more things after adding a widget.

pub fn clicked_by(&self, button: PointerButton) -> bool

Returns true if this widget was clicked this frame by the given button.

pub fn secondary_clicked(&self) -> bool

Returns true if this widget was clicked this frame by the secondary mouse button (e.g. the right mouse button).

pub fn middle_clicked(&self) -> bool

Returns true if this widget was clicked this frame by the middle mouse button.

pub fn double_clicked(&self) -> bool

Returns true if this widget was double-clicked this frame by the primary button.

pub fn double_clicked_by(&self, button: PointerButton) -> bool

Returns true if this widget was double-clicked this frame by the given button.

pub fn clicked_elsewhere(&self) -> bool

true if there was a click outside this widget this frame.

pub fn enabled(&self) -> bool

Was the widget enabled? If false, there was no interaction attempted and the widget should be drawn in a gray disabled look.

pub fn hovered(&self) -> bool

The pointer is hovering above this widget or the widget was clicked/tapped this frame.

pub fn has_focus(&self) -> bool

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

pub fn gained_focus(&self) -> bool

True if this widget has keyboard focus this frame, but didn’t last frame.

pub fn lost_focus(&self) -> bool

The widget had keyboard focus and lost it, either because the user pressed tab or clicked somewhere else, or (in case of a crate::TextEdit) because the user pressed enter.

let response = ui.text_edit_singleline(&mut my_text);
if response.lost_focus() && ui.input().key_pressed(egui::Key::Enter) {
    do_request(&my_text);
}

pub fn lost_kb_focus(&self) -> bool

👎 Deprecated:

Renamed to lost_focus()

pub fn request_focus(&self)

Request that this widget get keyboard focus.

pub fn surrender_focus(&self)

Surrender keyboard focus for this widget.

pub fn dragged(&self) -> bool

The widgets is being dragged.

To find out which button(s), query crate::PointerState::button_down (ui.input().pointer.button_down(…)).

Note that the widget must be sensing drags with Sense::drag. crate::DragValue senses drags; crate::Label does not (unless you call crate::Label::sense).

You can use Self::interact to sense more things after adding a widget.

pub fn dragged_by(&self, button: PointerButton) -> bool

pub fn drag_started(&self) -> bool

Did a drag on this widgets begin this frame?

pub fn drag_released(&self) -> bool

The widget was being dragged, but now it has been released.

pub fn drag_delta(&self) -> Vec2

If dragged, how many points were we dragged and in what direction?

pub fn interact_pointer_pos(&self) -> Option<Pos2>

Where the pointer (mouse/touch) were when when this widget was clicked or dragged. None if the widget is not being interacted with.

pub fn hover_pos(&self) -> Option<Pos2>

If it is a good idea to show a tooltip, where is pointer? None if the pointer is outside the response area.

pub fn is_pointer_button_down_on(&self) -> bool

Is the pointer button currently down on this widget? This is true if the pointer is pressing down or dragging a widget

pub fn changed(&self) -> bool

What the underlying data changed?

e.g. the slider was dragged, text was entered in a TextEdit etc. Always false for something like a Button. Can sometimes be true even though the data didn’t changed (e.g. if the user entered a character and erased it the same frame).

pub fn mark_changed(&mut self)

Report the data shown by this widget changed.

This must be called by widgets that represent some mutable data, e.g. checkboxes, sliders etc.

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

Show this UI if the widget was hovered (i.e. a tooltip).

The text will not be visible if the widget is not enabled. If you call this multiple times the tooltips will stack underneath the previous ones.

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

Show this UI when hovering if the widget is disabled.

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

Like on_hover_ui, but show the ui next to cursor.

pub fn on_hover_text(self, text: impl ToString) -> Self

Show this text if the widget was hovered (i.e. a tooltip).

The text will not be visible if the widget is not enabled. If you call this multiple times the tooltips will stack underneath the previous ones.

pub fn on_disabled_hover_text(self, text: impl ToString) -> Self

Show this text when hovering if the widget is disabled.

pub fn tooltip_text(self, text: impl ToString) -> Self

👎 Deprecated:

Deprecated 2020-10-01: use on_hover_text instead.

pub fn on_hover_cursor(self, cursor: CursorIcon) -> Self

When hovered, use this icon for the mouse cursor.

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

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

Note that this call will not add any hover-effects to the widget, so when possible it is better to give the widget a Sense instead, e.g. using [Label::sense].

let response = ui.label("hello");
assert!(!response.clicked()); // labels don't sense clicks by default
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);
        }
    }
});

pub fn widget_info(&self, make_info: impl Fn() -> WidgetInfo)

For accessibility.

Call after interacting and potential calls to Self::mark_changed.

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::new(&mut v.x)) | ui.add(DragValue::new(&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.

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.hovered() { ui.label("You hovered at least one of the widgets"); }

fn bitor_assign(&mut self, rhs: Self)

Performs the |= operation.

impl Clone for Response

fn clone(&self) -> Response

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Response

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

Formats the value using the given formatter.