Struct wayland_window::DecoratedSurface [] [src]

pub struct DecoratedSurface {
    // some fields omitted
}

A wrapper for a decorated surface.

This is the main object of this crate. It wraps a user provided wayland surface into a ShellSurface and gives you acces to it via the .get_shell() method.

It also handles the drawing of minimalistic borders allowing the resizing and moving of the window. See the root documentation of this crate for explanations about how to use it.

Methods

impl DecoratedSurface

fn resize(&mut self, width: i32, height: i32)

Resizes the borders to given width and height.

These values should be the dimentions of the internal surface of the window (the decorated window will thus be a little larger).

fn new(surface: &WlSurface, width: i32, height: i32, compositor: &WlCompositor, subcompositor: &WlSubcompositor, shm: &WlShm, shell: &WlShell, seat: Option<WlSeat>) -> Result<DecoratedSurface, ()>

Creates a new decorated window around given surface.

fn set_title(&self, title: String)

Set a short title for the surface.

This string may be used to identify the surface in a task bar, window list, or other user interface elements provided by the compositor.

fn set_class(&self, class: String)

Set a class for the surface.

The surface class identifies the general class of applications to which the surface belongs. A common convention is to use the file name (or the full path if it is a non-standard location) of the application's .desktop file as the class.

Trait Implementations

impl Iterator for DecoratedSurface

type Item = (WlShellSurfaceResize, i32, i32)

fn next(&mut self) -> Option<(WlShellSurfaceResize, i32, i32)>

1.0.0fn size_hint(&self) -> (usize, Option<usize>)

1.0.0fn count(self) -> usize

1.0.0fn last(self) -> Option<Self::Item>

1.0.0fn nth(&mut self, n: usize) -> Option<Self::Item>

1.0.0fn chain<U>(self, other: U) -> Chain<Self, U::IntoIter> where U: IntoIterator<Item=Self::Item>

1.0.0fn zip<U>(self, other: U) -> Zip<Self, U::IntoIter> where U: IntoIterator

1.0.0fn map<B, F>(self, f: F) -> Map<Self, F> where F: FnMut(Self::Item) -> B

1.0.0fn filter<P>(self, predicate: P) -> Filter<Self, P> where P: FnMut(&Self::Item) -> bool

1.0.0fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F> where F: FnMut(Self::Item) -> Option<B>

1.0.0fn enumerate(self) -> Enumerate<Self>

1.0.0fn peekable(self) -> Peekable<Self>

1.0.0fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P> where P: FnMut(&Self::Item) -> bool

1.0.0fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P> where P: FnMut(&Self::Item) -> bool

1.0.0fn skip(self, n: usize) -> Skip<Self>

1.0.0fn take(self, n: usize) -> Take<Self>

1.0.0fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F> where F: FnMut(&mut St, Self::Item) -> Option<B>

1.0.0fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F> where F: FnMut(Self::Item) -> U, U: IntoIterator

1.0.0fn fuse(self) -> Fuse<Self>

1.0.0fn inspect<F>(self, f: F) -> Inspect<Self, F> where F: FnMut(&Self::Item) -> ()

1.0.0fn by_ref(&mut self) -> &mut Self

1.0.0fn collect<B>(self) -> B where B: FromIterator<Self::Item>

1.0.0fn partition<B, F>(self, f: F) -> (B, B) where B: Default + Extend<Self::Item>, F: FnMut(&Self::Item) -> bool

1.0.0fn fold<B, F>(self, init: B, f: F) -> B where F: FnMut(B, Self::Item) -> B

1.0.0fn all<F>(&mut self, f: F) -> bool where F: FnMut(Self::Item) -> bool

1.0.0fn any<F>(&mut self, f: F) -> bool where F: FnMut(Self::Item) -> bool

1.0.0fn find<P>(&mut self, predicate: P) -> Option<Self::Item> where P: FnMut(&Self::Item) -> bool

1.0.0fn position<P>(&mut self, predicate: P) -> Option<usize> where P: FnMut(Self::Item) -> bool

1.0.0fn rposition<P>(&mut self, predicate: P) -> Option<usize> where Self: ExactSizeIterator + DoubleEndedIterator, P: FnMut(Self::Item) -> bool

1.0.0fn max(self) -> Option<Self::Item> where Self::Item: Ord

1.0.0fn min(self) -> Option<Self::Item> where Self::Item: Ord

fn max_by<B, F>(self, f: F) -> Option<Self::Item> where F: FnMut(&Self::Item) -> B, B: Ord

1.6.0fn max_by_key<B, F>(self, f: F) -> Option<Self::Item> where B: Ord, F: FnMut(&Self::Item) -> B

fn min_by<B, F>(self, f: F) -> Option<Self::Item> where B: Ord, F: FnMut(&Self::Item) -> B

1.6.0fn min_by_key<B, F>(self, f: F) -> Option<Self::Item> where B: Ord, F: FnMut(&Self::Item) -> B

1.0.0fn rev(self) -> Rev<Self> where Self: DoubleEndedIterator

1.0.0fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where FromB: Default + Extend<B>, FromA: Default + Extend<A>, Self: Iterator<Item=(A, B)>

1.0.0fn cloned<'a, T>(self) -> Cloned<Self> where Self: Iterator<Item=&'a T>, T: 'a + Clone

1.0.0fn cycle(self) -> Cycle<Self> where Self: Clone

fn sum<S>(self) -> S where S: Add<Self::Item, Output=S> + Zero

fn product<P>(self) -> P where P: Mul<Self::Item, Output=P> + One

1.5.0fn cmp<I>(self, other: I) -> Ordering where I: IntoIterator<Item=Self::Item>, Self::Item: Ord

1.5.0fn partial_cmp<I>(self, other: I) -> Option<Ordering> where I: IntoIterator, Self::Item: PartialOrd<I::Item>

1.5.0fn eq<I>(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialEq<I::Item>

1.5.0fn ne<I>(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialEq<I::Item>

1.5.0fn lt<I>(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialOrd<I::Item>

1.5.0fn le<I>(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialOrd<I::Item>

1.5.0fn gt<I>(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialOrd<I::Item>

1.5.0fn ge<I>(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialOrd<I::Item>