admin
af4009374d
On a page with forge/web an ltk app had a main surface, overlays and subsurfaces, but none of what a shell such as crustace needs from the compositor: fullscreen did nothing, the app heard nothing of the other windows, an activation token it asked for never came, forge/web was never told when a launched window had shown, the shell could not speak its protocol, and the app had no way to read its own files in a browser. Each now goes through the app's connection to forge/web, in the shape of the Wayland protocol it stands for. Fullscreen. On a page with forge/web, `App::fullscreen` and `App::start_fullscreen` send a `set_fullscreen` request for the main window, as `xdg_toplevel.set_fullscreen` does, instead of doing nothing; alone on a page the canvas still takes the browser's fullscreen. `examples/web_hello.rs` gains a button that toggles it. The desktop's windows. On connecting, the backend asks for the list of toplevels, and forge/web's `toplevel_opened` and `toplevel_closed` events become `ToplevelEvent`s for `App::on_toplevel_event`, as `ext-foreign-toplevel-list-v1` does on Wayland, so a shell's dock knows which applications have windows open. Activation. The tokens an app asks for with `App::take_activation_requests` are issued before it draws: forge/web's, through its `activation_token` request, or empty without a desktop, as on Wayland without xdg-activation, and handed to `App::on_activation_token` with their messages processed. A browser app that launched others through tokens waited for one that never came. Each surface's first presented frame is reported with a `presented` request (`WebSurfaceState::presented`), so forge/web knows when a window it launched has shown and can report it activated, which dismisses crustace's splash. The shell protocol. `platform/web/shell.rs` carries the JSON a shell speaks to forge over its socket over the app's connection to forge/web: `ltk::web::shell_send( json )` sends it as a `shell` request, and each `shell` event's message reaches the listener `ltk::web::set_shell_listener` gives, as JSON. What is sent before the app has connected is kept and sent once it has, so a shell can tell forge/web its theme while it starts. An overlay's role now carries its `App::overlay_namespace`, as its layer-shell namespace does on Wayland, so forge/web can tell a shell's overlays apart. The cursor over every surface. The CSS `cursor` was set on the main surface's element only, so over an overlay the pointer kept the page's arrow. `WebSurfaceState` keeps the element that takes its input, the shape moves to that of the surface the pointer enters, and `WebPlatform::cursor` keeps the last one asked for. An app's own files. `ltk::vfs`, through which ltk reads its themes, fonts and keyboard layouts, is public: `read`, `read_to_string`, `read_dir`, `is_file` and `is_dir` read the file system natively and, in a browser, the files the page loaded into memory. `ltk::web::load_tree( base, root ).await` loads any tree served with a `MANIFEST` under `root`, and `load_resources` is that into `/ltk` with the directory made the resource directory. `ltk::time::Instant` is public too, `std`'s natively and `web_time`'s on wasm32, where `std::time::Instant::now` panics, so an app that builds for both measures time with ltk's clock. wasm-bindgen-cli. `scripts/wasm-bindgen-cli.sh TOOLS_DIR` builds wasm-bindgen-cli into `TOOLS_DIR/bin` at the version of the `wasm-bindgen` crate ltk pins in its `Cargo.toml`, from its sources with a lock resolved for Debian's rustc, which is what `make web-deps` did inline and now runs. Since `make install` copies `scripts/` into the registry, a project that builds for the browser against the installed ltk, such as forge/web or crustace, gets the same CLI without a checkout of ltk. The README and docs/architecture.md say so. Images named by their caller. Every draw through `draw_image_data` fingerprints its pixels to find them in the image caches, which for a terminal means hashing every glyph of every frame. `Canvas::draw_image_keyed( key, rgba, w, h, dest, opacity )` is `draw_image_data` with `key` naming the pixels in place of their fingerprint: every draw with the same key must pass the same pixels, which are read only when the image is not cached. Both backends' caches are keyed by `ImageId`, `Content` for a fingerprint and `Keyed` for a caller's key, so a key never names an image drawn by content even when it equals its fingerprint. `GlesCanvas` and `SoftwareCanvas` gain `draw_image_keyed`, and their `draw_image_data` and it share one private `draw_image`. Tests check that a keyed image draws as its pixels do and that a key equal to a fingerprint is another image. A held button is not also tapped. A button with `on_long_press` and no `on_drag_start` stayed a tap after its hold fired, so releasing it sent its `on_press` as well. `GestureState::long_press_msg_fired` is set when the hold fires `long_press_msg` and suppresses the press message on release; a test covers it. `CHANGELOG.md` describes these changes.
72 lines
2.4 KiB
Rust
72 lines
2.4 KiB
Rust
//! The smallest ltk app in a browser: a counter and a text field on a canvas over the whole page, on the default theme the page serves under `ltk/`. `make web-example` builds it and its resources into `target/web/`, `make web-serve` serves it at <http://localhost:8000/>.
|
|
//!
|
|
//! A web app is a library the page loads, so this example builds as a `cdylib` whose entry point is the `start` function wasm-bindgen runs when the module is loaded.
|
|
|
|
use ltk::{ App, ButtonVariant, Element, button, column, spacer, text, text_edit };
|
|
use wasm_bindgen::prelude::wasm_bindgen;
|
|
|
|
#[ derive( Clone ) ]
|
|
enum Msg
|
|
{
|
|
Press,
|
|
Edit( String ),
|
|
Submit,
|
|
Fullscreen,
|
|
}
|
|
|
|
#[ derive( Default ) ]
|
|
struct Hello
|
|
{
|
|
presses: u32,
|
|
typed: String,
|
|
submitted: String,
|
|
fullscreen: bool,
|
|
}
|
|
|
|
impl App for Hello
|
|
{
|
|
type Message = Msg;
|
|
|
|
fn app_id( &self ) -> &str { "net.liberux.ltk.Hello" }
|
|
fn save_state( &self ) -> Option<Vec<u8>> { None }
|
|
fn restore_state( &mut self, _state: Vec<u8> ) {}
|
|
fn fullscreen( &self ) -> Option<bool> { Some( self.fullscreen ) }
|
|
|
|
fn view( &self ) -> Element<Msg>
|
|
{
|
|
let palette = ltk::theme_palette();
|
|
column::<Msg>()
|
|
.spacing( 16.0 )
|
|
.push( spacer() )
|
|
.push( text( "ltk in a browser" ).size( 28.0 ).color( palette.text_primary ) )
|
|
.push( text( format!( "Pressed {} times", self.presses ) ).size( 18.0 ).color( palette.text_secondary ) )
|
|
.push( button::<Msg>( "Press" ).variant( ButtonVariant::Secondary ).on_press( Msg::Press ) )
|
|
.push( text_edit::<Msg>( "Type and press Enter", &self.typed ).fixed_width( 320.0 ).on_change( Msg::Edit ).on_submit( Msg::Submit ) )
|
|
.push( text( format!( "Submitted: {}", self.submitted ) ).size( 18.0 ).color( palette.text_secondary ) )
|
|
.push( button::<Msg>( if self.fullscreen { "Leave fullscreen" } else { "Fullscreen" } ).variant( ButtonVariant::Secondary ).on_press( Msg::Fullscreen ) )
|
|
.push( spacer() )
|
|
.into()
|
|
}
|
|
|
|
fn update( &mut self, msg: Msg )
|
|
{
|
|
match msg
|
|
{
|
|
Msg::Press => self.presses += 1,
|
|
Msg::Edit( value ) => self.typed = value,
|
|
Msg::Submit => self.submitted = std::mem::take( &mut self.typed ),
|
|
Msg::Fullscreen => self.fullscreen = !self.fullscreen,
|
|
}
|
|
}
|
|
}
|
|
|
|
#[ wasm_bindgen( start ) ]
|
|
pub async fn start()
|
|
{
|
|
if let Err( e ) = ltk::web::load_resources( "ltk" ).await
|
|
{
|
|
web_sys::console::warn_1( &format!( "ltk resources: {e}" ).into() );
|
|
}
|
|
ltk::run( Hello::default() );
|
|
}
|