Struct sciter::window::Window

pub struct Window { /* fields omitted */ }

Sciter window.

Implementations

impl Window

pub fn new() -> Window

Create a new main window.

pub fn create(rect: RECT, flags: Flags, parent: Option<HWINDOW>) -> Window

Create a new window with the specified position, flags and an optional parent window.

pub fn attach(hwnd: HWINDOW) -> Window

Attach Sciter to an existing native window.

pub fn get_host(&self) -> Rc<Host>

Obtain a reference to Host which allows you to control Sciter engine.

pub fn sciter_handler<Callback: HostHandler + Sized>(
    &mut self,
    handler: Callback
)

Set callback for Sciter engine events.

pub fn event_handler<Handler: EventHandler>(&mut self, handler: Handler)

Attach dom::EventHandler to the Sciter window.

You should install Window event handler only once - it will survive all document reloads. Also it can be registered on an empty window before the document is loaded.

pub fn archive_handler(&mut self, resource: &[u8]) -> Result<(), ()>

Register an archive produced by packfolder tool.

The resources can be accessed via the this://app/ URL.

See documentation of the Archive.

pub fn register_behavior<Factory>(&mut self, name: &str, factory: Factory) where
    Factory: Fn() -> Box<dyn EventHandler> + 'static, 

Register a native event handler for the specified behavior name.

Behavior is a named event handler which is created for a particular DOM element. In Sciter’s sense, it is a function that is called for different UI events on the DOM element. Essentially it is an analog of the WindowProc in Windows.

In HTML, there is a behavior CSS property that defines the name of a native module that is responsible for the initialization and event handling on the element. For example, by defining div { behavior:button; } you are asking all <div> elements in your markup to behave as buttons: generate BUTTON_CLICK DOM events when the user clicks on that element, and be focusable.

When the engine discovers an element having behavior: xyz; defined in its style, it sends the SC_ATTACH_BEHAVIOR host notification with the name "xyz" and an element handle to the application. You can consume the notification and respond to it yourself, or the default handler walks through the list of registered behavior factories and creates an instance of the corresponding dom::EventHandler.

Example:

struct Button;

impl sciter::EventHandler for Button {}

let mut frame = sciter::Window::new();

// register a factory method that creates a new event handler
// for each element that has "custom-button" behavior:
frame.register_behavior("custom-button", || { Box::new(Button) });

And in HTML it can be used as:

<button style="behavior: custom-button">Rusty button</button>

pub fn load_file(&mut self, uri: &str) -> bool

Load an HTML document from file.

The specified uri should be either an absolute file path or a full URL to the HTML to load.

Supported URL schemes are: http://, file://, this://app/ (when used with archive_handler).

pub fn load_html(&mut self, html: &[u8], uri: Option<&str>) -> bool

Load an HTML document from memory.

pub fn get_hwnd(&self) -> HWINDOW

Get native window handle.

pub fn collapse(&self, hide: bool)

Minimize or hide window.

pub fn expand(&self, maximize: bool)

Show or maximize window.

pub fn dismiss(&self)

Close window.

pub fn set_title(&mut self, title: &str)

Set title of native window.

pub fn get_title(&self) -> String

Get native window title.

pub fn set_options(&self, options: Options) -> Result<(), ()>

Set various Sciter engine options, see the Options.

pub fn run_app(self)

Show window and run the main app message loop until window been closed.

pub fn run_loop(&self)

Run the main app message loop with already configured window.

pub fn quit_app(&self)

Post app quit message.