23 |
31 |
32 |
--------------------------------------------------------------------------------
/packages/blitz-traits/src/devtools.rs:
--------------------------------------------------------------------------------
1 | //! Types configure developer inspection and debug tools
2 |
3 | /// Configuration for debug overlays and other debugging tools
4 | #[derive(Debug, Default, Clone, Copy)]
5 | pub struct DevtoolSettings {
6 | /// Outline elements with different border colors depending on
7 | /// inner display style of that element
8 | pub show_layout: bool,
9 | /// Render browser-style colored overlay showing the content-box,
10 | /// padding, border, and margin of the hovered element
11 | pub highlight_hover: bool,
12 | }
13 |
14 | impl DevtoolSettings {
15 | /// Toggle the [`show_layout`](Self::show_layout) setting
16 | pub fn toggle_show_layout(&mut self) {
17 | self.show_layout = !self.show_layout
18 | }
19 |
20 | /// Toggle the [`highlight_hover`](Self::highlight_hover) setting
21 | pub fn toggle_highlight_hover(&mut self) {
22 | self.highlight_hover = !self.highlight_hover
23 | }
24 | }
25 |
--------------------------------------------------------------------------------
/examples/wgpu_texture/src/main.rs:
--------------------------------------------------------------------------------
1 | use color::{OpaqueColor, Srgb};
2 | use demo_renderer::{DemoMessage, DemoPaintSource};
3 | use std::env;
4 | use wgpu::{Features, Limits};
5 |
6 | mod demo_renderer;
7 | mod dioxus_native;
8 | mod html;
9 |
10 | use dioxus_native::launch_dx_native;
11 | use html::launch_html;
12 |
13 | // CSS Styles
14 | static STYLES: &str = include_str!("./styles.css");
15 |
16 | // WGPU settings required by this example
17 | const FEATURES: Features = Features::PUSH_CONSTANTS;
18 | fn limits() -> Limits {
19 | Limits {
20 | max_push_constant_size: 16,
21 | ..Limits::default()
22 | }
23 | }
24 |
25 | type Color = OpaqueColor
24 |
30 |
25 |
29 |
26 |
28 | Embeddable
27 |{body_html}
28 |
29 |
30 | "#
31 | )
32 | }
33 |
--------------------------------------------------------------------------------
/examples/assets/docsrs_header.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
10 |
22 |
23 |
24 |
--------------------------------------------------------------------------------
/LICENSE-MIT:
--------------------------------------------------------------------------------
1 | Permission is hereby granted, free of charge, to any
2 | person obtaining a copy of this software and associated
3 | documentation files (the "Software"), to deal in the
4 | Software without restriction, including without
5 | limitation the rights to use, copy, modify, merge,
6 | publish, distribute, sublicense, and/or sell copies of
7 | the Software, and to permit persons to whom the Software
8 | is furnished to do so, subject to the following
9 | conditions:
10 |
11 | The above copyright notice and this permission notice
12 | shall be included in all copies or substantial portions
13 | of the Software.
14 |
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
16 | ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
17 | TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
18 | PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
19 | SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
20 | CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
21 | OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
22 | IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
23 | DEALINGS IN THE SOFTWARE.
--------------------------------------------------------------------------------
/apps/browser/assets/browser.css:
--------------------------------------------------------------------------------
1 |
2 | * {
3 | box-sizing: border-box;
4 | }
5 |
6 | html, body, #main, #frame {
7 | margin: 0;
8 | padding: 0;
9 | height: 100%;
10 | }
11 |
12 | #frame {
13 | display: flex;
14 | flex-direction: column;
15 | }
16 |
17 | .urlbar {
18 | padding: 6px 6px;
19 | gap: 6px;
20 | background: #F9F9F9;
21 | border-bottom: 1px solid #EEE;
22 | display: flex;
23 | }
24 |
25 | .urlbar-input {
26 | flex: 1 1 60px;
27 | border: 1px solid #CCC;
28 | border-radius: 4px;
29 | line-height: 1;
30 | padding: 6px;
31 | min-width: 60px;
32 | font-size: 14px;
33 |
34 | &:focus {
35 | border-color: #5E9ED6;
36 | outline: 1px solid #5E9ED6;
37 | }
38 | }
39 |
40 | .iconbutton {
41 | padding: 4px;
42 | cursor: pointer;
43 | border-radius: 4px;
44 |
45 | &:hover {
46 | background: #CCC;
47 | }
48 |
49 | &:active {
50 | background: #BBB;
51 | }
52 |
53 | > .urlbar-icon {
54 | height: 20px;
55 | }
56 | }
57 |
58 | .webview {
59 | flex: 1 1 0px;
60 | height: 100%;
61 | width: 100%;
62 | }
63 |
--------------------------------------------------------------------------------
/packages/blitz/Cargo.toml:
--------------------------------------------------------------------------------
1 | [package]
2 | name = "blitz"
3 | description = "High-level APIs for rendering HTML with Blitz"
4 | documentation = "https://docs.rs/blitz"
5 | version = "0.2.1"
6 | license.workspace = true
7 | homepage.workspace = true
8 | repository.workspace = true
9 | categories.workspace = true
10 | edition.workspace = true
11 | rust-version.workspace = true
12 |
13 | [features]
14 | default = ["net", "accessibility"]
15 | net = ["dep:tokio", "dep:url", "dep:blitz-net"]
16 | accessibility = ["blitz-shell/accessibility"]
17 | tracing = ["blitz-shell/tracing"]
18 |
19 | [dependencies]
20 | # Blitz dependencies
21 | anyrender_vello = { workspace = true }
22 | blitz-traits = { workspace = true }
23 | blitz-dom = { workspace = true }
24 | blitz-html = { workspace = true }
25 | blitz-shell = { workspace = true }
26 | blitz-paint = { workspace = true }
27 | blitz-net = { workspace = true, optional = true }
28 |
29 | # IO & Networking
30 | url = { workspace = true, features = ["serde"], optional = true }
31 | tokio = { workspace = true, features = ["rt-multi-thread"], optional = true }
32 |
33 | [package.metadata.docs.rs]
34 | all-features = true
35 | rustdoc-args = ["--cfg", "docsrs"]
36 |
--------------------------------------------------------------------------------
/examples/wgpu_texture/src/styles.css:
--------------------------------------------------------------------------------
1 | * {
2 | box-sizing: border-box;
3 | }
4 |
5 | html, body, main {
6 | height: 100%;
7 | font-family: system-ui, sans;
8 | margin: 0;
9 | }
10 |
11 | main {
12 | display: grid;
13 | grid-template-rows: 100px 1fr;
14 | grid-template-columns: 100%;
15 | background: #f4e8d2;
16 | }
17 |
18 | #canvas-container {
19 | display: grid;
20 | opacity: 0.8;
21 | }
22 |
23 | header {
24 | padding: 10px 40px;
25 | background-color: white;
26 | z-index: 100;
27 | }
28 |
29 | #overlay {
30 | position: absolute;
31 | width: 33%;
32 | height: 100%;
33 | right: 0;
34 | z-index: 10;
35 | background-color: rgba(0, 0, 0, 0.5);
36 | padding-top: 40%;
37 | padding-inline: 20px;
38 | color: white;
39 | }
40 |
41 | #underlay {
42 | position: absolute;
43 | width: 33%;
44 | height: 100%;
45 | z-index: -10;
46 | background-color: black;
47 | padding-top: 40%;
48 | padding-inline: 20px;
49 | color: white;
50 | }
51 |
52 | .color-control {
53 | display: flex;
54 | gap: 12px;
55 |
56 | > input {
57 | width: 150px;
58 | color: black;
59 | }
60 | }
--------------------------------------------------------------------------------
/packages/blitz-paint/Cargo.toml:
--------------------------------------------------------------------------------
1 | [package]
2 | name = "blitz-paint"
3 | description = "Paint a Blitz Document using anyrender"
4 | documentation = "https://docs.rs/blitz-paint"
5 | version = "0.2.1"
6 | license.workspace = true
7 | homepage.workspace = true
8 | repository.workspace = true
9 | categories.workspace = true
10 | edition.workspace = true
11 | rust-version.workspace = true
12 |
13 | [features]
14 | default = ["svg"]
15 | tracing = ["dep:tracing"]
16 | svg = ["dep:anyrender_svg", "dep:usvg", "blitz-dom/svg"]
17 |
18 | [dependencies]
19 | # Blitz dependencies
20 | anyrender = { workspace = true }
21 | anyrender_svg = { workspace = true, optional = true }
22 | blitz-traits = { workspace = true }
23 | blitz-dom = { workspace = true }
24 |
25 | # Servo dependencies
26 | style = { workspace = true }
27 | euclid = { workspace = true }
28 |
29 | # DioxusLabs dependencies
30 | taffy = { workspace = true }
31 |
32 | # Linebender + WGPU dependencies
33 | parley = { workspace = true }
34 | color = { workspace = true }
35 | peniko = { workspace = true }
36 | kurbo = { workspace = true }
37 | usvg = { workspace = true, optional = true }
38 |
39 | # Other dependencies
40 | tracing = { workspace = true, optional = true }
41 |
--------------------------------------------------------------------------------
/packages/blitz-dom/src/config.rs:
--------------------------------------------------------------------------------
1 | use crate::HtmlParserProvider;
2 | use blitz_traits::{
3 | navigation::NavigationProvider,
4 | net::NetProvider,
5 | shell::{ShellProvider, Viewport},
6 | };
7 | use parley::FontContext;
8 | use std::sync::Arc;
9 |
10 | /// Options used when constructing a [`BaseDocument`](crate::BaseDocument)
11 | #[derive(Default)]
12 | pub struct DocumentConfig {
13 | /// The initial `Viewport`
14 | pub viewport: Option`.
6 | #[derive(PartialEq, Eq, PartialOrd, Ord, Clone, Debug)]
7 | pub struct Attribute {
8 | /// The name of the attribute (e.g. the `class` in `
`)
9 | pub name: QualName,
10 | /// The value of the attribute (e.g. the `"test"` in `
`)
11 | pub value: String,
12 | }
13 |
14 | #[derive(Clone, Debug)]
15 | pub struct Attributes {
16 | inner: Vec,
17 | }
18 |
19 | impl Attributes {
20 | pub fn new(inner: Vec) -> Self {
21 | Self { inner }
22 | }
23 |
24 | pub fn set(&mut self, name: QualName, value: &str) {
25 | let existing_attr = self.inner.iter_mut().find(|a| a.name == name);
26 | if let Some(existing_attr) = existing_attr {
27 | existing_attr.value.clear();
28 | existing_attr.value.push_str(value);
29 | } else {
30 | self.push(Attribute {
31 | name: name.clone(),
32 | value: value.to_string(),
33 | });
34 | }
35 | }
36 |
37 | pub fn remove(&mut self, name: &QualName) -> Option {
38 | let idx = self.inner.iter().position(|attr| attr.name == *name);
39 | idx.map(|idx| self.inner.remove(idx))
40 | }
41 | }
42 |
43 | impl Deref for Attributes {
44 | type Target = Vec;
45 | fn deref(&self) -> &Self::Target {
46 | &self.inner
47 | }
48 | }
49 | impl DerefMut for Attributes {
50 | fn deref_mut(&mut self) -> &mut Self::Target {
51 | &mut self.inner
52 | }
53 | }
54 |
--------------------------------------------------------------------------------
/examples/assets/animation.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 | Google
8 |
54 |
55 |
56 |
57 |
58 |
59 |
60 |
61 |
--------------------------------------------------------------------------------
/examples/inner_html.rs:
--------------------------------------------------------------------------------
1 | use std::sync::Arc;
2 |
3 | use anyrender_vello::VelloWindowRenderer;
4 | use blitz_dom::DocumentConfig;
5 | use blitz_html::{HtmlDocument, HtmlProvider};
6 | use blitz_shell::{BlitzApplication, BlitzShellEvent, WindowConfig, create_default_event_loop};
7 |
8 | pub fn main() {
9 | // Create renderer
10 |
11 | // Parse the HTML into a Blitz document
12 | let mut doc = HtmlDocument::from_html(
13 | HTML,
14 | DocumentConfig {
15 | html_parser_provider: Some(Arc::new(HtmlProvider) as _),
16 | ..Default::default()
17 | },
18 | );
19 |
20 | let node_id = doc.query_selector("#content_area").unwrap().unwrap();
21 | doc.mutate().set_inner_html(node_id, INNER_HTML);
22 | doc.resolve(0.0);
23 |
24 | // Create the Winit application and window
25 | let event_loop = create_default_event_loop::();
26 | let mut application = BlitzApplication::new(event_loop.create_proxy());
27 | let renderer = VelloWindowRenderer::new();
28 | let window = WindowConfig::new(Box::new(doc), renderer);
29 | application.add_window(window);
30 |
31 | // Run event loop
32 | event_loop.run_app(&mut application).unwrap()
33 | }
34 |
35 | static HTML: &str = r#"
36 |
37 |
38 |
39 |
45 |
46 |
47 |
48 |
52 |
53 |
54 | "#;
55 |
56 | static INNER_HTML: &str = r#"
57 | INNER HTML TEXT HERE
58 | "#;
59 |
--------------------------------------------------------------------------------
/packages/blitz-paint/src/lib.rs:
--------------------------------------------------------------------------------
1 | //! Paint a [`blitz_dom::BaseDocument`] by pushing [`anyrender`] drawing commands into
2 | //! an impl [`anyrender::PaintScene`].
3 |
4 | #![allow(clippy::collapsible_if)]
5 |
6 | mod color;
7 | mod debug_overlay;
8 | mod gradient;
9 | mod kurbo_css;
10 | mod layers;
11 | mod render;
12 | mod sizing;
13 | mod text;
14 |
15 | use anyrender::PaintScene;
16 | use blitz_dom::BaseDocument;
17 | use layers::reset_layer_stats;
18 | use render::BlitzDomPainter;
19 |
20 | /// Paint a [`blitz_dom::BaseDocument`] by pushing drawing commands into
21 | /// an impl [`anyrender::PaintScene`].
22 | ///
23 | /// This function assumes that the styles and layout in the [`BaseDocument`] are already
24 | /// resolved. Please ensure that this is the case before trying to paint.
25 | ///
26 | /// The implementation of [`PaintScene`] is responsible for handling the commands that are pushed into it.
27 | /// Generally this will involve executing them to draw a rasterized image/texture. But in some cases it may choose to
28 | /// transform them to a vector format (e.g. SVG/PDF) or serialize them in raw form for later use.
29 | pub fn paint_scene(
30 | scene: &mut impl PaintScene,
31 | dom: &BaseDocument,
32 | scale: f64,
33 | width: u32,
34 | height: u32,
35 | ) {
36 | reset_layer_stats();
37 |
38 | let devtools = *dom.devtools();
39 | let generator = BlitzDomPainter {
40 | dom,
41 | scale,
42 | width,
43 | height,
44 | initial_x: 0.0,
45 | initial_y: 0.0,
46 | devtools,
47 | };
48 | generator.paint_scene(scene);
49 |
50 | // println!(
51 | // "Rendered using {} clips (depth: {}) (wanted: {})",
52 | // CLIPS_USED.load(atomic::Ordering::SeqCst),
53 | // CLIP_DEPTH_USED.load(atomic::Ordering::SeqCst),
54 | // CLIPS_WANTED.load(atomic::Ordering::SeqCst)
55 | // );
56 | }
57 |
--------------------------------------------------------------------------------
/packages/blitz-traits/src/navigation.rs:
--------------------------------------------------------------------------------
1 | //! Abstractions allow embedders to handle link clicks and form submissions
2 |
3 | use http::{HeaderMap, Method};
4 | use url::Url;
5 |
6 | use crate::net::{Body, Request};
7 |
8 | /// An abstraction to allow embedders to hook into "navigation events" such as clicking a link
9 | /// or submitting a form.
10 | pub trait NavigationProvider: Send + Sync + 'static {
11 | fn navigate_to(&self, options: NavigationOptions);
12 | }
13 |
14 | pub struct DummyNavigationProvider;
15 |
16 | impl NavigationProvider for DummyNavigationProvider {
17 | fn navigate_to(&self, _options: NavigationOptions) {
18 | // Default impl: do nothing
19 | }
20 | }
21 |
22 | #[non_exhaustive]
23 | #[derive(Debug, Clone)]
24 | pub struct NavigationOptions {
25 | /// The URL to navigate to
26 | pub url: Url,
27 |
28 | pub content_type: String,
29 |
30 | /// Source document for the navigation
31 | pub source_document: usize,
32 |
33 | pub method: Method,
34 |
35 | pub document_resource: Body,
36 | }
37 |
38 | impl NavigationOptions {
39 | pub fn new(url: Url, content_type: String, source_document: usize) -> Self {
40 | Self {
41 | url,
42 | content_type,
43 | source_document,
44 | method: Method::GET,
45 | document_resource: Body::Empty,
46 | }
47 | }
48 | pub fn set_document_resource(mut self, document_resource: Body) -> Self {
49 | self.document_resource = document_resource;
50 | self
51 | }
52 |
53 | pub fn set_method(mut self, method: Method) -> Self {
54 | self.method = method;
55 | self
56 | }
57 |
58 | pub fn into_request(self) -> Request {
59 | Request {
60 | url: self.url,
61 | method: self.method,
62 | content_type: self.content_type,
63 | headers: HeaderMap::new(),
64 | body: self.document_resource,
65 | }
66 | }
67 | }
68 |
--------------------------------------------------------------------------------
/packages/blitz-paint/src/kurbo_css/mod.rs:
--------------------------------------------------------------------------------
1 | //! A rounded rect closer to the browser
2 | //! Implemented in such a way that splits the border into 4 parts at the midway of each radius
3 | //!
4 | //! This object is meant to be updated only when the data changes - BezPaths are expensive!
5 | //!
6 | //! Can I just say, this is a lot of work for a border
7 | //! HTML/css is annoyingly wild
8 |
9 | use kurbo::{Insets, Vec2};
10 |
11 | mod css_box;
12 | mod non_uniform_radii;
13 |
14 | pub use css_box::CssBox;
15 | pub use non_uniform_radii::NonUniformRoundedRectRadii;
16 |
17 | #[derive(Debug, Clone, Copy)]
18 | pub enum Edge {
19 | Top,
20 | Right,
21 | Bottom,
22 | Left,
23 | }
24 |
25 | #[derive(Debug, Clone, Copy)]
26 | pub(crate) enum Corner {
27 | TopLeft,
28 | TopRight,
29 | BottomLeft,
30 | BottomRight,
31 | }
32 |
33 | #[derive(Debug, Clone, Copy, PartialEq)]
34 | #[allow(clippy::enum_variant_names, reason = "Use CSS standard terminology")]
35 | pub(crate) enum CssBoxKind {
36 | OutlineBox,
37 | BorderBox,
38 | PaddingBox,
39 | ContentBox,
40 | }
41 |
42 | #[derive(Debug, Clone, Copy)]
43 | pub(crate) enum Direction {
44 | Clockwise,
45 | Anticlockwise,
46 | }
47 |
48 | fn add_insets(a: Insets, b: Insets) -> Insets {
49 | Insets {
50 | x0: a.x0 + b.x0,
51 | y0: a.y0 + b.y0,
52 | x1: a.x1 + b.x1,
53 | y1: a.y1 + b.y1,
54 | }
55 | }
56 |
57 | #[inline(always)]
58 | fn get_corner_insets(insets: Insets, corner: Corner) -> Vec2 {
59 | match corner {
60 | Corner::TopLeft => Vec2 {
61 | x: insets.x0,
62 | y: insets.y0,
63 | },
64 | Corner::TopRight => Vec2 {
65 | x: insets.x1,
66 | y: insets.y0,
67 | },
68 | Corner::BottomLeft => Vec2 {
69 | x: insets.x0,
70 | y: insets.y1,
71 | },
72 | Corner::BottomRight => Vec2 {
73 | x: insets.x1,
74 | y: insets.y1,
75 | },
76 | }
77 | }
78 |
--------------------------------------------------------------------------------
/packages/blitz-dom/src/events/ime.rs:
--------------------------------------------------------------------------------
1 | use blitz_traits::events::{BlitzImeEvent, BlitzInputEvent, DomEvent, DomEventData};
2 |
3 | use crate::BaseDocument;
4 |
5 | pub(crate) fn handle_ime_event(
6 | doc: &mut BaseDocument,
7 | event: BlitzImeEvent,
8 | mut dispatch_event: F,
9 | ) {
10 | if let Some(node_id) = doc.focus_node_id {
11 | let node = &mut doc.nodes[node_id];
12 | let text_input_data = node
13 | .data
14 | .downcast_element_mut()
15 | .and_then(|el| el.text_input_data_mut());
16 | if let Some(input_data) = text_input_data {
17 | let editor = &mut input_data.editor;
18 | let mut font_ctx = doc.font_ctx.lock().unwrap();
19 | let mut driver = editor.driver(&mut font_ctx, &mut doc.layout_ctx);
20 |
21 | match event {
22 | BlitzImeEvent::Enabled => { /* Do nothing */ }
23 | BlitzImeEvent::Disabled => {
24 | driver.clear_compose();
25 | doc.shell_provider.request_redraw();
26 | }
27 | BlitzImeEvent::Commit(text) => {
28 | driver.insert_or_replace_selection(&text);
29 | let value = input_data.editor.raw_text().to_string();
30 | dispatch_event(DomEvent::new(
31 | node_id,
32 | DomEventData::Input(BlitzInputEvent { value }),
33 | ));
34 | doc.shell_provider.request_redraw();
35 | }
36 | BlitzImeEvent::Preedit(text, cursor) => {
37 | if text.is_empty() {
38 | driver.clear_compose();
39 | } else {
40 | driver.set_compose(&text, cursor);
41 | }
42 | doc.shell_provider.request_redraw();
43 | }
44 | }
45 | println!("Sent ime event to {node_id}");
46 | }
47 | }
48 | }
49 |
--------------------------------------------------------------------------------
/packages/dioxus-native-dom/src/lib.rs:
--------------------------------------------------------------------------------
1 | #![cfg_attr(docsrs, feature(doc_cfg))]
2 |
3 | //! Core headless native renderer for Dioxus.
4 | //!
5 | //! ## Feature flags
6 | //! - `default`: Enables the features listed below.
7 | //! - `accessibility`: Enables [`accesskit`](https://docs.rs/accesskit/latest/accesskit/) accessibility support.
8 | //! - `hot-reload`: Enables hot-reloading of Dioxus RSX.
9 | //! - `menu`: Enables the [`muda`](https://docs.rs/muda/latest/muda/) menubar.
10 | //! - `tracing`: Enables tracing support.
11 |
12 | mod dioxus_document;
13 | mod events;
14 | mod mutation_writer;
15 | mod sub_document;
16 | pub use blitz_dom::DocumentConfig;
17 | pub use dioxus_document::DioxusDocument;
18 | pub use sub_document::SubDocumentAttr;
19 |
20 | use blitz_dom::{ns, LocalName, Namespace, QualName};
21 | type NodeId = usize;
22 |
23 | pub(crate) fn qual_name(local_name: &str, namespace: Option<&str>) -> QualName {
24 | QualName {
25 | prefix: None,
26 | ns: namespace.map(Namespace::from).unwrap_or(ns!(html)),
27 | local: LocalName::from(local_name),
28 | }
29 | }
30 |
31 | // Syntax sugar to make tracing calls less noisy in function below
32 | macro_rules! trace {
33 | ($pattern:literal) => {{
34 | #[cfg(feature = "tracing")]
35 | tracing::debug!($pattern);
36 | }};
37 | ($pattern:literal, $item1:expr) => {{
38 | #[cfg(feature = "tracing")]
39 | tracing::debug!($pattern, $item1);
40 | }};
41 | ($pattern:literal, $item1:expr, $item2:expr) => {{
42 | #[cfg(feature = "tracing")]
43 | tracing::debug!($pattern, $item1, $item2);
44 | }};
45 | ($pattern:literal, $item1:expr, $item2:expr, $item3:expr) => {{
46 | #[cfg(feature = "tracing")]
47 | tracing::debug!($pattern, $item1, $item2);
48 | }};
49 | ($pattern:literal, $item1:expr, $item2:expr, $item3:expr, $item4:expr) => {{
50 | #[cfg(feature = "tracing")]
51 | tracing::debug!($pattern, $item1, $item2, $item3, $item4);
52 | }};
53 | }
54 | pub(crate) use trace;
55 |
--------------------------------------------------------------------------------
/wpt/runner/src/panic_backtrace.rs:
--------------------------------------------------------------------------------
1 | use std::backtrace::{Backtrace, BacktraceStatus};
2 | use std::{cell::Cell, panic::PanicHookInfo};
3 |
4 | thread_local! {
5 | static STASHED_PANIC_INFO: Cell> = const { Cell::new(None) };
6 | }
7 |
8 | pub fn take_stashed_panic_info() -> Option {
9 | STASHED_PANIC_INFO.take()
10 | }
11 |
12 | pub struct StashedPanicInfo {
13 | pub message: Option,
14 | pub file: String,
15 | pub line: u32,
16 | pub column: u32,
17 | pub backtrace: Backtrace,
18 | }
19 |
20 | pub fn stash_panic_handler(info: &PanicHookInfo) {
21 | let backtrace = Backtrace::force_capture();
22 | let payload = info.payload();
23 | let location = info.location().unwrap();
24 |
25 | let str_msg = payload.downcast_ref::<&str>().map(|s| s.to_string());
26 | let string_msg = payload.downcast_ref::().map(|s| s.to_owned());
27 | let message = str_msg.or(string_msg);
28 |
29 | let info = StashedPanicInfo {
30 | message,
31 | backtrace,
32 | file: location.file().to_owned(),
33 | line: location.line(),
34 | column: location.column(),
35 | };
36 |
37 | STASHED_PANIC_INFO.with(move |b| b.set(Some(info)));
38 | }
39 |
40 | #[inline(never)]
41 | pub fn backtrace_cutoff R>(cb: T) -> R {
42 | cb()
43 | }
44 |
45 | pub fn trim_backtrace(backtrace: &Backtrace) -> Option {
46 | if backtrace.status() != BacktraceStatus::Captured {
47 | return None;
48 | }
49 |
50 | let string_backtrace = backtrace.to_string();
51 | let mut filtered = String::with_capacity(string_backtrace.len());
52 | let mut started = false;
53 |
54 | for line in string_backtrace.lines() {
55 | if line.contains("wpt::panic_backtrace::backtrace_cutoff") {
56 | break;
57 | }
58 |
59 | if started {
60 | filtered.push_str(line);
61 | filtered.push('\n');
62 | }
63 |
64 | if line.contains("core::panicking::panic") {
65 | started = true;
66 | }
67 | }
68 |
69 | Some(filtered)
70 | }
71 |
--------------------------------------------------------------------------------
/packages/blitz-shell/Cargo.toml:
--------------------------------------------------------------------------------
1 | [package]
2 | name = "blitz-shell"
3 | description = "Blitz application shell"
4 | documentation = "https://docs.rs/blitz-shell"
5 | version = "0.2.2"
6 | license.workspace = true
7 | homepage.workspace = true
8 | repository.workspace = true
9 | categories.workspace = true
10 | edition.workspace = true
11 | rust-version.workspace = true
12 |
13 | [features]
14 | default = ["accessibility", "clipboard", "file_dialog"]
15 | accessibility = [
16 | "dep:accesskit",
17 | "dep:accesskit_winit",
18 | "blitz-dom/accessibility",
19 | ]
20 | clipboard = ["dep:arboard"]
21 | tracing = ["dep:tracing", "blitz-dom/tracing"]
22 | file_dialog = ["dep:rfd"]
23 | # Enables a data-uri-only NetProvider. Only needed if you aren't using the regular NetProvider
24 | data-uri = ["dep:data-url"]
25 |
26 | [dependencies]
27 | # Blitz dependencies
28 | blitz-traits = { workspace = true }
29 | blitz-dom = { workspace = true }
30 | blitz-paint = { workspace = true }
31 | anyrender = { workspace = true }
32 |
33 | # Windowing & Input
34 | winit = { workspace = true }
35 | keyboard-types = { workspace = true }
36 | accesskit = { workspace = true, optional = true }
37 | accesskit_winit = { workspace = true, optional = true }
38 |
39 | # Other dependencies
40 | tracing = { workspace = true, optional = true }
41 | futures-util = { workspace = true }
42 | data-url = { workspace = true, optional = true }
43 |
44 | [target.'cfg(target_os = "android")'.dependencies]
45 | android-activity = { version = "0.6.0", features = ["native-activity"] }
46 |
47 | [target.'cfg(any(target_os = "windows",target_os = "macos",target_os = "linux",target_os = "dragonfly", target_os = "freebsd", target_os = "netbsd", target_os = "openbsd"))'.dependencies]
48 | arboard = { workspace = true, optional = true }
49 |
50 |
51 | [target.'cfg(any(target_os = "windows",target_os = "macos",target_os = "linux",target_os = "freebsd", target_os = "dragonfly", target_os = "netbsd", target_os = "openbsd"))'.dependencies]
52 | rfd = { workspace = true, optional = true, features = ["xdg-portal", "tokio"] }
53 |
54 | [package.metadata.docs.rs]
55 | all-features = true
56 | rustdoc-args = ["--cfg", "docsrs"]
57 |
--------------------------------------------------------------------------------
/packages/blitz-paint/src/kurbo_css/non_uniform_radii.rs:
--------------------------------------------------------------------------------
1 | use kurbo::Vec2;
2 | use std::ops::{Mul, MulAssign};
3 |
4 | /// Radii for each corner of a non-uniform rounded rectangle.
5 | ///
6 | /// The use of `top` as in `top_left` assumes a y-down coordinate space. Piet
7 | /// (and Druid by extension) uses a y-down coordinate space, but Kurbo also
8 | /// supports a y-up coordinate space, in which case `top_left` would actually
9 | /// refer to the bottom-left corner, and vice versa. Top may not always
10 | /// actually be the top, but `top` corners will always have a smaller y-value
11 | /// than `bottom` corners.
12 | #[derive(Clone, Copy, Default, Debug, PartialEq)]
13 | // #[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
14 | // #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
15 | pub struct NonUniformRoundedRectRadii {
16 | /// The radii of the top-left corner.
17 | pub top_left: Vec2,
18 | /// The radii of the top-right corner.
19 | pub top_right: Vec2,
20 | /// The radii of the bottom-right corner.
21 | pub bottom_right: Vec2,
22 | /// The radii of the bottom-left corner.
23 | pub bottom_left: Vec2,
24 | }
25 |
26 | impl NonUniformRoundedRectRadii {
27 | pub fn average(&self) -> f64 {
28 | (self.top_left.x
29 | + self.top_left.y
30 | + self.top_right.x
31 | + self.top_right.y
32 | + self.bottom_left.x
33 | + self.bottom_left.y
34 | + self.bottom_right.x
35 | + self.bottom_right.y)
36 | / 8.0
37 | }
38 | }
39 |
40 | impl Mul for NonUniformRoundedRectRadii {
41 | type Output = Self;
42 |
43 | fn mul(self, rhs: f64) -> Self::Output {
44 | Self {
45 | top_left: self.top_left * rhs,
46 | top_right: self.top_right * rhs,
47 | bottom_right: self.bottom_right * rhs,
48 | bottom_left: self.bottom_left * rhs,
49 | }
50 | }
51 | }
52 |
53 | impl MulAssign for NonUniformRoundedRectRadii {
54 | fn mul_assign(&mut self, rhs: f64) {
55 | self.top_left *= rhs;
56 | self.top_right *= rhs;
57 | self.bottom_left *= rhs;
58 | self.bottom_right *= rhs;
59 | }
60 | }
61 |
--------------------------------------------------------------------------------
/packages/blitz-paint/src/layers.rs:
--------------------------------------------------------------------------------
1 | use anyrender::PaintScene;
2 | use kurbo::{Affine, Shape};
3 | use peniko::Mix;
4 | use std::sync::atomic::{AtomicUsize, Ordering};
5 |
6 | const LAYER_LIMIT: usize = 1024;
7 |
8 | static LAYERS_USED: AtomicUsize = AtomicUsize::new(0);
9 | static LAYER_DEPTH: AtomicUsize = AtomicUsize::new(0);
10 | static LAYER_DEPTH_USED: AtomicUsize = AtomicUsize::new(0);
11 | static LAYERS_WANTED: AtomicUsize = AtomicUsize::new(0);
12 |
13 | pub(crate) fn reset_layer_stats() {
14 | LAYERS_USED.store(0, Ordering::SeqCst);
15 | LAYERS_WANTED.store(0, Ordering::SeqCst);
16 | LAYER_DEPTH.store(0, Ordering::SeqCst);
17 | LAYER_DEPTH_USED.store(0, Ordering::SeqCst);
18 | }
19 |
20 | pub(crate) fn maybe_with_layer(
21 | scene: &mut S,
22 | condition: bool,
23 | opacity: f32,
24 | transform: Affine,
25 | shape: &impl Shape,
26 | paint_layer: F,
27 | ) {
28 | let layer_used = maybe_push_layer(scene, condition, opacity, transform, shape);
29 | paint_layer(scene);
30 | maybe_pop_layer(scene, layer_used);
31 | }
32 |
33 | pub(crate) fn maybe_push_layer(
34 | scene: &mut impl PaintScene,
35 | condition: bool,
36 | opacity: f32,
37 | transform: Affine,
38 | shape: &impl Shape,
39 | ) -> bool {
40 | if !condition {
41 | return false;
42 | }
43 | LAYERS_WANTED.fetch_add(1, Ordering::SeqCst);
44 |
45 | // Check if clips are above limit
46 | let layers_available = LAYERS_USED.load(Ordering::SeqCst) <= LAYER_LIMIT;
47 | if !layers_available {
48 | return false;
49 | }
50 | let blend_mode = if opacity == 1.0 {
51 | #[allow(deprecated)]
52 | Mix::Clip
53 | } else {
54 | Mix::Normal
55 | };
56 |
57 | // Actually push the clip layer
58 | scene.push_layer(blend_mode, opacity, transform, shape);
59 |
60 | // Update accounting
61 | LAYERS_USED.fetch_add(1, Ordering::SeqCst);
62 | let depth = LAYER_DEPTH.fetch_add(1, Ordering::SeqCst) + 1;
63 | LAYER_DEPTH_USED.fetch_max(depth, Ordering::SeqCst);
64 |
65 | true
66 | }
67 |
68 | pub(crate) fn maybe_pop_layer(scene: &mut impl PaintScene, condition: bool) {
69 | if condition {
70 | scene.pop_layer();
71 | LAYER_DEPTH.fetch_sub(1, Ordering::SeqCst);
72 | }
73 | }
74 |
--------------------------------------------------------------------------------
/examples/assets/border.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
63 |
64 |
65 | CSS Animation demo
8 |
45 |
46 |
47 | ,
5 | object_size: Option>,
6 | object_fit: ObjectFit,
7 | ) -> taffy::Size {
8 | match object_fit {
9 | ObjectFit::None => object_size.unwrap_or(container_size),
10 | ObjectFit::Fill => container_size,
11 | ObjectFit::Cover => compute_object_fit_cover(container_size, object_size),
12 | ObjectFit::Contain => compute_object_fit_contain(container_size, object_size),
13 | ObjectFit::ScaleDown => {
14 | let contain_size = compute_object_fit_contain(container_size, object_size);
15 | match object_size {
16 | Some(object_size) if object_size.width < contain_size.width => object_size,
17 | _ => contain_size,
18 | }
19 | }
20 | }
21 | }
22 |
23 | fn compute_object_fit_contain(
24 | container_size: taffy::Size,
25 | object_size: Option>,
26 | ) -> taffy::Size {
27 | let Some(object_size) = object_size else {
28 | return container_size;
29 | };
30 |
31 | let x_ratio = container_size.width / object_size.width;
32 | let y_ratio = container_size.height / object_size.height;
33 |
34 | let ratio = match (x_ratio < 1.0, y_ratio < 1.0) {
35 | (true, true) => x_ratio.min(y_ratio),
36 | (true, false) => x_ratio,
37 | (false, true) => y_ratio,
38 | (false, false) => x_ratio.min(y_ratio),
39 | };
40 |
41 | object_size.map(|dim| dim * ratio)
42 | }
43 |
44 | fn compute_object_fit_cover(
45 | container_size: taffy::Size,
46 | object_size: Option>,
47 | ) -> taffy::Size {
48 | let Some(object_size) = object_size else {
49 | return container_size;
50 | };
51 |
52 | let x_ratio = container_size.width / object_size.width;
53 | let y_ratio = container_size.height / object_size.height;
54 |
55 | let ratio = match (x_ratio < 1.0, y_ratio < 1.0) {
56 | (true, true) => x_ratio.max(y_ratio),
57 | (true, false) => y_ratio,
58 | (false, true) => x_ratio,
59 | (false, false) => x_ratio.max(y_ratio),
60 | };
61 |
62 | object_size.map(|dim| dim * ratio)
63 | }
64 |
--------------------------------------------------------------------------------
/apps/readme/Cargo.toml:
--------------------------------------------------------------------------------
1 | [package]
2 | name = "readme"
3 | version = "0.1.0"
4 | edition = "2024"
5 | license.workspace = true
6 | rust-version.workspace = true
7 | publish = false
8 |
9 | [features]
10 | default = ["gpu", "comrak", "floats"]
11 |
12 | # Renderers
13 | gpu = ["dep:anyrender_vello"]
14 | hybrid = ["dep:anyrender_vello_hybrid"]
15 | skia = ["dep:anyrender_skia"]
16 | skia-pixels = ["dep:anyrender_skia", "anyrender_skia/pixels_window_renderer"]
17 | skia-softbuffer = ["dep:anyrender_skia", "anyrender_skia/softbuffer_window_renderer"]
18 | cpu = ["cpu-pixels"]
19 | cpu-pixels = ["cpu-base", "anyrender_vello_cpu/pixels_window_renderer"]
20 | cpu-softbuffer = ["cpu-base", "anyrender_vello_cpu/softbuffer_window_renderer"]
21 | cpu-base = ["dep:anyrender_vello_cpu"]
22 |
23 | avif = ["dep:image", "image?/avif-native"]
24 | comrak = ["dep:comrak"]
25 | pulldown_cmark = ["dep:pulldown-cmark"]
26 | floats = ["blitz-dom/floats"]
27 | cache = ["blitz-net/cache"]
28 | log_frame_times = [
29 | "anyrender_vello_cpu?/log_frame_times",
30 | "anyrender_vello_hybrid?/log_frame_times",
31 | "anyrender_vello?/log_frame_times",
32 | "anyrender_skia?/log_frame_times",
33 | ]
34 | log_phase_times = ["blitz-dom/log_phase_times"]
35 | incremental = ["blitz-dom/incremental"]
36 |
37 | [dependencies]
38 | blitz-traits = { workspace = true }
39 | blitz-dom = { workspace = true, features = ["default", "parallel-construct"] }
40 | blitz-html = { workspace = true }
41 | blitz-paint = { workspace = true, features = ["default"] }
42 | blitz-net = { workspace = true, features = ["cookies", "debug_log"] }
43 | blitz-shell = { workspace = true, features = ["tracing", "default"] }
44 | anyrender_vello = { workspace = true, optional = true }
45 | anyrender_skia = { workspace = true, optional = true }
46 | anyrender_vello_cpu = { workspace = true, features = ["multithreading"], optional = true }
47 | anyrender_vello_hybrid = { workspace = true, optional = true }
48 |
49 | tokio = { workspace = true, features = ["rt", "rt-multi-thread"] }
50 | reqwest = { workspace = true }
51 | url = { workspace = true }
52 | winit = { workspace = true }
53 | comrak = { version = "0.49", default-features = false, optional = true }
54 | pulldown-cmark = { version = "0.13", default-features = false, features = ["html"], optional = true }
55 | image = { workspace = true, default-features = false, optional = true }
56 | notify = "8.0.0"
--------------------------------------------------------------------------------
/packages/dioxus-native/src/contexts.rs:
--------------------------------------------------------------------------------
1 | use blitz_shell::BlitzShellEvent;
2 | use dioxus_document::{Document, NoOpDocument};
3 | use winit::{event_loop::EventLoopProxy, window::WindowId};
4 |
5 | use crate::DioxusNativeEvent;
6 |
7 | pub struct DioxusNativeDocument {
8 | pub(crate) proxy: EventLoopProxy,
9 | pub(crate) window: WindowId,
10 | }
11 |
12 | impl DioxusNativeDocument {
13 | pub(crate) fn new(proxy: EventLoopProxy, window: WindowId) -> Self {
14 | Self { proxy, window }
15 | }
16 | }
17 |
18 | impl Document for DioxusNativeDocument {
19 | fn eval(&self, _js: String) -> dioxus_document::Eval {
20 | NoOpDocument.eval(_js)
21 | }
22 |
23 | fn create_head_element(
24 | &self,
25 | name: &str,
26 | attributes: &[(&str, String)],
27 | contents: Option,
28 | ) {
29 | let window = self.window;
30 | _ = self.proxy.send_event(BlitzShellEvent::embedder_event(
31 | DioxusNativeEvent::CreateHeadElement {
32 | name: name.to_string(),
33 | attributes: attributes
34 | .iter()
35 | .map(|(name, value)| (name.to_string(), value.clone()))
36 | .collect(),
37 | contents,
38 | window,
39 | },
40 | ));
41 | }
42 |
43 | fn set_title(&self, title: String) {
44 | self.create_head_element("title", &[], Some(title));
45 | }
46 |
47 | fn create_meta(&self, props: dioxus_document::MetaProps) {
48 | let attributes = props.attributes();
49 | self.create_head_element("meta", &attributes, None);
50 | }
51 |
52 | fn create_script(&self, props: dioxus_document::ScriptProps) {
53 | let attributes = props.attributes();
54 | self.create_head_element("script", &attributes, props.script_contents().ok());
55 | }
56 |
57 | fn create_style(&self, props: dioxus_document::StyleProps) {
58 | let attributes = props.attributes();
59 | self.create_head_element("style", &attributes, props.style_contents().ok());
60 | }
61 |
62 | fn create_link(&self, props: dioxus_document::LinkProps) {
63 | let attributes = props.attributes();
64 | self.create_head_element("link", &attributes, None);
65 | }
66 |
67 | fn create_head_component(&self) -> bool {
68 | true
69 | }
70 | }
71 |
--------------------------------------------------------------------------------
/examples/assets/object_fit.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
9 |
10 |
11 |
12 | 
14 | 
15 | 
16 |
17 |
19 |
20 |
21 |
22 |
24 |
25 |
26 |
27 |
28 |
29 |
31 |
32 |
33 |
34 |
36 |
37 |
38 |
39 |
41 |
42 |
43 |
44 |
45 |
46 |
48 |
49 |
50 |
51 |
52 |
53 |
54 |
--------------------------------------------------------------------------------
/packages/blitz-shell/src/event.rs:
--------------------------------------------------------------------------------
1 | use blitz_traits::navigation::NavigationOptions;
2 | use futures_util::task::ArcWake;
3 | use std::{any::Any, sync::Arc};
4 | use winit::{event_loop::EventLoopProxy, window::WindowId};
5 |
6 | #[cfg(feature = "accessibility")]
7 | use accesskit_winit::{Event as AccessKitEvent, WindowEvent as AccessKitWindowEvent};
8 |
9 | #[derive(Debug, Clone)]
10 | pub enum BlitzShellEvent {
11 | Poll {
12 | window_id: WindowId,
13 | },
14 |
15 | RequestRedraw {
16 | doc_id: usize,
17 | },
18 |
19 | /// An accessibility event from `accesskit`.
20 | #[cfg(feature = "accessibility")]
21 | Accessibility {
22 | window_id: WindowId,
23 | data: Arc,
24 | },
25 |
26 | /// An arbitary event from the Blitz embedder
27 | Embedder(Arc),
28 |
29 | /// Navigate to another URL (triggered by e.g. clicking a link)
30 | Navigate(Box),
31 |
32 | /// Navigate to another URL (triggered by e.g. clicking a link)
33 | NavigationLoad {
34 | url: String,
35 | contents: String,
36 | retain_scroll_position: bool,
37 | is_md: bool,
38 | },
39 | }
40 | impl BlitzShellEvent {
41 | pub fn embedder_event(value: T) -> Self {
42 | let boxed = Arc::new(value) as Arc;
43 | Self::Embedder(boxed)
44 | }
45 | }
46 |
47 | #[cfg(feature = "accessibility")]
48 | impl From for BlitzShellEvent {
49 | fn from(value: AccessKitEvent) -> Self {
50 | Self::Accessibility {
51 | window_id: value.window_id,
52 | data: Arc::new(value.window_event),
53 | }
54 | }
55 | }
56 |
57 | /// Create a waker that will send a poll event to the event loop.
58 | ///
59 | /// This lets the VirtualDom "come up for air" and process events while the main thread is blocked by the WebView.
60 | ///
61 | /// All other IO lives in the Tokio runtime,
62 | pub fn create_waker(proxy: &EventLoopProxy, id: WindowId) -> std::task::Waker {
63 | struct DomHandle {
64 | proxy: EventLoopProxy,
65 | id: WindowId,
66 | }
67 | impl ArcWake for DomHandle {
68 | fn wake_by_ref(arc_self: &Arc) {
69 | _ = arc_self.proxy.send_event(BlitzShellEvent::Poll {
70 | window_id: arc_self.id,
71 | })
72 | }
73 | }
74 |
75 | let proxy = proxy.clone();
76 | futures_util::task::waker(Arc::new(DomHandle { id, proxy }))
77 | }
78 |
--------------------------------------------------------------------------------
/examples/assets/pseudo.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
69 |
70 |
71 | >,
10 | }
11 |
12 | #[allow(unused)]
13 | impl DioxusNativeNetProvider {
14 | pub fn shared(proxy: EventLoopProxy) -> Arc {
15 | Arc::new(Self::new(proxy)) as Arc
16 | }
17 |
18 | pub fn new(proxy: EventLoopProxy) -> Self {
19 | let net_waker = Some(BlitzShellNetWaker::shared(proxy));
20 |
21 | #[cfg(feature = "net")]
22 | let inner_net_provider = Some(blitz_net::Provider::shared(net_waker.clone()));
23 | #[cfg(all(feature = "data-uri", not(feature = "net")))]
24 | let inner_net_provider = Some(blitz_shell::DataUriNetProvider::shared(net_waker.clone()));
25 | #[cfg(all(not(feature = "data-uri"), not(feature = "net")))]
26 | let inner_net_provider = None;
27 |
28 | Self { inner_net_provider }
29 | }
30 |
31 | pub fn with_inner(proxy: EventLoopProxy, inner: Arc) -> Self {
32 | Self {
33 | inner_net_provider: Some(inner),
34 | }
35 | }
36 |
37 | pub fn inner(&self) -> Option<&Arc> {
38 | self.inner_net_provider.as_ref()
39 | }
40 | }
41 |
42 | impl NetProvider for DioxusNativeNetProvider {
43 | fn fetch(&self, doc_id: usize, request: Request, handler: Box) {
44 | if request.url.scheme() == "dioxus" {
45 | #[allow(clippy::single_match)] // cfg'd code
46 | match dioxus_asset_resolver::native::serve_asset(request.url.path()) {
47 | Ok(res) => {
48 | #[cfg(feature = "tracing")]
49 | tracing::trace!("fetching asset from file system success {request:#?}");
50 | handler.bytes(request.url.to_string(), res.into_body().into())
51 | }
52 | Err(_) => {
53 | #[cfg(feature = "tracing")]
54 | tracing::warn!("fetching asset from file system error {request:#?}");
55 | }
56 | }
57 | } else if let Some(inner) = &self.inner_net_provider {
58 | inner.fetch(doc_id, request, handler);
59 | } else {
60 | #[cfg(feature = "tracing")]
61 | tracing::warn!("net feature not enabled, cannot fetch {request:#?}");
62 | }
63 | }
64 | }
65 |
--------------------------------------------------------------------------------
/packages/blitz-shell/src/net.rs:
--------------------------------------------------------------------------------
1 | use std::sync::Arc;
2 |
3 | use blitz_traits::net::NetWaker;
4 | use winit::event_loop::EventLoopProxy;
5 |
6 | use crate::BlitzShellEvent;
7 |
8 | /// A NetWaker that wakes up our winit event loop
9 | pub struct BlitzShellNetWaker(EventLoopProxy);
10 |
11 | impl BlitzShellNetWaker {
12 | pub fn new(proxy: EventLoopProxy) -> Self {
13 | Self(proxy)
14 | }
15 |
16 | pub fn shared(proxy: EventLoopProxy) -> Arc {
17 | Arc::new(Self(proxy))
18 | }
19 | }
20 | impl NetWaker for BlitzShellNetWaker {
21 | fn wake(&self, doc_id: usize) {
22 | self.0
23 | .send_event(BlitzShellEvent::RequestRedraw { doc_id })
24 | .unwrap()
25 | }
26 | }
27 |
28 | #[cfg(feature = "data-uri")]
29 | mod data_uri_net_provider {
30 | //! Data-URI only networking for Blitz
31 | //!
32 | //! Provides an implementation of the [`blitz_traits::net::NetProvider`] trait.
33 |
34 | use blitz_traits::net::{Bytes, NetHandler, NetProvider, NetWaker, Request};
35 | use data_url::DataUrl;
36 | use std::sync::Arc;
37 |
38 | pub struct DataUriNetProvider {
39 | #[allow(unused)]
40 | waker: Option>,
41 | }
42 | impl DataUriNetProvider {
43 | pub fn new(waker: Option>) -> Self {
44 | Self { waker }
45 | }
46 | pub fn shared(waker: Option>) -> Arc {
47 | Arc::new(Self::new(waker))
48 | }
49 | }
50 |
51 | impl NetProvider for DataUriNetProvider {
52 | fn fetch(&self, _doc_id: usize, request: Request, handler: Box) {
53 | // let callback = &self.resource_callback;
54 | match request.url.scheme() {
55 | "data" => {
56 | let Ok(data_url) = DataUrl::process(request.url.as_str()) else {
57 | // callback.call(doc_id, Err(Some(String::from("Failed to parse data uri"))));
58 | return;
59 | };
60 | let Ok(decoded) = data_url.decode_to_vec() else {
61 | // callback.call(doc_id, Err(Some(String::from("Failed to decode data uri"))));
62 | return;
63 | };
64 | let bytes = Bytes::from(decoded.0);
65 | handler.bytes(request.url.to_string(), bytes);
66 | }
67 | _ => {
68 | // callback.call(doc_id, Err(Some(String::from("UnsupportedScheme"))));
69 | }
70 | };
71 | }
72 | }
73 | }
74 | #[cfg(feature = "data-uri")]
75 | pub use data_uri_net_provider::DataUriNetProvider;
76 |
--------------------------------------------------------------------------------
/examples/assets/servo-new-reduced.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 | Servo items reduced.
7 |
8 |
9 |
10 |
11 |
12 |
13 |
50 |
51 |
52 |
--------------------------------------------------------------------------------
/examples/wgpu_texture/src/html.rs:
--------------------------------------------------------------------------------
1 | use anyrender_vello::{VelloRendererOptions, VelloWindowRenderer};
2 | use blitz_dom::{qual_name, DocumentConfig};
3 | use blitz_html::HtmlDocument;
4 | use blitz_shell::{create_default_event_loop, BlitzApplication, BlitzShellEvent, WindowConfig};
5 |
6 | use crate::{limits, DemoPaintSource, FEATURES, STYLES};
7 |
8 | pub fn launch_html() {
9 | // Create renderer
10 | let mut renderer = VelloWindowRenderer::with_options(VelloRendererOptions {
11 | features: Some(FEATURES),
12 | limits: Some(limits()),
13 | ..VelloRendererOptions::default()
14 | });
15 |
16 | // Create custom paint source and register it with the renderer
17 | let demo_paint_source = Box::new(DemoPaintSource::new());
18 | let paint_source_id = renderer.register_custom_paint_source(demo_paint_source);
19 |
20 | // Parse the HTML into a Blitz document
21 | let html = HTML.replace("{{STYLES_PLACEHOLDER}}", STYLES);
22 | let mut doc = HtmlDocument::from_html(&html, DocumentConfig::default());
23 |
24 | // Set the "src" attribute on the `
Inner HTML Demo
49 |Text set with innerHTML should appear below:
50 | 51 |hi
66 | Dioxus12312312312321
hi
67 | hi
Dioxus12312312312321
hi
68 | hi
Dioxus12312312312321
hi
69 | hi
Dioxus12312312312321
hi
70 | hi
Dioxus12312312312321
hi
71 |
72 |
73 |
--------------------------------------------------------------------------------
/examples/assets/animated_layout.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 | hi
48 | Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nam faucibus tortor orci, nec tempus nisl rhoncus nec. Suspendisse egestas dictum suscipit. Suspendisse semper lectus ex, id pretium nisl sollicitudin mattis. Morbi ligula augue, auctor in aliquet quis, venenatis consectetur enim. Mauris non ligula euismod, semper mauris nec, mattis lectus. Integer facilisis ultricies orci, a mollis velit sodales a. Sed ac nulla vitae massa rhoncus fermentum. Pellentesque maximus neque nisi, eu malesuada eros tincidunt vitae. Morbi sed condimentum risus. Ut vel dui lacinia, pulvinar odio sit amet, lacinia ligula. Sed posuere odio augue, quis maximus sapien ullamcorper nec.
49 |
50 |
51 |
--------------------------------------------------------------------------------
/justfile:
--------------------------------------------------------------------------------
1 |
2 | ## Build/lint commands
3 |
4 | check:
5 | cargo check --workspace
6 |
7 | clippy:
8 | cargo clippy --workspace
9 |
10 | fmt:
11 | cargo fmt --all
12 |
13 | small:
14 | cargo build --profile small -p counter --no-default-features --features cpu,system_fonts
15 |
16 | ## WPT test runner
17 |
18 | wpt *ARGS:
19 | cargo run --release --package wpt {{ARGS}}
20 |
21 | browser:
22 | cargo run --release --package browser
23 |
24 | browser-with-perf:
25 | cargo run --release --package browser --features log_frame_times,log_phase_times
26 |
27 | browskia:
28 | cargo run -rp browser --no-default-features --features skia,floats,incremental,cookies,cache,log_frame_times,log_phase_times
29 |
30 | ## Browser
31 |
32 | screenshot *ARGS:
33 | cargo run --release --example screenshot {{ARGS}}
34 |
35 | open *ARGS:
36 | cargo run --release --package readme --features log_frame_times,log_phase_times {{ARGS}}
37 |
38 | dev *ARGS:
39 | cargo run --package readme --features log_frame_times,log_phase_times {{ARGS}}
40 |
41 | incr *ARGS:
42 | cargo run --release --package readme --features incremental,comrak,floats,log_frame_times,log_phase_times {{ARGS}}
43 |
44 | cpu *ARGS:
45 | cargo run --release --package readme --no-default-features --features cpu,comrak,incremental,floats,log_frame_times,log_phase_times {{ARGS}}
46 |
47 | hybrid *ARGS:
48 | cargo run --release --package readme --no-default-features --features hybrid,comrak,incremental,floats,log_frame_times,log_phase_times {{ARGS}}
49 |
50 | skia *ARGS:
51 | cargo run --release --package readme --no-default-features --features skia,comrak,incremental,floats,log_frame_times,log_phase_times {{ARGS}}
52 |
53 | skia-pixels *ARGS:
54 | cargo run --release --package readme --no-default-features --features skia-pixels,comrak,floats,incremental,log_frame_times,log_phase_times {{ARGS}}
55 |
56 | skia-softbuffer *ARGS:
57 | cargo run --release --package readme --no-default-features --features skia-softbuffer,comrak,floats,incremental,log_frame_times,log_phase_times {{ARGS}}
58 |
59 | ## TodoMVC commands
60 |
61 | todomvc *ARGS:
62 | cargo run --release --package todomvc {{ARGS}}
63 |
64 | todoskia *ARGS:
65 | cargo run --release --package todomvc {{ARGS}} --no-default-features --features skia
66 |
67 | ## Ops
68 |
69 | bump *ARGS:
70 | cargo run --release --package bump {{ARGS}}
--------------------------------------------------------------------------------
/packages/blitz-paint/src/sizing.rs:
--------------------------------------------------------------------------------
1 | use style::properties::generated::longhands::object_fit::computed_value::T as ObjectFit;
2 |
3 | pub(crate) fn compute_object_fit(
4 | container_size: taffy::SizeFill
13 |
14 |
15 |
16 |
17 | Contain (50px)
18 |
19 |
20 |
21 |
22 | Cover (50px)
23 |
24 |
25 |
26 |
27 |
28 |
29 | Contain (100px)
30 |
31 |
32 |
33 |
34 | Cover (100px)
35 |
36 |
37 |
38 |
39 | Contain (200px)
40 |
41 |
42 |
43 |
44 |
45 |
46 | Cover (200px)
47 |
48 |
49 |
50 |
51 |
52 |
53 |
54 |
--------------------------------------------------------------------------------
/packages/blitz-shell/src/event.rs:
--------------------------------------------------------------------------------
1 | use blitz_traits::navigation::NavigationOptions;
2 | use futures_util::task::ArcWake;
3 | use std::{any::Any, sync::Arc};
4 | use winit::{event_loop::EventLoopProxy, window::WindowId};
5 |
6 | #[cfg(feature = "accessibility")]
7 | use accesskit_winit::{Event as AccessKitEvent, WindowEvent as AccessKitWindowEvent};
8 |
9 | #[derive(Debug, Clone)]
10 | pub enum BlitzShellEvent {
11 | Poll {
12 | window_id: WindowId,
13 | },
14 |
15 | RequestRedraw {
16 | doc_id: usize,
17 | },
18 |
19 | /// An accessibility event from `accesskit`.
20 | #[cfg(feature = "accessibility")]
21 | Accessibility {
22 | window_id: WindowId,
23 | data: ArcHello
72 |
73 | Hello
74 |
80 |
81 |
82 |
--------------------------------------------------------------------------------
/examples/restyle.rs:
--------------------------------------------------------------------------------
1 | use dioxus::prelude::*;
2 | use tokio::time::{Duration, sleep};
3 |
4 | fn main() {
5 | // Turn on the runtime and enter it
6 | let rt = tokio::runtime::Builder::new_multi_thread()
7 | .enable_all()
8 | .build()
9 | .unwrap();
10 | let _guard = rt.enter();
11 |
12 | dioxus_native::launch(app);
13 | }
14 |
15 | #[derive(Copy, Clone)]
16 | enum AnimationState {
17 | Increasing,
18 | Decreasing,
19 | }
20 |
21 | impl std::ops::Not for AnimationState {
22 | type Output = Self;
23 | fn not(self) -> Self::Output {
24 | match self {
25 | AnimationState::Increasing => AnimationState::Decreasing,
26 | AnimationState::Decreasing => AnimationState::Increasing,
27 | }
28 | }
29 | }
30 |
31 | const MIN_SIZE: i32 = 12;
32 | const MAX_SIZE: i32 = 120;
33 |
34 | fn app() -> Element {
35 | let mut size = use_signal(|| 12);
36 | let mut direction = use_signal(|| AnimationState::Increasing);
37 | let mut running = use_signal(|| true);
38 |
39 | // `use_future` will spawn an infinitely direction future that can be started and stopped
40 | use_future(move || async move {
41 | loop {
42 | if running() {
43 | match direction() {
44 | AnimationState::Increasing => size += 1,
45 | AnimationState::Decreasing => size -= 1,
46 | }
47 |
48 | let size = *size.read();
49 | if size <= MIN_SIZE {
50 | *direction.write() = AnimationState::Increasing;
51 | }
52 | if size >= MAX_SIZE {
53 | *direction.write() = AnimationState::Decreasing;
54 | }
55 | }
56 |
57 | sleep(Duration::from_millis(16)).await;
58 | }
59 | });
60 | rsx! {
61 | div {
62 | style { {STYLES} }
63 | h1 { "Current size: {size}" }
64 | div { style: "display: flex",
65 | div { class: "button", onclick: move |_| running.toggle(), "Start/Stop" }
66 | div { class: "button", onclick: move |_| size.set(12), "Reset the size" }
67 | }
68 | p { style: "font-size: {size}px", "Animate Font Size" }
69 | }
70 | }
71 | }
72 |
73 | static STYLES: &str = r#"
74 | .button {
75 | padding: 6px;
76 | border: 1px solid #999;
77 | margin-left: 12px;
78 | cursor: pointer;
79 | }
80 |
81 | .button:hover {
82 | background: #999;
83 | color: white;
84 | }
85 | "#;
86 |
--------------------------------------------------------------------------------
/packages/blitz-dom/src/stylo_to_cursor_icon.rs:
--------------------------------------------------------------------------------
1 | use cursor_icon::CursorIcon;
2 | use style::values::computed::ui::CursorKind as StyloCursorKind;
3 |
4 | pub(crate) fn stylo_to_cursor_icon(cursor: StyloCursorKind) -> CursorIcon {
5 | match cursor {
6 | StyloCursorKind::None => todo!("set the cursor to none"),
7 | StyloCursorKind::Default => CursorIcon::Default,
8 | StyloCursorKind::Pointer => CursorIcon::Pointer,
9 | StyloCursorKind::ContextMenu => CursorIcon::ContextMenu,
10 | StyloCursorKind::Help => CursorIcon::Help,
11 | StyloCursorKind::Progress => CursorIcon::Progress,
12 | StyloCursorKind::Wait => CursorIcon::Wait,
13 | StyloCursorKind::Cell => CursorIcon::Cell,
14 | StyloCursorKind::Crosshair => CursorIcon::Crosshair,
15 | StyloCursorKind::Text => CursorIcon::Text,
16 | StyloCursorKind::VerticalText => CursorIcon::VerticalText,
17 | StyloCursorKind::Alias => CursorIcon::Alias,
18 | StyloCursorKind::Copy => CursorIcon::Copy,
19 | StyloCursorKind::Move => CursorIcon::Move,
20 | StyloCursorKind::NoDrop => CursorIcon::NoDrop,
21 | StyloCursorKind::NotAllowed => CursorIcon::NotAllowed,
22 | StyloCursorKind::Grab => CursorIcon::Grab,
23 | StyloCursorKind::Grabbing => CursorIcon::Grabbing,
24 | StyloCursorKind::EResize => CursorIcon::EResize,
25 | StyloCursorKind::NResize => CursorIcon::NResize,
26 | StyloCursorKind::NeResize => CursorIcon::NeResize,
27 | StyloCursorKind::NwResize => CursorIcon::NwResize,
28 | StyloCursorKind::SResize => CursorIcon::SResize,
29 | StyloCursorKind::SeResize => CursorIcon::SeResize,
30 | StyloCursorKind::SwResize => CursorIcon::SwResize,
31 | StyloCursorKind::WResize => CursorIcon::WResize,
32 | StyloCursorKind::EwResize => CursorIcon::EwResize,
33 | StyloCursorKind::NsResize => CursorIcon::NsResize,
34 | StyloCursorKind::NeswResize => CursorIcon::NeswResize,
35 | StyloCursorKind::NwseResize => CursorIcon::NwseResize,
36 | StyloCursorKind::ColResize => CursorIcon::ColResize,
37 | StyloCursorKind::RowResize => CursorIcon::RowResize,
38 | StyloCursorKind::AllScroll => CursorIcon::AllScroll,
39 | StyloCursorKind::ZoomIn => CursorIcon::ZoomIn,
40 | StyloCursorKind::ZoomOut => CursorIcon::ZoomOut,
41 | StyloCursorKind::Auto => {
42 | // todo: we should be the ones determining this based on the UA?
43 | // https://developer.mozilla.org/en-US/docs/Web/CSS/cursor
44 |
45 | CursorIcon::Default
46 | }
47 | }
48 | }
49 |
--------------------------------------------------------------------------------
/packages/dioxus-native/src/assets.rs:
--------------------------------------------------------------------------------
1 | use blitz_shell::BlitzShellNetWaker;
2 | use std::sync::Arc;
3 |
4 | use blitz_shell::BlitzShellEvent;
5 | use blitz_traits::net::{NetHandler, NetProvider, Request};
6 | use winit::event_loop::EventLoopProxy;
7 |
8 | pub struct DioxusNativeNetProvider {
9 | inner_net_provider: Option
14 |
49 |
15 |
31 |
16 | 
17 |
20 |
17 | Embeddable
18 |Servo provides a WebView API so other applications can use it to embed web content.
19 |
21 | 
22 |
25 |
22 | Memory-safe
23 |Servo takes advantage of the memory safety features of the Rust programming language, resulting in fewer vulnerabilities related to memory and concurrency.
24 |
26 | 
27 |
30 |
27 | Modular
28 |Built with a modular architecture and powered by widely-used Rust crates, Servo makes it easier to customize and adapt a high-performance browser engine to your needs.
29 |
32 |
48 |
33 | 
34 |
37 |
34 | Parallel
35 |Servo uses concurrency and parallelism for faster and more energy-efficient rendering of web content on multi-core devices.
36 |
38 | 
39 |
42 |
39 | Cross platform
40 |Servo has multi-platform support, including Windows, macOS, Linux, Android, and OpenHarmony. In addition, Servo can be ported and adapted to embedded devices.
41 |
43 | 
44 |
47 |
44 | Independent
45 |Servo is a project managed with open governance under Linux Foundation Europe through our Technical Steering Committee.
46 |