Struct Opaque 

pub struct Opaque<W> { /* private fields */ }

Wraps the given widget and captures any mouse button presses inside the bounds of the widget—effectively making it opaque.

This widget is meant to be used to mark elements in a Stack, or inside an overlay—like the popup of a Popover—to avoid mouse events from passing through to the elements below.

By default, only mouse button presses are captured. Use Self::capture_scroll to also capture scroll wheel events, so that scrolling does not pass through to the elements below.

Example

use iced::widget::{button, opaque, stack, text};

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

fn view(state: &State) -> impl Widget<Message> {
    stack![
        // This button lies below the opaque top layer: mouse events over
        // the top layer do not pass through to it.
        button("Click me!").on_press(Message::ButtonPressed),
        opaque(text("I am opaque")),
    ]
}

Implementations

impl<W> Opaque<W>

pub fn new(content: W) -> Opaque<W>

Creates a new Opaque.

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

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

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.

pub fn into_inner(self) -> W

Returns the wrapped content.

Trait Implementations

impl<'a, W, Message, Theme, Renderer> From<Opaque<W>> for Element<'a, Message, Theme, Renderer>

where Message: 'a, Theme: 'a, Renderer: 'a, W: Widget<Message, Theme, Renderer> + 'a,

fn from(opaque: Opaque<W>) -> Element<'a, Message, Theme, Renderer>

Converts to this type from the input type.

impl<W> Meta for Opaque<W>

fn is_void(&self) -> bool

Returns whether the Widget is Void.

impl<W, Message, Theme, Renderer> Widget<Message, Theme, Renderer> for Opaque<W>

where W: Widget<Message, Theme, 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 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 operate( &mut self, tree: &mut Tree, layout: Layout, viewport: &Rectangle, renderer: &Renderer, operation: &mut dyn Operation, )

Applies an Operation to 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 mouse_interaction( &self, tree: &Tree, layout: Layout, cursor: Cursor, viewport: &Rectangle, renderer: &Renderer, ) -> Interaction

Returns the current mouse::Interaction of 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.