Where the pointer (mouse/touch) were when this widget was clicked or dragged.

None if the widget is not being interacted with.

The intrinsic / desired size of the widget.

This is the size that a non-wrapped, non-truncated, non-justified version of the widget would have.

If this is None, use egui.Response.rect instead.

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

This is not set if the view of the data was changed. For instance, moving the cursor in a TextEdit does not set this to True.

Note that this can be True even if the user did not interact with the widget, for instance if an existing slider value was clamped to the given range.

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

A click is registered when the mouse or touch is released within a certain amount of time and distance from when and where it was pressed.

This will also return true if the widget was clicked via accessibility integration, or if the widget had keyboard focus and the use pressed Space/Enter.

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

You can use egui.Response.interact to sense more things after adding a widget.

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

This will NOT return true if the widget was "clicked" via some accessibility integration, or if the widget had keyboard focus and the user pressed Space/Enter. For that, use egui.Response.clicked instead.

This will likewise ignore the press-and-hold action on touch screens. Use egui.Response.secondary_clicked instead to also detect that.

True if there was a click outside the rect of this widget.

Clicks on widgets contained in this one counts as clicks inside this widget, so that clicking a button in an area will not be considered as clicking "elsewhere" from the area.

Clicks on other layers above this widget will be considered as clicking elsewhere.

Was this widget middle-clicked or clicked while holding down a modifier key?

This is used by egui.Hyperlink to check if a URL should be opened in a new tab, using egui.OpenUrl.new_tab.

Returns true if the pointer is contained by the response rect, and no other widget is covering it.

In contrast to egui.Response.hovered, this can be True even if some other widget is being dragged. This means it is useful for styling things like drag-and-drop targets. contains_pointer can also be True for disabled widgets.

This is slightly different from Ui.rect_contains_pointer and Context.rect_contains_pointer, in that egui.Response.contains_pointer also checks that no other widget is covering this response rectangle.

Response to secondary clicks (right-clicks) by showing the given menu.

Make sure the widget senses clicks (e.g. egui.Button does, egui.Label does not).

See also: Ui.menu_button and Ui.close.

Returns whether a context menu is currently open for this widget.

See egui.Response.context_menu.

Drag-and-Drop: Return what is being held over this widget, if any.

Only returns something if egui.Response.contains_pointer is true, and the user is drag-dropping something of this type.

Drag-and-Drop: Return what is being dropped onto this widget, if any.

Only returns something if egui.Response.contains_pointer is true, the user is drag-dropping something of this type, and they released it this frame.

If the user started dragging this widget this frame, store the payload for drag-and-drop.

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

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

If dragged, how many points were we dragged in since last frame?

If dragged, how far did the mouse move since last frame?

This will use raw mouse movement if provided by the integration, otherwise will fall back to Response.drag_delta Raw mouse movement is unaccelerated and unclamped by screen boundaries, and does not relate to any position on the screen. This may be useful in certain situations such as draggable values and 3D cameras, where screen position does not matter.

Did a drag on this widget begin this frame?

This is only true if the widget sense drags. If the widget also senses clicks, this will only become true if the pointer has moved a bit.

This will only be true for a single frame.

Did a drag on this widget by the button begin this frame?

This is only true if the widget sense drags. If the widget also senses clicks, this will only become true if the pointer has moved a bit.

This will only be true for a single frame.

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

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

The widget is being dragged.

To find out which button(s), use egui.Response.dragged_by.

If the widget is only sensitive to drags, this is True as soon as the pointer presses down on it.

If the widget also senses clicks, the press could be either, so the decision is postponed until whichever of these comes first: * the pointer moves further than egui.InputOptions.max_click_dist, * it is held longer than egui.InputOptions.max_click_duration, * or it leaves the widget — a click has to be released on the widget, so once the pointer is outside, the gesture can only be a drag. This is what keeps a handle thinner than max_click_dist from spending the decision window as neither hovered nor dragged.

See egui.input_state.PointerState.is_decidedly_dragging for details.

While the decision is pending the pointer is still on the widget, so egui.Response.hovered is True throughout. If you want neither the delay nor the distinction, use egui.Response.is_pointer_button_down_on.

If the widget is NOT sensitive to drags, this will always be False. egui.DragValue senses drags; egui.Label does not (unless you call egui.Label.sense). You can use egui.Response.interact to sense more things after adding a widget.

See egui.Response.dragged.

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

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

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

This function only returns true if the UI as a whole (e.g. window) also has the keyboard focus. That makes this function suitable for style choices, e.g. a thicker border around focused widgets.

