Struct TooltipProps

pub struct TooltipProps {
    pub target: NodeRef,
    pub id: Option<AttrValue>,
    pub children: Children,
    pub placement: Placement,
    pub fade: bool,
    pub show: bool,
    pub trigger_on_focus: TooltipFocusTrigger,
    pub trigger_on_hover: bool,
    pub disabled: bool,
}

Fields

target: NodeRef

The node which this tooltip is attached to.

If the target can be disabled, pass the same value to Tooltip’s disabled property to ensure that the tooltip will be automatically hidden, even if it had focus, was being hovered or clicked.

id: Option<AttrValue>

ID of the tooltip.

If this is set, Tooltip will set the target’s aria-describedby attribute whenever it is visible.

children: Children

Content of the tooltip.

placement: Placement

Placement of the tooltip.

Popper’s website shows all placement options.

fade: bool

Use fade transition when showing or hiding the tooltip.

show: bool

If true, always show the tooltip, regardless of focus state.

disabled = true overrides this option.

trigger_on_focus: TooltipFocusTrigger

Show the tooltip when the target node recieves input or keyboard focus.

This defaults to TooltipFocusTrigger::Always, which always shows the tooltip on input focus. See TooltipFocusTrigger for other options which selectively disable this behaviour based on media queries, and full caveats on each.

This will not trigger on disabled elements.

Safari/WebKit focus events

Unlike most other web browsers (even on macOS), Safari and other browsers using the WebKit renderer¹ do not fire focus events for components which do not accept keyboard input (such as <a> and <button> elements) when clicked or touched, following macOS conventions.

In Safari on macOS, pressing Option + Tab will allow you to focus components that does not accept keyboard input, and will fire a focus event similarly to other platforms. If keyboard navigation is enabled in System Settings, pressing Tab cycles focus between any component (like other platforms).

Safari will fire focus and (potentially-synthetic) hover events for components which accept keyboard input (such as <input type="text">) when clicked or touched. Touchscreen devices on most other platforms will only fire focus events on touch, not hover.

---

1. Outside of the European Union, all browsers on iOS also use WebKit. ↩

trigger_on_hover: bool

Show the tooltip when the target component has the mouse cursor hovered over it.

This defaults to true, but will not trigger on disabled elements.

Note: touchscreen devices and keyboard-only users may not trigger hover events. Ensure there is some other way to trigger the tooltip on those devices, such as with trigger_on_focus={TooltipFocusTrigger::Always}.

Safari on iOS reports synthetic mouseenter events on touchscreen devices, when browsers on other platforms with touchscreens traditionally do not.

However, Safari on iOS does not fire focus events for components which do not accept keyboard input (such as <a> and <button>), so synthetic hover events are the only way to trigger tooltips.

disabled: bool

If true, always hide the tooltip. This overrides all other conditions.

The tooltip will remain part of the DOM.

Disabled elements don’t fire events, including focusout on a currently-focused element and mouseleave of a currently-hovered element. This could cause a tooltip to be “stuck” being shown.

This property allows you to automatically hide a Tooltip which has trigger_on_focus = true or trigger_on_hover = true whenever the target is disabled.

Warning: entirely removing the Tooltip from the DOM whenever the target is disabled can cause strange behaviour if the that tooltip is currently being displayed.

Trait Implementations

impl Clone for TooltipProps

fn clone(&self) -> TooltipProps

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl PartialEq for TooltipProps

fn eq(&self, other: &TooltipProps) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Properties for TooltipProps

type Builder = TooltipPropsBuilder

Builder that will be used to construct properties

fn builder() -> Self::Builder

Entrypoint for building properties

impl StructuralPartialEq for TooltipProps