Window

A window is the core component of an application and it is the object where all events from children controls are being processed.

To create a Window use:

• Window::new method (with 3 parameters: a title, a layout and initialization flags)
• Window::with_type method (with 4 parameters: a title, a layout , initialization flags and a type)
• macro window!.

let w = Window::new("Title", layout!("x:10,y:5,w:15,h:9"),window::Flags::None);
let w2 = window!("Title,a:c,w:10,h:10");
let w3 = window!("title='Some Title',a:c,w:30,h:10,flags=[Sizeable])");
let w4 = window!("title='WithTag',a:c,w:30,h:10,tag:MyTag)");
let w5 = window!("Title,a:c,w:10,h:10,key:Alt+F10");
let w6 = window!("Title,a:c,w:10,h:10,key:auto");

Keep in mind that window will NOT handle any events from its children.

A window supports all common parameters (as they are described in Instantiate via Macros section). Besides them, the following named parameters are also accepted:

To create a window that will handle events from its children, use #[Window(...)] method:

#[Window(events=..., )]
struct MyWindow {
    // specific fields
}

A window supports the following initialization flags:

• window::Flags::None - regular window (with a close button)
• window::Flags::Sizeable or Sizeable (for window! macro) - a window that has the resize grip and the maximize button
• window::Flags::NoCloseButton or NoCloseButton (for window! macro) - a window without a close button
• window::Flags::FixedPosition or FixedPosition (for window! macro) - a window that can not be moved

the following types:

• window::Type::Classic or Classic (for window! macro) - a regular window with a classic look (double border)
• window::Type::Rounded or Rounded (for window! macro) - a window with rounded corners
• window::Type::Panel or Panel (for window! macro) - a window with a top bar and no borders

the following backgrounds:

• window::Type::Normal or Normal (for window! macro) - a regular window (using the default background color)
• window::Type::Error or Error (for window! macro) - a window with a red background to indicate an error message
• window::Type::Notification or Notification (for window! macro) - a window with a different background designed for notification messages
• window::Type::Warning or Warning (for window! macro) - a window with a different background designed for Warning messages

Methods

Besides the Common methods for all Controls a button also has the following aditional methods:

Key association

In terms of key association, a Window has two modes:

• Normal mode (for whem a window is has focus)
• Resize/Move mode (in this mode you can use arrows and various combinations to move the window)

For normal mode

OBS: Keep in mind that if any of these keys (in particular Left, Right, Up and Down) are capture by one of the children of a window, they will not pe process by the window.

For resize/move mode

Events

Window related events can be intercepted via WindowEvents trait. You will need to add WindowEvents in the list of events like in the following example:

#![allow(unused)]
fn main() {
#[Window(events=WindowEvents)]
struct MyWindow { ... }
impl WindowEvents for MyWindow { ... }
}

WindowEvents is defined in the following way:

#![allow(unused)]
fn main() {
pub trait WindowEvents {
    fn on_close(&mut self) -> EventProcessStatus {
        EventProcessStatus::Ignored
    }
    fn on_layout_changed(&mut self, old_layout: Rect, new_layout: Rect) {}
    fn on_activate(&mut self) {}
    fn on_deactivate(&mut self) {}
    fn on_accept(&mut self) {}
    fn on_cancel(&mut self) -> ActionRequest {
        ActionRequest::Allow
    }
}
}

These methods are called under the following scenarious:

Window Tags

For every window, a tag can be set for a window (a tag is a string associated with a Window that reflects its purpose). To set a tag use .set_tag("<name") method. For example, the following code:

fn main() -> Result<(), appcui::system::Error> {
    let mut app = App::new().build()?;
    let mut win = window!("Title,a:c,w:40,h:9");
    win.set_tag("TAG");
    app.add_window(win);
    app.run();
    Ok(())
}

should generate a window that looks like the following:

Window Hot Key

You can also associate a hot key to a window. A hot key allows you to quickly switch between windows. In the next example, we set up Alt+7 as a hot key for a windows.

fn main() -> Result<(), appcui::system::Error> {
    let mut app = App::new().build()?;
    let mut win = window!("Title,a:c,w:40,h:9");
    win.set_hotkey(key!("Alt+7"));
    app.add_window(win);
    app.run();
    Ok(())
}

should generate a window that looks like the following: