update deps and use vc-ltl instead of crt-static

.drone.yml

@@ -1,6 +1,6 @@
 kind: pipeline
 type: docker
-name: default
+name: build
 
 steps:
 - name: build
@@ -27,4 +27,24 @@ steps:
       - sha256
   when:
     event: 
-      - tag
+      - tag
+
+---
+
+kind: pipeline
+type: docker
+name: clippy
+
+steps:
+- name: clippy
+  image: ubuntu:latest
+  commands:
+    - echo '========Install the necessary environment========'
+    - apt update && apt install -y curl gcc git libwebkit2gtk-4.0-dev libappindicator3-dev
+    - echo '========Install the Rust toolchain========'
+    - curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- --default-toolchain stable -c clippy -y
+    - echo '========Compile the Neutauri binary========'
+    - $HOME/.cargo/bin/cargo build --release --bin neutauri_runtime
+    - $HOME/.cargo/bin/cargo build --release --bin neutauri_bundler
+    - echo '========Run Cargo Clippy========'
+    - $HOME/.cargo/bin/cargo clippy

Cargo.toml

@@ -2,4 +2,10 @@
 members = [
   "neutauri_runtime",
   "neutauri_bundler",
+  "neutauri_data",
 ]
+
+[profile.release]
+lto = true
+strip = true
+opt-level = "z"

neutauri_bundler/Cargo.toml

@@ -5,14 +5,14 @@ version = "0.1.0"
 
 [dependencies]
 anyhow = "1.0"
-bincode = "1.3"
-brotli = "3.3"
 gumdrop = "0.8"
-image = "0.24"
+inquire = "0.6"
+neutauri_data = {path = "../neutauri_data", default-features = false, features = ["bundler"]}
 new_mime_guess = "4.0"
 serde = {version = "1.0", features = ["derive"]}
-toml = "0.5"
+toml = "0.7"
-wry = {version = "0.15", default-features = false, features = ["protocol", "tray", "gtk-tray", "transparent", "fullscreen", "devtools"]}
+vc-ltl = "5.0.5"
+wry = {version = "0.27", default-features = false, features = ["protocol", "tray", "transparent", "fullscreen", "devtools"]}
 
 [target.'cfg(windows)'.dependencies]
 rcedit = {git = "https://github.com/Tim-Paik/rcedit-rs.git", rev = "2805fca"}

neutauri_bundler/src/bundle.rs

@@ -1,16 +1,11 @@
-use crate::data;
-use std::{
-    fs,
-    io::{self, Write},
-};
-
-#[cfg(windows)]
 use anyhow::Context;
+use neutauri_data as data;
 #[cfg(windows)]
 use std::{
     env,
     hash::{Hash, Hasher},
 };
