Struct Window 

pub struct Window(/* private fields */);

A region containing Handles

This is like a browser tab, it can contain any number of regular and spawned Handles.

Implementations

impl Window

pub fn push_inner<W: Widget>( &self, pa: &mut Pass, widget: W, specs: PushSpecs, ) -> Handle<W>

Pushes a widget to the “buffer area” of a Window

If this Widget is being pushed to a Buffer’s group, then this Widget will be included in that Buffer’s group. This means that, if that Buffer is moved around or deleted, this Widget (and all others in its group) will follow suit.

When you push a Widget, it is placed on an edge of the area, and a new parent area may be created to hold both widgets. If created, that new area will be used for pushing widgets in the future.

This means that, if you push widget A to the left, then you push widget B to the bottom, you will get this layout:

╭───┬──────────╮
│   │          │
│ A │  Buffer  │
│   │          │
├───┴──────────┤
│      B       │
╰──────────────╯

Here’s an example of such a layout:

setup_duat!(setup);
use duat::prelude::*;

fn setup() {
    hook::remove("BufferWidgets");
    hook::add::<Buffer>(|pa, handle| {
        LineNumbers::builder().push_on(pa, handle);
        status!("{name_txt} {selections_txt} {main_txt}").push_on(pa, handle);
        Ok(())
    });
}

In this case, each buffer will have LineNumbers with relative/absolute numbering, and a StatusLine showing the buffer’s name, how many selections are in it, and its main selection.

pub fn push_outer<W: Widget>( &self, pa: &mut Pass, widget: W, specs: PushSpecs, ) -> Handle<W>

Docs: TODO

pub fn handles<'a>( &'a self, pa: &'a Pass, ) -> impl Iterator<Item = &'a Handle<dyn Widget>>

An Iterator over all Handles in a Window

Each Handle takes care of one Widget, if you want to see which one exactly is being used, you can use the Handle::try_downcast and Handle::read_as methods.

If you just want an iterator over the Buffers, then check out Window::buffers.

pub fn buffers(&self, pa: &Pass) -> Vec<Handle>

The Buffers in a single Window

They will be ordered by where the "next-buffer" command focus on. This usually follows the order by which they were created, but it can be altered if you use the "swap" command.

If you want an Iterator over all Handles, see Window::handles.

Trait Implementations

impl Clone for Window

fn clone(&self) -> Window

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl PushTarget for Window

fn try_downcast<W: Widget>(&self) -> Option<Handle<W>>

Tries to downcast to a Handle of some W

fn push_inner<PW: Widget>( &self, pa: &mut Pass, widget: PW, specs: PushSpecs, ) -> Handle<PW>

Pushes a Widget around self

fn push_outer<PW: Widget>( &self, pa: &mut Pass, widget: PW, specs: PushSpecs, ) -> Handle<PW>

Pushes a Widget around the “master region” of self