Highlight this widget, to make it look like it is hovered, even if it isn't.

The highlight takes one frame to take effect if you call this after the widget has been fully rendered.

See also Context.highlight_widget.

The widget is highlighted via a call to egui.Response.highlight or Context.highlight_widget.

If it is a good idea to show a tooltip, where is pointer?

None if the pointer is outside the response area.

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

In contrast to egui.Response.contains_pointer, this will be False whenever some other widget is being dragged. hovered is always False for disabled widgets.

While a widget is being clicked or dragged it is the only hovered widget, so this stays True even after the pointer moves off it. Together with how egui.Response.dragged resolves a press that leaves the widget, that means hovered() || dragged() holds for a whole press-drag-release gesture, which is what you want for highlighting something like a drag handle.

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

The interaction will occur on the same plane as the original widget, i.e. if the response was from a widget behind button, the interaction will also be behind that button. egui gives priority to the last added widget (the one on top gets clicked first).

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 egui.Label.sense.

Using this method on a Response that is the result of calling union on multiple Responses is undefined behavior.

Is the pointer button currently down on this widget?

This is true if the pointer is pressing down or dragging a widget, even when dragging outside the widget.

This could also be thought of as "is this widget being interacted with?".

Unlike egui.Response.dragged, this is True from the press frame onwards, with no click-versus-drag decision window.

Was the tooltip open last frame?

Associate a label with a control for accessibility.

Example

Was this long-pressed on a touch screen?

Usually you want to check egui.Response.secondary_clicked instead.

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

Report the data shown by this widget changed.

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

This should be called when the content changes, but not when the view does. So we call this when the text of a egui.TextEdit, but not when the cursor changes.

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

A click is registered when the mouse or touch is released within a certain amount of time and distance from when and where it was pressed.

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

Show this text when hovering if the widget is disabled.

Show this UI when hovering if the widget is disabled.

When hovered or dragged, use this icon for the mouse cursor.

When hovered, use this icon for the mouse cursor.

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

The text will not be visible if the widget is not enabled. For that, use egui.Response.on_disabled_hover_text instead.

If you call this multiple times the tooltips will stack underneath the previous ones.

Like on_hover_text, but show the text next to cursor.

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

The text will not be visible if the widget is not enabled. For that, use egui.Response.on_disabled_hover_ui instead.

If you call this multiple times the tooltips will stack underneath the previous ones.

The widget can contain interactive widgets, such as buttons and links. If so, it will stay open as the user moves their pointer over it. By default, the text of a tooltip is NOT selectable (i.e. interactive), but you can change this by setting [style.Interaction.selectable_labels from within the tooltip:

Like on_hover_ui, but show the ui next to cursor.

Draw a debug rectangle over the response displaying the response's id and whether it is enabled and/or hovered.

This function is intended for debugging purpose and can be useful, for example, in case of widget id instability.

Color code: - Blue: Enabled but not hovered - Green: Enabled and hovered - Red: Disabled

The Id of the parent egui.Ui that hosts this widget.

Looks up the WidgetRect from the current (or previous) pass.

Request that this widget get keyboard focus.

Adjust the scroll position until this UI becomes visible.

If align is Align.TOP it means "put the top of the rect at the top of the scroll area", etc. If align is None, it'll scroll enough to bring the UI into view.

See also: Ui.scroll_to_cursor, Ui.scroll_to_rect. Ui.scroll_with_delta.

Like egui.Response.scroll_to_me, but allows you to specify the egui.style.ScrollAnimation.

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

A click is registered when the mouse or touch is released within a certain amount of time and distance from when and where it was pressed.

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

This also returns true if the widget was pressed-and-held on a touch screen.

Set the Flags.CLOSE flag.

Can be used to e.g. signal that a container should be closed.

Set the intrinsic / desired size of the widget.

Should the container be closed?

Will e.g. be set by calling Ui.close in a child Ui or by calling egui.Response.set_close.

Always show this tooltip, even if disabled and the user isn't hovering it.

This can be used to give attention to a widget during a tutorial.

Always show this tooltip, even if disabled and the user isn't hovering it.

This can be used to give attention to a widget during a tutorial.

Surrender keyboard focus for this widget.

If dragged, how many points have we been dragged since the start of the drag?

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

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

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

The resulting egui.Response.id will come from the first (self) argument.

You may not call egui.Response.interact on the resulting Response.

For accessibility.

Call after interacting and potential calls to egui.Response.mark_changed.

Returns a response with a modified egui.Response.rect.