+use std::{fs, io::Write};
 
 fn options() -> fs::OpenOptions {
     #[cfg(not(windows))]
@@ -62,10 +57,17 @@ fn get_runtime_data(
     Ok(runtime_data)
 }
 
-pub fn bundle(config_path: String) -> anyhow::Result<()> {
+pub(crate) fn bundle(config_path: String) -> anyhow::Result<()> {
-    let config_path = std::path::Path::new(&config_path).canonicalize()?;
+    let config_path = std::path::Path::new(&config_path)
+        .canonicalize()
+        .with_context(|| {
+            format!(
+                "Error reading config file from {}\n\n{}",
+                &config_path, "You may want to create a neutauri.toml via the init subcommand?"
+            )
+        })?;
     let config: data::Config = toml::from_str(fs::read_to_string(&config_path)?.as_str())
-        .map_err(|e| io::Error::new(io::ErrorKind::Other, e))?;
+        .with_context(|| "toml parsing error")?;
     let source = match config_path.parent() {
         Some(path) => path.join(&config.source).canonicalize()?,
         None => config.source.canonicalize()?,
@@ -75,14 +77,13 @@ pub fn bundle(config_path: String) -> anyhow::Result<()> {
         None => data::normalize_path(&config.target),
     };
     fs::create_dir_all(target.parent().unwrap_or_else(|| std::path::Path::new("/")))?;
-    let target = if target.extension() == None && cfg!(windows) {
+    let target = if target.extension().is_none() && cfg!(windows) {
         target.with_extension("exe")
     } else {
         target
     };
     if target.extension() == Some(std::ffi::OsStr::new("neu")) {
-        data::pack(config_path)?;
+        return data::pack(config_path);
-        return Ok(());
     }
     let data = data::Data::build_from_dir(source, config.window_attr()?, config.webview_attr()?)?;
     let mut f = options().open(&target)?;

neutauri_bundler/src/dev.rs

@@ -1,40 +1,34 @@
-use std::{fs, io::Read, path::PathBuf};
+use anyhow::{Context, Result};
-
+use neutauri_data as data;
+use std::{fs, io::Read, path::PathBuf, borrow::Cow};
 use wry::{
     application::{
         dpi::{PhysicalSize, Size},
-        event::{Event, StartCause, WindowEvent},
+        event::{Event, WindowEvent},
         event_loop::{ControlFlow, EventLoop},
         window::{Fullscreen, Icon, Window, WindowBuilder},
     },
     webview::{WebContext, WebViewBuilder},
 };
 
-use crate::data;
+const PROTOCOL_PREFIX: &str = "dev://localhost";
-
-const PROTOCOL_PREFIX: &str = "{PROTOCOL}://";
 const PROTOCOL: &str = "dev";
 
-fn custom_protocol_uri<T: Into<String>>(protocol: T, path: T) -> String {
+fn custom_protocol_uri<T: Into<String>>(path: T) -> String {
-    PROTOCOL_PREFIX.replacen("{PROTOCOL}", &protocol.into(), 1) + &path.into()
+    PROTOCOL_PREFIX.to_owned() + &path.into()
-}
-fn custom_protocol_uri_to_path<T: Into<String>>(protocol: T, uri: T) -> wry::Result<String> {
-    let prefix = PROTOCOL_PREFIX.replacen("{PROTOCOL}", &protocol.into(), 1);
-    let uri = uri.into();
-    let path = uri.strip_prefix(&prefix);
-    match path {
-        Some(str) => Ok(str.to_string()),
-        None => Err(wry::Error::Io(std::io::Error::new(
-            std::io::ErrorKind::InvalidInput,
-            prefix + " is not found in " + &uri,
-        ))),
-    }
 }
 
-pub fn dev(config_path: String) -> wry::Result<()> {
+pub(crate) fn dev(config_path: String) -> Result<()> {
-    let config_path = std::path::Path::new(&config_path).canonicalize()?;
+    let config_path = std::path::Path::new(&config_path)
-    let config: data::Config = toml::from_str(fs::read_to_string(&config_path)?.as_str())
+        .canonicalize()
-        .map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, e))?;
+        .with_context(|| {
+            format!(
+                "Error reading config file from {}\n\n{}",
+                &config_path, "You may want to create a neutauri.toml via the init subcommand?"
+            )
+        })?;
+    let config: data::Config = toml::from_str(fs::read_to_string(config_path)?.as_str())
+        .with_context(|| "toml parsing error")?;
     let source = config.source.canonicalize()?;
 
     let event_loop = EventLoop::new();
@@ -87,12 +81,12 @@ pub fn dev(config_path: String) -> wry::Result<()> {
     let webview_builder = match url {
         Some(url) => {
             if url.starts_with('/') {
-                webview_builder.with_url(&custom_protocol_uri(PROTOCOL, &url))?
+                webview_builder.with_url(&custom_protocol_uri(&url))?
             } else {
                 webview_builder.with_url(&url)?
             }
         }
-        None => webview_builder.with_url(&custom_protocol_uri(PROTOCOL, "/index.html"))?,
+        None => webview_builder.with_url(&custom_protocol_uri("/index.html"))?,
     };
     let html = config.webview_attr()?.html;
     let webview_builder = match html {
@@ -142,13 +136,14 @@ pub fn dev(config_path: String) -> wry::Result<()> {
         WebContext::new(None)
     };
     let webview = webview_builder
+        .with_clipboard(true)
         .with_visible(config.window_attr()?.visible)
         .with_transparent(config.window_attr()?.transparent)
         .with_web_context(&mut web_context)
         .with_custom_protocol(PROTOCOL.to_string(), move |request| {
-            let path = custom_protocol_uri_to_path(PROTOCOL, request.uri())?;
+            let path = request.uri().path();
             let mut local_path = source.clone();
-            local_path.push(path.strip_prefix('/').unwrap_or(&path));
+            local_path.push(path.strip_prefix('/').unwrap_or(path));
             let mut data = Vec::new();
             let mut mime: String = "application/octet-stream".to_string();
             match fs::File::open(&local_path) {
@@ -170,7 +165,11 @@ pub fn dev(config_path: String) -> wry::Result<()> {
                     }
                 }
             }
-            wry::http::ResponseBuilder::new().mimetype(&mime).body(data)
+            wry::http::Response::builder()
+                .header("Content-Type", mime)
+                .header("Access-Control-Allow-Origin", "*")
+                .body(Cow::Owned(data))
+                .map_err(|e| e.into())
         })
         .with_ipc_handler(|window: &Window, req: String| {
             match req.as_str() {
@@ -186,14 +185,14 @@ pub fn dev(config_path: String) -> wry::Result<()> {
         *control_flow = ControlFlow::Wait;
 
         match event {
-            Event::NewEvents(StartCause::Init) => webview.focus(),
             Event::WindowEvent {
                 event: WindowEvent::CloseRequested,
                 ..
             } => *control_flow = ControlFlow::Exit,
-            _ => {
+            Event::GlobalShortcutEvent(id) => webview
-                let _ = webview.resize();
+                .evaluate_script(&format!("GlobalShortcutEvent({:})", id.0))
-            }
+                .unwrap_or_default(),
+            _ => (),
         }
     });
 }

neutauri_bundler/src/init.rs

@@ -0,0 +1,45 @@
+use anyhow::Ok;
+use neutauri_data as data;
+
+const TEMPLATE: &str = include_str!("../../neutauri.toml.example");
+
+pub(crate) fn init() -> anyhow::Result<()> {
+    let config = TEMPLATE;
+    let config = config.replace(
+        "Neutauri Demo",
+        &inquire::Text::new("The name of your program? (for window title)")
+            .with_placeholder("Neutauri App")
+            .with_default("Neutauri App")
+            .prompt()?,
+    );
+    let config = config.replace(
+        "web_src",
+        &inquire::Text::new("Where is your web source code? (relative to the current directory)")
+            .with_placeholder("web_src")
+            .with_default("web_src")
+            .prompt()?,
+    );
+    let config = config.replace(
+        "neutauri_demo",
+        &inquire::Text::new("The name of your output target?")
+            .with_placeholder("app")
+            .with_default("app")
+            .prompt()?,
+    );
+    let config = config.replacen(
+        "Small",
+        inquire::Select::new(
+            "The default size of the window?",
+            vec!["Small", "Medium", "Large"],
+        )
+        .prompt()?,
+        1,
+    );
+    let config_path = data::normalize_path(std::path::Path::new("./neutauri.toml"));
+    std::fs::write(&config_path, config)?;
+    eprintln!(
+        "The configuration file has been written to \"{}\"",
+        config_path.display()
+    );
+    Ok(())
+}

neutauri_bundler/src/main.rs

@@ -1,8 +1,7 @@
 use gumdrop::Options;
-
 mod bundle;
 mod dev;
-mod data;
+mod init;
 
 #[derive(Debug, Options)]
 struct Args {
@@ -21,6 +20,8 @@ enum Command {
     Bundle(BundleOpts),
     #[options(help = "run the project in the current directory in development mode")]
     Dev(DevOpts),
+    #[options(help = "initialize a neutauri project")]
+    Init(InitOpts),
 }
 
 #[derive(Debug, Clone, Options)]
@@ -39,6 +40,12 @@ struct DevOpts {
     config: Option<String>,
 }
 
+#[derive(Debug, Clone, Options)]
+struct InitOpts {
+    #[options(help = "print help information")]
+    help: bool,
+}
+
 fn print_help_and_exit(args: Args) {
     if args.command.is_some() {
         Args::parse_args_default_or_exit();
@@ -47,7 +54,6 @@ fn print_help_and_exit(args: Args) {
     eprintln!(
         "Usage: {:?} [SUBCOMMAND] [OPTIONS]",
         std::env::args()
-            .into_iter()
             .next()
             .unwrap_or_else(|| "neutauri_bundler".to_string())
     );
@@ -69,6 +75,8 @@ fn main() -> anyhow::Result<()> {
         Some(command) => match command {
             Command::Bundle(opts) => {
                 if opts.help_requested() {
+                    eprintln!("Package according to the configuration in neutauri.toml");
+                    eprintln!();
                     print_help_and_exit(args);
                 }
                 let config_path = opts.config.unwrap_or_else(|| "neutauri.toml".to_string());
@@ -76,11 +84,21 @@ fn main() -> anyhow::Result<()> {
             }
             Command::Dev(opts) => {
                 if opts.help_requested() {
+                    eprintln!("Check the configuration in neutauri.toml and start directly");
+                    eprintln!();
                     print_help_and_exit(args);
                 }
                 let config_path = opts.config.unwrap_or_else(|| "neutauri.toml".to_string());
                 dev::dev(config_path)?;
-            },
+            }
+            Command::Init(opts) => {
+                if opts.help_requested() {
+                    eprintln!("Interactively create a neutauri.toml configuration file");
+                    eprintln!();
+                    print_help_and_exit(args);
+                }
+                init::init()?;
+            }
         },
         None => print_help_and_exit(args),
     }

neutauri_data/Cargo.toml

@@ -0,0 +1,19 @@
+[package]
+edition = "2021"
+name = "neutauri_data"
+version = "0.1.0"
+
+[dependencies]
+anyhow = {version = "1.0", optional = true}
+bincode = "1.3"
+brotli = "3.3"
+image = {version = "0.24", optional = true}
+new_mime_guess = {version = "4.0", optional = true}
+serde = {version = "1.0", features = ["derive"]}
+toml = {version = "0.7", optional = true}
+wry = {version = "0.27", default-features = false, features = ["protocol", "tray", "transparent", "fullscreen"]}
+
+[features]
+default = ["runtime"]
+bundler = ["anyhow", "new_mime_guess", "toml", "image"]
+runtime = []

neutauri_data/src/lib.rs

@@ -104,6 +104,103 @@ pub struct WebViewAttr {
     pub initialization_script: Option<String>,
 }
 
+#[cfg(feature = "runtime")]
+impl File {
+    pub fn decompressed_data(&mut self) -> Result<Vec<u8>> {
+        let mut data = Vec::with_capacity(self.data.len());
+        let mut r = brotli::Decompressor::new(self.data.as_slice(), 4096);
+        r.read_to_end(&mut data)?;
+        Ok(data)
+    }
+    pub fn mimetype(&self) -> String {
+        self.mime.clone()
+    }
+}
+
+#[cfg(feature = "runtime")]
+impl Data {
+    pub fn new<P: AsRef<path::Path> + Copy>(path: P) -> Result<Self> {
+        use std::io::{Seek, SeekFrom};
+        let mut base = fs::File::open(path)?;
+        let base_length = base.metadata()?.len();
+        let mut magic_number_start_data = [0; MAGIC_NUMBER_START.len()];
+        let mut data_length_data = [0; USIZE_LEN];
+        let mut data = Vec::new();
+        let mut magic_number_end_data = [0; MAGIC_NUMBER_END.len()];
+        base.seek(SeekFrom::Start(base_length - MAGIC_NUMBER_END.len() as u64))?;
+        // 此时指针指向 MAGIC_NUMBER_END 之前
+        base.read_exact(&mut magic_number_end_data)?;
+        if &magic_number_end_data != MAGIC_NUMBER_END {
+            return Err(io::Error::new(
+                io::ErrorKind::InvalidData,
+                "MAGIC_NUMBER_END not found",
+            ));
+        }
+        base.seek(SeekFrom::Start(
+            base_length - MAGIC_NUMBER_END.len() as u64 - USIZE_LEN as u64,
+        ))?;
+        // 此时指针指向 data_length 之前
+        base.read_exact(&mut data_length_data)?;
+        base.seek(SeekFrom::Start(
+            base_length - u64::from_be_bytes(data_length_data),
+        ))?;
+        // 此时指针指向 MAGIC_NUMBER_START
+        base.read_exact(&mut magic_number_start_data)?;
+        if &magic_number_start_data != MAGIC_NUMBER_START {
+            return Err(io::Error::new(
+                io::ErrorKind::InvalidData,
+                "MAGIC_NUMBER_START not found",
+            ));
+        }
+        base.read_exact(&mut data_length_data)?;
+        // 此时指针指向 Data 前
+        base.take(u64::from_be_bytes(data_length_data))
+            .read_to_end(&mut data)?;
+        let serialize_options = bincode::DefaultOptions::new()
+            .with_fixint_encoding()
+            .allow_trailing_bytes()
+            .with_limit(104857600 /* 100MiB */);
+        let fs: Self = match serialize_options.deserialize(&data) {
+            Ok(fs) => fs,
+            Err(e) => {
+                return Err(io::Error::new(io::ErrorKind::InvalidData, e));
+            }
+        };
+        Ok(fs)
+    }
+
+    fn open_file(current_dir: &Dir, mut path: path::Iter) -> Result<File> {
+        let next_path = match path.next() {
+            Some(str) => str.to_string_lossy().to_string(),
+            None => return Err(io::Error::new(io::ErrorKind::NotFound, "file not found")),
+        };
+        for (name, file) in &current_dir.files {
+            if next_path == *name {
+                return Ok(file.clone());
+            }
+        }
+        for (name, dir) in &current_dir.dirs {
+            if next_path == *name {
+                return Self::open_file(dir, path);
+            }
+        }
+        Err(io::Error::new(io::ErrorKind::NotFound, "file not found"))
+    }
+
+    pub fn open<P: AsRef<path::Path>>(&self, path: P) -> Result<File> {
+        let path = normalize_path(path.as_ref());
+        let path = if path.starts_with("/") {
+            path.strip_prefix("/")
+                .unwrap_or_else(|_| Path::new(""))
+                .to_path_buf()
+        } else {
+            path
+        };
+        Self::open_file(&self.fs, path.iter())
+    }
+}
+
+#[cfg(feature = "bundler")]
 impl Dir {
     // 使用本地文件系统填充 Dir 结构体
     fn fill_with<P: AsRef<path::Path>>(
@@ -155,6 +252,7 @@ impl Dir {
     }
 }
 
+#[cfg(feature = "bundler")]
 impl Data {
     pub fn build_from_dir<P: AsRef<path::Path>>(
         source: P,
@@ -199,7 +297,7 @@ impl Data {
 
         let mut target: Vec<u8> = Vec::new();
         target.extend(MAGIC_NUMBER_START);
-        target.extend(&data.len().to_be_bytes());
+        target.extend(data.len().to_be_bytes());
         target.extend(&data);
         let target_length = target.len();
         let target_length = target_length + USIZE_LEN;
@@ -210,7 +308,7 @@ impl Data {
         Ok(target)
     }
 
-    pub fn pack<P: AsRef<path::Path>>(config_path: P) -> Result<()> {
+    pub fn pack<P: AsRef<path::Path>>(config_path: P) -> anyhow::Result<()> {
         let config_path = config_path.as_ref().canonicalize()?;
         let config: Config = toml::from_str(fs::read_to_string(&config_path)?.as_str())?;
         let source = match config_path.parent() {
@@ -229,6 +327,7 @@ impl Data {
     }
 }
 
+#[cfg(feature = "bundler")]
 impl Default for Config {
     fn default() -> Self {
         Self {
@@ -255,6 +354,7 @@ impl Default for Config {
     }
 }
 
+#[cfg(feature = "bundler")]
 impl Config {
     pub fn window_attr(&self) -> Result<WindowAttr> {
         Ok(WindowAttr {
@@ -294,10 +394,17 @@ impl Config {
     }
 }
 
-pub fn pack<P: AsRef<path::Path>>(config: P) -> Result<()> {
+#[cfg(feature = "runtime")]
+pub fn load<P: AsRef<path::Path> + Copy>(path: P) -> Result<Data> {
+    Data::new(path)
+}
+
+#[cfg(feature = "bundler")]
+pub fn pack<P: AsRef<path::Path>>(config: P) -> anyhow::Result<()> {
     Data::pack(config)
 }
 
+#[cfg(feature = "bundler")]
 fn load_icon(path: &Path) -> Result<Icon> {
     let image = image::open(path)
         .map_err(|e| io::Error::new(io::ErrorKind::Other, e))?

neutauri_runtime/Cargo.toml

@@ -4,10 +4,9 @@ name = "neutauri_runtime"
 version = "0.1.0"
 
 [dependencies]
-bincode = "1.3"
+neutauri_data = {path = "../neutauri_data", default-features = false, features = ["runtime"]}
-brotli = "3.3"
+vc-ltl = "5.0.5"
-serde = {version = "1.0", features = ["derive"]}
+wry = {version = "0.27", default-features = false, features = ["protocol", "tray", "transparent", "fullscreen"]}
-wry = {version = "0.15", default-features = false, features = ["protocol", "tray", "gtk-tray", "transparent", "fullscreen"]}
 
 [target.'cfg(windows)'.build-dependencies]
 winres = "0.1"

neutauri_runtime/src/data.rs

@@ -1,255 +0,0 @@
-use bincode::Options;
-use serde::{Deserialize, Serialize};
-use std::{
-    fs,
-    io::{self, Read, Result, Seek, SeekFrom},
-    path::{self, Component, Path, PathBuf},
-};
-use wry::application::dpi::Position;
-
-const MAGIC_NUMBER_START: &[u8; 9] = b"NEUTFSv01";
-const MAGIC_NUMBER_END: &[u8; 9] = b"NEUTFSEnd";
-const USIZE_LEN: usize = usize::MAX.to_be_bytes().len();
-
-#[non_exhaustive]
-#[derive(Serialize, Deserialize, Clone, Debug)]
-pub enum Compress {
-    Brotli,
-    None,
-}
-
-#[derive(Serialize, Deserialize, Clone, Debug)]
-pub struct File {
-    mime: String,
-    data: Vec<u8>,
-    compress: Compress,
-}
-
-#[derive(Serialize, Deserialize, Debug)]
-struct Dir {
-    files: Vec<(String, File)>,
-    dirs: Vec<(String, Dir)>,
-}
-
-#[derive(Serialize, Deserialize, Debug)]
-pub struct Data {
-    pub window_attr: WindowAttr,
-    pub webview_attr: WebViewAttr,
-    fs: Dir,
-}
-
-#[derive(Serialize, Deserialize, Copy, Clone, Debug)]
-pub enum WindowSize {
-    Large,
-    Medium,
-    Small,
-    Fixed { width: f64, height: f64 },
-    Scale { factor: f64 },
-}
-
-#[derive(Serialize, Deserialize, Clone, Debug)]
-pub struct Config {
-    pub source: PathBuf,
-    pub target: PathBuf,
-    pub inner_size: Option<WindowSize>,
-    pub min_inner_size: Option<WindowSize>,
-    pub max_inner_size: Option<WindowSize>,
-    pub resizable: bool,
-    pub fullscreen: bool,
-    pub title: String,
-    pub maximized: bool,
-    pub visible: bool,
-    pub transparent: bool,
-    pub decorations: bool,
-    pub always_on_top: bool,
-    pub icon: Option<PathBuf>,
-    pub spa: bool,
-    pub url: Option<String>,
-    pub html: Option<PathBuf>,
-    pub initialization_script: Option<String>,
-    pub manifest: Option<PathBuf>,
-}
-
-#[derive(Serialize, Deserialize, Clone, Debug, Default)]
-pub struct Icon {
-    pub rgba: Vec<u8>,
-    pub width: u32,
-    pub height: u32,
-}
-
-#[derive(Serialize, Deserialize, Clone, Debug)]
-pub struct WindowAttr {
-    pub inner_size: Option<WindowSize>,
-    pub min_inner_size: Option<WindowSize>,
-    pub max_inner_size: Option<WindowSize>,
-    pub position: Option<Position>,
-    pub resizable: bool,
-    pub fullscreen: bool,
-    pub title: String,
-    pub maximized: bool,
-    pub visible: bool,
-    pub transparent: bool,
-    pub decorations: bool,
-    pub always_on_top: bool,
-    pub icon: Option<Icon>,
-}
-
-#[derive(Serialize, Deserialize, Clone, Debug)]
-pub struct WebViewAttr {
-    pub visible: bool,
-    pub transparent: bool,
-    pub spa: bool,
-    pub url: Option<String>,
-    pub html: Option<String>,
-    pub initialization_script: Option<String>,
-}
-
-impl File {
-    pub fn decompressed_data(&mut self) -> Result<Vec<u8>> {
-        let mut data = Vec::with_capacity(self.data.len());
-        let mut r = brotli::Decompressor::new(self.data.as_slice(), 4096);
-        r.read_to_end(&mut data)?;
-        Ok(data)
-    }
-    pub fn mimetype(&self) -> String {
-        self.mime.clone()
-    }
-}
-
-impl Data {
-    pub fn new<P: AsRef<path::Path> + Copy>(path: P) -> Result<Self> {
-        let mut base = fs::File::open(path)?;
-        let base_length = base.metadata()?.len();
-        let mut magic_number_start_data = [0; MAGIC_NUMBER_START.len()];
-        let mut data_length_data = [0; USIZE_LEN];
-        let mut data = Vec::new();
-        let mut magic_number_end_data = [0; MAGIC_NUMBER_END.len()];
-        base.seek(SeekFrom::Start(base_length - MAGIC_NUMBER_END.len() as u64))?;
-        // 此时指针指向 MAGIC_NUMBER_END 之前
-        base.read_exact(&mut magic_number_end_data)?;
-        if &magic_number_end_data != MAGIC_NUMBER_END {
-            return Err(io::Error::new(
-                io::ErrorKind::InvalidData,
-                "MAGIC_NUMBER_END not found",
-            ));
-        }
-        base.seek(SeekFrom::Start(
-            base_length - MAGIC_NUMBER_END.len() as u64 - USIZE_LEN as u64,
-        ))?;
-        // 此时指针指向 data_length 之前
-        base.read_exact(&mut data_length_data)?;
-        base.seek(SeekFrom::Start(
-            base_length - u64::from_be_bytes(data_length_data),
-        ))?;
-        // 此时指针指向 MAGIC_NUMBER_START
-        base.read_exact(&mut magic_number_start_data)?;
-        if &magic_number_start_data != MAGIC_NUMBER_START {
-            return Err(io::Error::new(
-                io::ErrorKind::InvalidData,
-                "MAGIC_NUMBER_START not found",
-            ));
-        }
-        base.read_exact(&mut data_length_data)?;
-        // 此时指针指向 Data 前
-        base.take(u64::from_be_bytes(data_length_data))
-            .read_to_end(&mut data)?;
-        let serialize_options = bincode::DefaultOptions::new()
-            .with_fixint_encoding()
-            .allow_trailing_bytes()
-            .with_limit(104857600 /* 100MiB */);
-        let fs: Self = match serialize_options.deserialize(&data) {
-            Ok(fs) => fs,
-            Err(e) => {
-                return Err(io::Error::new(io::ErrorKind::InvalidData, e));
-            }
-        };
-        Ok(fs)
-    }
-
-    fn open_file(&self, current_dir: &Dir, mut path: path::Iter) -> Result<File> {
-        let next_path = match path.next() {
-            Some(str) => str.to_string_lossy().to_string(),
-            None => return Err(io::Error::new(io::ErrorKind::NotFound, "file not found")),
-        };
-        for (name, file) in &current_dir.files {
-            if next_path == *name {
-                return Ok(file.clone());
-            }
-        }
-        for (name, dir) in &current_dir.dirs {
-            if next_path == *name {
-                return self.open_file(dir, path);
-            }
-        }
-        Err(io::Error::new(io::ErrorKind::NotFound, "file not found"))
-    }
-
-    pub fn open<P: AsRef<path::Path>>(&self, path: P) -> Result<File> {
-        let path = normalize_path(path.as_ref());
-        let path = if path.starts_with("/") {
-            path.strip_prefix("/")
-                .unwrap_or_else(|_| Path::new(""))
-                .to_path_buf()
-        } else {
-            path
-        };
-        self.open_file(&self.fs, path.iter())
-    }
-}
-
-impl Default for Config {
-    fn default() -> Self {
-        Self {
-            source: PathBuf::from("."),
-            target: PathBuf::from("app.neu"),
-            inner_size: Some(WindowSize::Medium),
-            min_inner_size: None,
-            max_inner_size: None,
-            resizable: true,
-            fullscreen: false,
-            title: "".into(),
-            maximized: false,
-            visible: true,
-            transparent: false,
-            decorations: true,
-            always_on_top: false,
-            icon: None,
-            spa: false,
-            url: Some("/index.html".into()),
-            html: None,
-            initialization_script: None,
-            manifest: None,
-        }
-    }
-}
-
-pub fn load<P: AsRef<path::Path> + Copy>(path: P) -> Result<Data> {
-    Data::new(path)
-}
-
-pub fn normalize_path(path: &Path) -> PathBuf {
-    let mut components = path.components().peekable();
-    let mut ret = if let Some(c @ Component::Prefix(..)) = components.peek().cloned() {
-        components.next();
-        PathBuf::from(c.as_os_str())
-    } else {
-        PathBuf::new()
-    };
-
-    for component in components {
-        match component {
-            Component::Prefix(..) => {}
-            Component::RootDir => {
-                ret.push(component.as_os_str());
-            }
-            Component::CurDir => {}
-            Component::ParentDir => {
-                ret.pop();
-            }
-            Component::Normal(c) => {
-                ret.push(c);
-            }
-        }
-    }
-    ret
-}

neutauri_runtime/src/main.rs

@@ -1,35 +1,22 @@
 #![windows_subsystem = "windows"]
 
-use std::path::PathBuf;
+use neutauri_data as data;
-
+use std::{borrow::Cow, path::PathBuf};
 use wry::{
     application::{
         dpi::{PhysicalSize, Size},
-        event::{Event, StartCause, WindowEvent},
+        event::{Event, WindowEvent},
         event_loop::{ControlFlow, EventLoop},
         window::{Fullscreen, Icon, Window, WindowBuilder},
     },
     webview::{WebContext, WebViewBuilder},
 };
-mod data;
 
-const PROTOCOL_PREFIX: &str = "{PROTOCOL}://";
+const PROTOCOL_PREFIX: &str = "neu://localhost";
 const PROTOCOL: &str = "neu";
 
-fn custom_protocol_uri<T: Into<String>>(protocol: T, path: T) -> String {
+fn custom_protocol_uri<T: Into<String>>(path: T) -> String {
-    PROTOCOL_PREFIX.replacen("{PROTOCOL}", &protocol.into(), 1) + &path.into()
+    PROTOCOL_PREFIX.to_owned() + &path.into()
-}
-fn custom_protocol_uri_to_path<T: Into<String>>(protocol: T, uri: T) -> wry::Result<String> {
-    let prefix = PROTOCOL_PREFIX.replacen("{PROTOCOL}", &protocol.into(), 1);
-    let uri = uri.into();
-    let path = uri.strip_prefix(&prefix);
-    match path {
-        Some(str) => Ok(str.to_string()),
-        None => Err(wry::Error::Io(std::io::Error::new(
-            std::io::ErrorKind::InvalidInput,
-            prefix + " is not found in " + &uri,
-        ))),
-    }
 }
 
 fn main() -> wry::Result<()> {
@@ -87,12 +74,12 @@ fn main() -> wry::Result<()> {
     let webview_builder = match url {
         Some(url) => {
             if url.starts_with('/') {
-                webview_builder.with_url(&custom_protocol_uri(PROTOCOL, &url))?
+                webview_builder.with_url(&custom_protocol_uri(&url))?
             } else {
                 webview_builder.with_url(&url)?
             }
         }
-        None => webview_builder.with_url(&custom_protocol_uri(PROTOCOL, "/index.html"))?,
+        None => webview_builder.with_url(&custom_protocol_uri("/index.html"))?,
     };
     let html = res.webview_attr.html.clone();
     let webview_builder = match html {
@@ -142,24 +129,32 @@ fn main() -> wry::Result<()> {
         WebContext::new(None)
     };
     let webview = webview_builder
+        .with_clipboard(true)
         .with_visible(res.window_attr.visible)
         .with_transparent(res.window_attr.transparent)
         .with_web_context(&mut web_context)
+        .with_initialization_script(
+            r#"window.oncontextmenu = (event) => { event.preventDefault(); }"#,
+        )
         .with_custom_protocol(PROTOCOL.to_string(), move |request| {
-            let path = custom_protocol_uri_to_path(PROTOCOL, request.uri())?;
+            let path = request.uri().path();
             let mut file = match res.open(path) {
                 Ok(file) => file,
                 Err(e) => {
-                    if e.kind() == std::io::ErrorKind::NotFound && res.webview_attr.spa {
+                    if e.kind() == std::io::ErrorKind::NotFound
+                        && res.webview_attr.spa
+                        && path != "/index.html"
+                    {
                         res.open("index.html")?
                     } else {
                         return Err(wry::Error::Io(e));
                     }
                 }
             };
-            wry::http::ResponseBuilder::new()
+            wry::http::Response::builder()
-                .mimetype(&file.mimetype())
+                .header("Content-Type", file.mimetype())
-                .body(file.decompressed_data()?)
+                .body(Cow::Owned(file.decompressed_data()?))
+                .map_err(|e| e.into())
         })
         .with_ipc_handler(|window: &Window, req: String| {
             match req.as_str() {
@@ -175,14 +170,14 @@ fn main() -> wry::Result<()> {
         *control_flow = ControlFlow::Wait;
 
         match event {
-            Event::NewEvents(StartCause::Init) => webview.focus(),
             Event::WindowEvent {
                 event: WindowEvent::CloseRequested,
                 ..
             } => *control_flow = ControlFlow::Exit,
-            _ => {
+            Event::GlobalShortcutEvent(id) => webview
-                let _ = webview.resize();
+                .evaluate_script(&format!("GlobalShortcutEvent({:})", id.0))
-            }
+                .unwrap_or_default(),
+            _ => (),
         }
     });
 }