blitz-pdf 0.1.7 → 0.1.9

package/src/worker-protocol.ts

@@ -1,10 +1,10 @@
 import type { RenderOptions } from "./render.js";
 
 export type HostMessage =
-  | { type: "render"; module: WebAssembly.Module; html: string; options: RenderOptions; external: boolean }
-  | { type: "assets"; data: Uint8Array[] };
+  | { type: "render"; id: number; module: WebAssembly.Module; html: string; options: RenderOptions; external: boolean }
+  | { type: "assets"; id: number; data: Uint8Array[] };
 
 export type WorkerMessage =
-  | { type: "assets"; urls: string[] }
-  | { type: "done"; pdf: Uint8Array }
-  | { type: "error"; error: unknown };
+  | { type: "assets"; id: number; urls: string[] }
+  | { type: "done"; id: number; pdf: Uint8Array }
+  | { type: "error"; id: number; error: unknown };

package/src/worker-runtime.ts

@@ -7,29 +7,43 @@ export interface WorkerEndpoint {
   onMessage(handler: (message: HostMessage) => void): void;
 }
 
-/** Worker side of `renderPdfInWorker`: one render per worker; asset bytes come from the host. */
+/** One document at a time; retain the initialized engine and its bundled-font cache. */
 export function serve(endpoint: WorkerEndpoint): void {
+  let initialized = false;
+  let activeId: number | undefined;
   let receiveAssets: ((data: Uint8Array[]) => void) | undefined;
   endpoint.onMessage(async message => {
     if (message.type === "assets") {
+      if (message.id !== activeId) return;
       const receive = receiveAssets;
       receiveAssets = undefined;
       receive?.(message.data);
       return;
     }
+    if (activeId !== undefined) {
+      endpoint.post({ type: "error", id: message.id, error: new Error("Worker already has an active document") }, []);
+      return;
+    }
+    activeId = message.id;
     try {
-      initSync({ module: message.module });
+      if (!initialized) {
+        initSync({ module: message.module });
+        initialized = true;
+      }
       const load = message.external
         ? (urls: string[]) => new Promise<Uint8Array[]>(resolve => {
           receiveAssets = resolve;
-          endpoint.post({ type: "assets", urls }, []);
+          endpoint.post({ type: "assets", id: message.id, urls }, []);
         })
         : undefined;
       const pdf = await render(message.html, message.options, load);
-      endpoint.post({ type: "done", pdf }, [pdf.buffer as ArrayBuffer]);
+      endpoint.post({ type: "done", id: message.id, pdf }, [pdf.buffer as ArrayBuffer]);
     } catch (error) {
-      try { endpoint.post({ type: "error", error }, []); }
-      catch { endpoint.post({ type: "error", error: new Error(String(error)) }, []); }
+      try { endpoint.post({ type: "error", id: message.id, error }, []); }
+      catch { endpoint.post({ type: "error", id: message.id, error: new Error(String(error)) }, []); }
+    } finally {
+      activeId = undefined;
+      receiveAssets = undefined;
     }
   });
 }

package/vendor/README.md

@@ -1,6 +1,20 @@
+# Upstream versions
+
+Checked against upstream on 2026-10-21:
+
+- Blitz DOM and paint: `0.3.0-beta.4`, revision
+  `f8723f495c7c6bfb611a923a21ed5c8e0fe95d55` from `DioxusLabs/blitz` main.
+  All sibling Blitz crates use the same revision and its Taffy pin
+  `4e59968eda29ceeb0bbaeb3993c8cd38baa3d0a6`.
+- Stylo `0.22.0`, Krilla `0.8.2`, and Fontique `0.12.0` are the latest
+  published crates.io releases. Their sources were compared with the release
+  archives to confirm that only the patches and packaging files below differ.
+
 # Stylo paged-media patch
 
-`stylo/` is the unmodified crates.io `stylo` 0.22.0 source except for:
+`stylo/` contains the crates.io `stylo` 0.22.0 source (original crate checksum
+`7a255e46af2478628c48daab3774090caabd7812b1dd3ca98801c2b9c53491ed`),
+with the following changes:
 
 - `properties/longhands.toml`: enable `break-before`, `break-after`, and
   `break-inside` and the `@page size` descriptor for Servo; add inherited
@@ -44,7 +58,7 @@ Node/browser checks, and `npm run test:pdfa` against the rebuilt WASM.
 # Blitz print layout patch
 
 `blitz-dom/` contains `packages/blitz-dom` from Blitz revision
-`e72650a6e67941852fddf025295cfee30c39ea32`, with its MIT/Apache-2.0 licenses.
+`f8723f495c7c6bfb611a923a21ed5c8e0fe95d55`, with its MIT/Apache-2.0 licenses.
 Its standalone manifest expands the upstream workspace dependencies and pins
 the sibling Blitz crates to the same revision.
 
@@ -54,11 +68,11 @@ the sibling Blitz crates to the same revision.
   The PDF body and margin templates disable rounding and supply the exact
   printable dimensions, including after CSS page setup changes them. Layout,
   transforms, painting, and pagination share the resulting geometry.
-- `layout/construct.rs`: use baseline alignment for the root of an inline
+- `layout/inline/build.rs`: use baseline alignment for the root of an inline
   formatting context. A table cell's `vertical-align: middle` aligns the cell
   content within its row; applying it again to its own text inflated every line.
   Descendant inline alignment and the cell's placement remain intact.
-- `layout/inline.rs`: let empty inline contexts compute their size and margin
+- `layout/inline/layout.rs`: let empty inline contexts compute their size and margin
   collapse normally. The empty-text shortcut prevented margins from collapsing
   through paragraphs containing empty spans and discarded explicit heights.
 - `layout/table.rs`: keep `max-width` as an intrinsic measurement constraint,
@@ -79,7 +93,7 @@ table columns, anonymous cells, and inheritance after CSS page-size changes.
 # Blitz Unicode paint notifications
 
 `blitz-paint/` contains `packages/blitz-paint` from Blitz revision
-`e72650a6e67941852fddf025295cfee30c39ea32`, with its MIT/Apache-2.0 licenses.
+`f8723f495c7c6bfb611a923a21ed5c8e0fe95d55`, with its MIT/Apache-2.0 licenses.
 Its standalone manifest expands the upstream workspace dependencies and pins
 sibling crates to the same revision.
 

package/vendor/blitz-dom/Cargo.toml

@@ -2,7 +2,7 @@
 name = "blitz-dom"
 description = "Blitz DOM implementation"
 documentation = "https://docs.rs/blitz-dom"
-version = "0.3.0-beta.3"
+version = "0.3.0-beta.4"
 license = "MIT OR Apache-2.0"
 homepage = "https://github.com/dioxuslabs/blitz"
 repository = "https://github.com/dioxuslabs/blitz"
@@ -45,9 +45,9 @@ log-phase-times = ["debug_timer/enable"]
 
 [dependencies]
 # Blitz dependencies
-blitz-traits = { version = "=0.3.0-beta.3", default-features = false, git = "https://github.com/DioxusLabs/blitz", rev = "e72650a6e67941852fddf025295cfee30c39ea32" }
-stylo_taffy = { version = "=0.3.0-beta.3", default-features = false, git = "https://github.com/DioxusLabs/blitz", rev = "e72650a6e67941852fddf025295cfee30c39ea32", features = ["default"] }
-debug_timer = { version = "0.1.2", git = "https://github.com/DioxusLabs/blitz", rev = "e72650a6e67941852fddf025295cfee30c39ea32" }
+blitz-traits = { version = "=0.3.0-beta.4", default-features = false, git = "https://github.com/DioxusLabs/blitz", rev = "f8723f495c7c6bfb611a923a21ed5c8e0fe95d55" }
+stylo_taffy = { version = "=0.3.0-beta.4", default-features = false, git = "https://github.com/DioxusLabs/blitz", rev = "f8723f495c7c6bfb611a923a21ed5c8e0fe95d55", features = ["default"] }
+debug_timer = { version = "0.1.2", git = "https://github.com/DioxusLabs/blitz", rev = "f8723f495c7c6bfb611a923a21ed5c8e0fe95d55" }
 
 # Servo dependencies
 style = { version = "0.22.0", package = "stylo" }
@@ -64,7 +64,7 @@ smallvec = { version = "1" }
 thin-vec = { version = "0.2" }
 
 # DioxusLabs dependencies
