test drone

.drone.yml

@@ -1,6 +1,6 @@
 kind: pipeline
 type: docker
-name: build
+name: default
 
 steps:
 - name: build
@@ -27,24 +27,4 @@ steps:
       - sha256
   when:
     event: 
-      - 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
+      - tag

Cargo.toml

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

neutauri_bundler/Cargo.toml

@@ -5,13 +5,14 @@ version = "0.1.0"
 
 [dependencies]
 anyhow = "1.0"
+bincode = "1.3"
+brotli = "3.3"
 gumdrop = "0.8"
-inquire = "0.2"
-neutauri_data = {path = "../neutauri_data", features = ["bundler"]}
+image = "0.24"
 new_mime_guess = "4.0"
 serde = {version = "1.0", features = ["derive"]}
 toml = "0.5"
-wry = {version = "0.20", default-features = false, features = ["protocol", "tray", "transparent", "fullscreen", "devtools"]}
+wry = {version = "0.15", default-features = false, features = ["protocol", "tray", "gtk-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,11 +1,16 @@
+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))]
@@ -57,17 +62,10 @@ fn get_runtime_data(
     Ok(runtime_data)
 }
 
-pub(crate) fn bundle(config_path: String) -> anyhow::Result<()> {
-    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?"
-            )
-        })?;
+pub fn bundle(config_path: String) -> anyhow::Result<()> {
+    let config_path = std::path::Path::new(&config_path).canonicalize()?;
     let config: data::Config = toml::from_str(fs::read_to_string(&config_path)?.as_str())
-        .with_context(|| "toml parsing error")?;
+        .map_err(|e| io::Error::new(io::ErrorKind::Other, e))?;
     let source = match config_path.parent() {
         Some(path) => path.join(&config.source).canonicalize()?,
         None => config.source.canonicalize()?,

neutauri_bundler/src/data.rs

@@ -2,7 +2,7 @@ use bincode::Options;
 use serde::{Deserialize, Serialize};
 use std::{
     fs,
-    io::{self, Read, Result, SeekFrom, Seek},
+    io::{self, Read, Result},
     path::{self, Component, Path, PathBuf},
 };
 use wry::application::dpi::Position;
@@ -104,102 +104,6 @@ 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> {
-        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())
-    }
-}
-
-#[cfg(feature = "bundler")]
 impl Dir {
     // 使用本地文件系统填充 Dir 结构体
     fn fill_with<P: AsRef<path::Path>>(
@@ -251,7 +155,6 @@ impl Dir {
     }
 }
 
-#[cfg(feature = "bundler")]
 impl Data {
     pub fn build_from_dir<P: AsRef<path::Path>>(
         source: P,
@@ -326,7 +229,6 @@ impl Data {
     }
 }
 
-#[cfg(feature = "bundler")]
 impl Default for Config {
     fn default() -> Self {
         Self {
@@ -353,7 +255,6 @@ impl Default for Config {
     }
 }
 
-#[cfg(feature = "bundler")]
 impl Config {
     pub fn window_attr(&self) -> Result<WindowAttr> {
         Ok(WindowAttr {
@@ -393,17 +294,10 @@ impl Config {
     }
 }
 
-#[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) -> 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_bundler/src/dev.rs

@@ -1,6 +1,5 @@
-use anyhow::{Context, Result};
-use neutauri_data as data;
 use std::{fs, io::Read, path::PathBuf};
+
 use wry::{
     application::{
         dpi::{PhysicalSize, Size},
@@ -11,6 +10,8 @@ use wry::{
     webview::{WebContext, WebViewBuilder},
 };
 
+use crate::data;
+
 const PROTOCOL_PREFIX: &str = "{PROTOCOL}://";
 const PROTOCOL: &str = "dev";
 
@@ -30,17 +31,10 @@ fn custom_protocol_uri_to_path<T: Into<String>>(protocol: T, uri: T) -> wry::Res
     }
 }
 
-pub(crate) fn dev(config_path: String) -> Result<()> {
-    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?"
-            )
-        })?;
+pub fn dev(config_path: String) -> wry::Result<()> {
+    let config_path = std::path::Path::new(&config_path).canonicalize()?;
     let config: data::Config = toml::from_str(fs::read_to_string(&config_path)?.as_str())
-        .with_context(|| "toml parsing error")?;
+        .map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, e))?;
     let source = config.source.canonicalize()?;
 
     let event_loop = EventLoop::new();
@@ -148,7 +142,6 @@ pub(crate) fn dev(config_path: String) -> 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)
@@ -198,7 +191,9 @@ pub(crate) fn dev(config_path: String) -> Result<()> {
                 event: WindowEvent::CloseRequested,
                 ..
             } => *control_flow = ControlFlow::Exit,
-            _ => (),
+            _ => {
+                let _ = webview.resize();
+            }
         }
     });
 }

neutauri_bundler/src/init.rs

@@ -1,45 +0,0 @@
-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,7 +1,8 @@
 use gumdrop::Options;
+
 mod bundle;
 mod dev;
-mod init;
+mod data;
 
 #[derive(Debug, Options)]
 struct Args {
@@ -20,8 +21,6 @@ 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)]
@@ -40,12 +39,6 @@ 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();
@@ -76,8 +69,6 @@ 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());
@@ -85,21 +76,11 @@ 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

@@ -1,17 +0,0 @@
-[package]
-edition = "2021"
-name = "neutauri_data"
-version = "0.1.0"
-
-[dependencies]
-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.5", optional = true}
-wry = {version = "0.20", default-features = false, features = ["protocol", "tray", "transparent", "fullscreen"]}
-
-[features]
-bundler = ["new_mime_guess", "toml", "image"]
-runtime = []

neutauri_runtime/Cargo.toml

@@ -4,8 +4,10 @@ name = "neutauri_runtime"
 version = "0.1.0"
 
 [dependencies]
-neutauri_data = {path = "../neutauri_data", features = ["runtime"]}
-wry = {version = "0.20", default-features = false, features = ["protocol", "tray", "transparent", "fullscreen"]}
+bincode = "1.3"
+brotli = "3.3"
+serde = {version = "1.0", features = ["derive"]}
+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

@@ -0,0 +1,255 @@
+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,7 +1,7 @@
 #![windows_subsystem = "windows"]
 
-use neutauri_data as data;
 use std::path::PathBuf;
+
 use wry::{
     application::{
         dpi::{PhysicalSize, Size},
@@ -11,6 +11,7 @@ use wry::{
     },
     webview::{WebContext, WebViewBuilder},
 };
+mod data;
 
 const PROTOCOL_PREFIX: &str = "{PROTOCOL}://";
 const PROTOCOL: &str = "neu";
@@ -141,13 +142,9 @@ 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 mut file = match res.open(path) {
@@ -183,7 +180,9 @@ fn main() -> wry::Result<()> {
                 event: WindowEvent::CloseRequested,
                 ..
             } => *control_flow = ControlFlow::Exit,
-            _ => (),
+            _ => {
+                let _ = webview.resize();
+            }
         }
     });
 }