Struct Popover 

pub struct Popover<W, V, Message> { /* private fields */ }

A floating piece of content that appears over another element.

The popover does not control its own visibility. Instead, the popover argument is an Option: Some displays the overlay (open), and None hides it (closed). The base is always present.

When the user clicks outside of the popover’s bounds, the popover notifies the application through its on_close handler.

The popover() helper wraps the popup in opaque(), so mouse button presses inside the popup’s bounds are captured and do not pass through to the elements below. Use Self::passthrough to let them fall through to the base layer, and Self::capture_scroll to also capture scroll wheel events over the popup.

Example

use iced::widget::{button, container, popover, text};

#[derive(Clone)]
enum Message {
    Close,
}

fn view(state: &State) -> impl Widget<Message> {
    // The base is always present. The `popover` argument is `Some` when the
    // popover is open and `None` when it is closed.
    popover(
        button(text("Click me!")).on_press(Message::Close),
        state.is_open.then(|| {
            container(text("This is the popover contents!")).padding(10)
        }),
    )
    .position(popover::Position::Bottom)
    .on_close(Message::Close)
}

Implementations

impl<W, V, Message> Popover<W, V, Message>

pub fn new(content: W, popup: Option<V>) -> Popover<W, V, Message>

Creates a new Popover.

It expects:

• the content widget that the popover is anchored to (the base), and
• the optional popup widget to display: Some when the popover is open and None when it is closed.

The base is always present; it is the popup argument that controls whether the overlay is displayed. By default, the Popover is positioned Position::Auto; use the Self::position method to set a specific position.

pub fn on_close(self, message: Message) -> Popover<W, V, Message>

Sets the message that will be produced when the user clicks outside of the Popover’s bounds.

This is typically how the application decides to close the popover, by setting the popover argument to None.

pub fn position(self, position: Position) -> Popover<W, V, Message>

Sets the Position of the Popover.

By default, the Popover is positioned Position::Auto, which places it on the side of the base with the most available space.

pub fn gap(self, gap: impl Into<Pixels>) -> Popover<W, V, Message>

Sets the gap between the content and its Popover.

pub fn snap_within_viewport(self, snap: bool) -> Popover<W, V, Message>

Sets whether the Popover is snapped within the viewport.

impl<W, V, Message> Popover<W, Opaque<V>, Message>

pub fn passthrough(self) -> Popover<W, V, Message>

Makes interactions on the popup of the Popover fall through to the base layer.

pub fn capture_scroll(self, capture: bool) -> Popover<W, Opaque<V>, Message>

Sets whether the scroll wheel should be captured when the cursor is over the bounds of the popup.

By default, only mouse button presses are captured. Enabling this flag also captures scroll wheel events, preventing them from passing through to the elements below.

Trait Implementations

impl<W, V, Message> Meta for Popover<W, V, Message>

fn is_void(&self) -> bool

Returns whether the Widget is Void.

impl<W, V, Message, Theme, Renderer> Widget<Message, Theme, Renderer> for Popover<W, V, Message>

where W: Widget<Message, Theme, Renderer>, V: Widget<Message, Theme, Renderer>, Message: Clone, Renderer: Renderer,

fn tag(&self) -> Tag

Returns the Tag of the Widget.

fn state(&self) -> State

Returns the State of the Widget.

fn diff(&mut self, tree: &mut Tree)

Reconciles the Widget with the provided Tree.

fn size(&self) -> Size<Length>

Returns the Size of the Widget in lengths.

fn layout(&mut self, tree: &mut Tree, renderer: &Renderer, limits: &Limits)

Lays out the Widget.

fn update( &mut self, tree: &mut Tree, event: &Event, layout: Layout, cursor: Cursor, renderer: &Renderer, shell: &mut Shell<'_, Message>, viewport: &Rectangle, )

Processes a runtime Event.

fn draw( &self, tree: &Tree, renderer: &mut Renderer, theme: &Theme, style: &Style, layout: Layout, cursor: Cursor, viewport: &Rectangle, )

Draws the Widget using the associated Renderer.

fn mouse_interaction( &self, tree: &Tree, layout: Layout, cursor: Cursor, viewport: &Rectangle, renderer: &Renderer, ) -> Interaction

Returns the current mouse::Interaction of the Widget.

fn operate( &mut self, tree: &mut Tree, layout: Layout, viewport: &Rectangle, renderer: &Renderer, operation: &mut dyn Operation, )

Applies an Operation to the Widget.

fn overlay<'b>( &'b mut self, tree: &'b mut Tree, layout: Layout, renderer: &Renderer, viewport: &Rectangle, translation: Vector, window: Size, ) -> Vec<Element<'b, Message, Theme, Renderer>>

Returns the overlays of the Widget.

fn _map<F, B>(self, f: F) -> Map<Self, F, Message>

where Self: Sized, F: Fn(Message) -> B,

Applies a transformation to the produced message of this Widget, returning a Map.

fn _boxed<'a>(self) -> Element<'a, Message, Theme, Renderer>

where Self: Sized + 'a,

Boxes this Widget, turning it into a generic Element.