-taffy = { git = "https://github.com/DioxusLabs/taffy", rev = "6c2106e3df79493d304f954dc2cd4a4a382981d3", default-features = false, features = ["std", "flexbox", "flexbox_balance", "grid", "block_layout", "content_size", "calc", "detailed_layout_info"] }
+taffy = { git = "https://github.com/DioxusLabs/taffy", rev = "4e59968eda29ceeb0bbaeb3993c8cd38baa3d0a6", default-features = false, features = ["std", "flexbox", "flexbox_balance", "grid", "block_layout", "content_size", "calc", "detailed_layout_info"] }
 anyrender = { version = "0.14.0", optional = true }
 
 # Linebender/Fontations dependencies
@@ -100,7 +100,7 @@ percent-encoding = { version = "2.3.1" }
 url = { version = "2.5.0" }
 
 # Input
-keyboard-types = { version = "0.7" }
+keyboard-types = { version = "0.8" }
 cursor-icon = { version = "1" }
 thread_local = { version = "1" }
 

package/vendor/blitz-dom/src/accessibility.rs

@@ -1,4 +1,6 @@
-use crate::{BaseDocument, ElementData, Node as BlitzDomNode, local_name};
+use crate::{
+    BaseDocument, ElementData, Node as BlitzDomNode, NodeData, NodeId as BlitzDomNodeId, local_name,
+};
 use accesskit::{Node as AccessKitNode, NodeId, Role, TreeId, TreeInfo, TreeUpdate};
 use style::properties::longhands::visibility;
 
@@ -7,6 +9,8 @@ impl BaseDocument {
         let mut nodes = std::collections::HashMap::new();
         let mut window = AccessKitNode::new(Role::Window);
         let mut hidden_nodes = std::collections::HashSet::new();
+        let mut labelled_by_nodes = Vec::new();
+        let mut described_by_nodes = Vec::new();
 
         self.visit(|node_id, node| {
             if node.is_hidden_from_accessibility_tree()
@@ -25,9 +29,57 @@ impl BaseDocument {
                 .unwrap_or(&mut window);
             let (id, builder) = self.build_accessibility_node(node, parent);
 
+            if node.attr(local_name!("aria-labelledby")).is_some() {
+                labelled_by_nodes.push(node_id);
+            }
+            if node.attr(local_name!("aria-describedby")).is_some() {
+                described_by_nodes.push(node_id);
+            }
             nodes.insert(node_id, (id, builder));
         });
 
+        let mut label = FlatText::default();
+        for node_id in labelled_by_nodes {
+            let Some(id_refs) = self.nodes[node_id].attr(local_name!("aria-labelledby")) else {
+                continue;
+            };
+            let Some((id, mut builder)) = nodes.remove(&node_id) else {
+                continue;
+            };
+            let mut has_target = false;
+            label.clear();
+            for target in self.referenced_dom_ids_to_node_ids(id_refs) {
+                if !has_target {
+                    builder.clear_labelled_by();
+                    has_target = true;
+                }
+                if target == node_id || nodes.contains_key(&target) {
+                    builder.push_labelled_by(NodeId(target.as_u64()));
+                }
+                self.nodes[target].write_text_alternative(&mut label);
+                label.break_word();
+            }
+            if !label.text.is_empty() {
+                builder.set_label(label.text.as_str());
+            }
+            nodes.insert(node_id, (id, builder));
+        }
+
+        for node_id in described_by_nodes {
+            let Some(id_refs) = self.nodes[node_id].attr(local_name!("aria-describedby")) else {
+                continue;
+            };
+            let Some((id, mut builder)) = nodes.remove(&node_id) else {
+                continue;
+            };
+            for target in self.referenced_dom_ids_to_node_ids(id_refs) {
+                if target == node_id || nodes.contains_key(&target) {
+                    builder.push_described_by(NodeId(target.as_u64()));
+                }
+            }
+            nodes.insert(node_id, (id, builder));
+        }
+
         let mut nodes: Vec<_> = nodes
             .into_iter()
             .map(|(_, (id, node))| (id, node))
@@ -43,6 +95,15 @@ impl BaseDocument {
         }
     }
 
+    fn referenced_dom_ids_to_node_ids<'a>(
+        &'a self,
+        nodes_reference: &'a str,
+    ) -> impl Iterator<Item = BlitzDomNodeId> + 'a {
+        nodes_reference
+            .split_ascii_whitespace()
+            .filter_map(|dom_id| self.nodes_to_id.get(dom_id)?.first().copied())
+    }
+
     fn build_accessibility_node(
         &self,
         node: &BlitzDomNode,
@@ -65,12 +126,48 @@ impl BaseDocument {
                 .unwrap_or(Role::Unknown);
 
             builder.set_role(role);
-            builder.set_html_tag(name);
 
             // https://www.w3.org/TR/wai-aria-1.2/#tree_exclusion
             if element_data.attr(local_name!("aria-hidden")) == Some("true") {
                 builder.set_hidden();
             }
+
+            if let Some(aria_expanded) = element_data.attr(local_name!("aria-expanded"))
+                && let Ok(aria_expanded) = aria_expanded.parse()
+            {
+                builder.set_expanded(aria_expanded);
+            }
+
+            if element_data.attr(local_name!("aria-disabled")) == Some("true") {
+                builder.set_disabled();
+            }
+
+            if let Some(aria_selected) = element_data.attr(local_name!("aria-selected"))
+                && let Ok(aria_selected) = aria_selected.parse()
+            {
+                builder.set_selected(aria_selected);
+            }
+
+            if let Some(aria_label) = element_data.attr(local_name!("aria-label")) {
+                builder.set_label(aria_label);
+            }
+            if let Some(aria_description) = element_data.attr(local_name!("aria-description")) {
+                builder.set_description(aria_description);
+            }
+            if let Some(aria_level) = element_data.attr(local_name!("aria-level"))
+                && let Ok(aria_level) = aria_level.parse::<usize>()
+                // Accesskit levels are 0-based, while ARIA levels are 1-based
+                // See https://docs.rs/accesskit/latest/accesskit/struct.Node.html#method.level
+                && let Some(aria_level) = aria_level.checked_sub(1)
+            {
+                builder.set_level(aria_level);
+            } else if let Some(default_level) = default_level_for_tag(&name) {
+                builder.set_level(default_level);
+            } else if let Some(default_level) = default_level_for_role(role) {
+                builder.set_level(default_level);
+            }
+
+            builder.set_html_tag(name);
         } else if node.is_text_node() {
             builder.set_role(Role::TextRun);
             builder.set_value(node.text_content());
@@ -96,6 +193,59 @@ impl BlitzDomNode {
             })
             .unwrap_or(false)
     }
