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.

Most likely, there is no need for run_app or run_loop after that. However, to get UI working, you have to route window events to Sciter - see the blog article.

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

Obtain a reference to Host which offers some advanced control over the Sciter engine instance.

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

Set a 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 a 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).

ZIP archives are also supported.

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

Load an HTML document from memory.

For example, HTML can be loaded from a file in compile time via include_bytes!.

pub fn get_hwnd(&self) -> HWINDOW

Get a native window handle.

pub fn collapse(&self, hide: bool)

Minimize or hide the window.

pub fn expand(&self, maximize: bool)

Show or maximize the window.

pub fn dismiss(&self)

Close the window.

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

Set a new window title.

pub fn get_title(&self) -> String

Get the native window title.

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

Set various Sciter engine options, see the Options.

pub fn set_variable(&self, path: &str, value: Value) -> Result<(), ()>

Set a window variable by its path.

See the global sciter::set_variable.

pub fn get_variable(&self, path: &str) -> Result<Value, ()>

Get a window variable by its path.

See the global sciter::get_variable.

pub fn run_app(self)

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

pub fn run_loop(self)

Run the main app message loop with the already shown window.

pub fn quit_app(&self)

Post a quit message for the app.