+
+    fn write_text_alternative(&self, out: &mut FlatText) {
+        match self
+            .attr(local_name!("aria-label"))
+            .filter(|aria_label| !aria_label.trim_ascii().is_empty())
+        {
+            Some(aria_label) => out.push(aria_label),
+            None => self.write_flat_text_content(out),
+        }
+    }
+
+    fn write_flat_text_content(&self, out: &mut FlatText) {
+        match &self.data {
+            NodeData::Text(data) => out.push(&data.content),
+            NodeData::Element(..) | NodeData::AnonymousBlock(..) => {
+                for &child_id in &self.children {
+                    self.with(child_id).write_flat_text_content(out);
+                }
+            }
+            _ => {}
+        }
+    }
+}
+
+#[derive(Default)]
+struct FlatText {
+    text: String,
+    pending_space: bool,
+}
+
+impl FlatText {
+    fn push(&mut self, text: &str) {
+        for (i, word) in text.split(|c: char| c.is_ascii_whitespace()).enumerate() {
+            self.pending_space |= i > 0;
+            if word.is_empty() {
+                continue;
+            }
+            if self.pending_space && !self.text.is_empty() {
+                self.text.push(' ');
+            }
+            self.pending_space = false;
+            self.text.push_str(word);
+        }
+    }
+
+    fn break_word(&mut self) {
+        self.pending_space = true;
+    }
+
+    fn clear(&mut self) {
+        self.text.clear();
+        self.pending_space = false;
+    }
 }
 
 fn role_from_name(name: &str) -> Option<Role> {
@@ -162,6 +312,29 @@ fn role_from_name(name: &str) -> Option<Role> {
     }
 }
 
+fn default_level_for_tag(name: &str) -> Option<usize> {
+    // Accesskit levels are 0-based, while ARIA levels are 1-based
+    // See https://docs.rs/accesskit/latest/accesskit/struct.Node.html#method.level
+    match name {
+        "h1" => Some(0),
+        "h2" => Some(1),
+        "h3" => Some(2),
+        "h4" => Some(3),
+        "h5" => Some(4),
+        "h6" => Some(5),
+        _ => None,
+    }
+}
+
+fn default_level_for_role(role: Role) -> Option<usize> {
+    match role {
+        // ARIA specifies an implicit level of 2 for the heading role. Accesskit levels are 0-based,
+        // so this turns into level 1
+        Role::Heading => Some(1),
+        _ => None,
+    }
+}
+
 fn role_from_element_data(element_data: &ElementData) -> Option<Role> {
     // <https://www.w3.org/TR/html-aam-1.0/>
     match &*element_data.name.local {

package/vendor/blitz-dom/src/config.rs

@@ -10,20 +10,18 @@ use style::media_queries::MediaType;
 
 /// Strategy for Stylo's style traversal during `resolve`.
 ///
-/// Two `Document`s resolving on [`StyleThreading::Parallel`] concurrently
-/// share Stylo's global thread pool and can panic with
-/// `already mutably borrowed` — see
-/// <https://github.com/DioxusLabs/blitz/issues/430>. Set
-/// [`StyleThreading::Sequential`] on documents that may resolve from a
-/// user thread while another `Parallel` resolve is in flight.
+/// `Parallel` traversals are serialised process-wide (Stylo's global pool can
+/// only run one traversal at a time), so documents resolving from several
+/// threads never run their style traversals concurrently but also never
+/// overlap: it only pays off when a single thread resolves all documents
+/// (e.g. a UI thread, including nested sub-documents).
 #[derive(Default, Clone, Copy, PartialEq, Eq, Debug)]
 pub enum StyleThreading {
     /// Use Stylo's parallel traversal via its global rayon thread pool.
-    /// Fastest for a single document; panics if another `Parallel` resolve
-    /// is in flight on a different thread.
     Parallel,
     /// Run style traversal sequentially on the calling thread, bypassing
-    /// the global pool. Safe to use from many user threads concurrently.
+    /// the global pool and its lock. Threads resolving their own documents
+    /// run independently of each other.
     #[default]
     Sequential,
 }
@@ -57,7 +55,7 @@ pub struct DocumentConfig {
     /// Defaults to [`MediaType::screen`].
     pub media_type: Option<MediaType>,
     /// Strategy for Stylo's style traversal.
-    /// Defaults to [`StyleThreading::Parallel`].
+    /// Defaults to [`StyleThreading::Sequential`].
     pub style_threading: StyleThreading,
     /// Whether incremental layout is enabled. Defaults to `true`.
     ///

package/vendor/blitz-dom/src/document.rs

@@ -954,6 +954,21 @@ impl BaseDocument {
         if self.focus_node_id == Some(node_id) {
             let shell_provider = self.shell_provider.clone();
             self.nodes[node_id].blur(shell_provider);
+            // Nothing on the chain contains the focus anymore. Only the surviving
+            // ancestors need a snapshot for restyling: nodes in the removed subtree had
+            // theirs dropped already and may be freed entirely.
+            let mut maybe_id = Some(node_id);
+            while let Some(node) = maybe_id.and_then(|id| self.get_node(id)) {
+                let id = node.id;
+                maybe_id = node.parent;
+                if node.flags.is_in_document() {
+                    self.snapshot_node_and(id, ElementState::FOCUS_WITHIN, |node| {
+                        node.remove_focus_within()
+                    });
+                } else {
+                    self.nodes[id].remove_focus_within();
+                }
+            }
             self.focus_node_id = None;
         }
         if self.mousedown_node_id == Some(node_id) {
@@ -1699,7 +1714,13 @@ impl BaseDocument {
             self.snapshot_node_and(id, ElementState::FOCUS | ElementState::FOCUSRING, |node| {
                 node.blur(shell_provider)
             });
+            for &ancestor in self.node_element_ancestors(id).iter() {
+                self.snapshot_node_and(ancestor, ElementState::FOCUS_WITHIN, |node| {
+                    node.remove_focus_within()
+                });
+            }
             self.focus_node_id = None;
+            self.shell_provider.request_redraw();
         }
     }
 
@@ -1713,6 +1734,10 @@ impl BaseDocument {
         if Some(focus_node_id) == self.focus_node_id {
             return false;
         }
+        // A node that is not in the document cannot be focused
+        if !self.nodes[focus_node_id].flags.is_in_document() {
+            return false;
+        }
 
         #[cfg(feature = "tracing")]
         tracing::info!("Focussed node {focus_node_id}");
@@ -1733,8 +1758,32 @@ impl BaseDocument {
             |node| node.focus(shell_provider),
         );
 
+        // Update :focus-within on the ancestor chains (shared prefix stays)
+        let old_node_path = self.maybe_node_element_ancestors(self.focus_node_id);
+        let new_node_path = self.node_element_ancestors(focus_node_id);
+        let same_count = old_node_path
+            .iter()
+            .zip(&new_node_path)
+            .take_while(|(o, n)| o == n)
+            .count();
+        for &id in old_node_path.iter().skip(same_count) {
+            self.snapshot_node_and(id, ElementState::FOCUS_WITHIN, |node| {
+                node.remove_focus_within()
+            });
+        }
+        for &id in new_node_path.iter().skip(same_count) {
+            self.snapshot_node_and(id, ElementState::FOCUS_WITHIN, |node| {
+                node.add_focus_within()
+            });
+        }
+
         self.focus_node_id = Some(focus_node_id);
 
+        // The focus is styled (:focus, :focus-visible, :focus-within), so
+        // moving it changes what is on screen. Nothing else asks for the
+        // frame: a keyboard focus change touches no layout and no content.
+        self.shell_provider.request_redraw();
+
         true
     }
 
@@ -2211,11 +2260,15 @@ impl BaseDocument {
         // Prefer the precise hit node: `cursor` and `user-select` may be set on
         // a pseudo-element or resolved on an anonymous box, and text hits carry
         // is_text via the hit node. Fall back to the canonical hover node if
-        // the hit node has been removed (it is transient across resolves).
-        let node_id = self
+        // the hit node has been removed (it is transient across resolves), and
+        // to the default cursor if the pointer is over no box.
+        let Some(node_id) = self
             .hover_hit_node_id
             .filter(|&id| self.nodes.contains_key(id))
-            .or(self.get_hover_node_id())?;
+            .or(self.get_hover_node_id())
+        else {
+            return Some(CursorIcon::Default);
+        };
         let node = &self.nodes[node_id];
 
         if let Some(subdoc) = node.subdoc().map(|doc| doc.inner())
@@ -2953,6 +3006,16 @@ mod hover_state_tests {
         assert_eq!(doc.get_hover_node_id(), Some(container));
         assert_eq!(doc.get_cursor(), Some(CursorIcon::Default));
     }
+
+    /// Hovering below the content hits no box: default cursor (`None` would hide it).
+    #[test]
+    fn hovering_below_content_reports_default_cursor() {
+        let (mut doc, _) = make_doc();
+
+        doc.set_hover_to(5.0, 250.0);
+        assert_eq!(doc.get_hover_node_id(), None);
+        assert_eq!(doc.get_cursor(), Some(CursorIcon::Default));
+    }
 }
 
 #[cfg(test)]

package/vendor/blitz-dom/src/events/keyboard.rs

@@ -5,7 +5,7 @@ use blitz_traits::{
     SmolStr,
     events::{BlitzInputEvent, BlitzKeyEvent, DomEvent, DomEventData},
 };
-use keyboard_types::{Key, Modifiers};
+use keyboard_types::{Key, Modifiers, NamedKey};
 use markup5ever::local_name;
 
 pub(super) enum KeyboardOrTextInputEvent {
@@ -20,9 +20,8 @@ pub(crate) fn handle_key_or_input_event<F: FnMut(DomEvent)>(
     mut dispatch_event: F,
 ) {
     if let KeyboardOrTextInputEvent::KeyPress(event) = &event {
-        if event.key == Key::Tab {
+        if event.key == Key::Named(NamedKey::Tab) {
             let backwards = event.modifiers.contains(Modifiers::SHIFT);
-            let old_focus = doc.focus_node_id;
             generate_focus_events(
                 doc,
                 &mut |doc| {
@@ -34,9 +33,6 @@ pub(crate) fn handle_key_or_input_event<F: FnMut(DomEvent)>(
                 },
                 &mut dispatch_event,
             );
-            if doc.focus_node_id != old_focus {
-                doc.shell_provider.request_redraw();
-            }
             return;
         }