update configuration refs

raphamorim · Jun 10, 2024 · 0cbf331 · 0cbf331
1 parent f2a5c6a
commit 0cbf331
Show file tree

Hide file tree

Showing 12 changed files with 46 additions and 82 deletions.
diff --git a/frontends/rioterm/src/router/mod.rs b/frontends/rioterm/src/router/mod.rs
@@ -41,7 +41,7 @@ impl Route {
     }
 }
 
-impl<'a> Route {
+impl Route {
     #[inline]
     pub fn redraw(&self) {
         self.window.winit_window.request_redraw();
@@ -233,7 +233,7 @@ impl Router {
         &mut self,
         event_loop: &ActiveEventLoop,
         event_proxy: EventProxy,
-        config: RioConfig,
+        config: &RioConfig,
     ) {
         // In case configuration window does exists already
         if let Some(route_id) = self.config_route {
@@ -339,7 +339,7 @@ impl RouteWindow {
     pub async fn new(
         event_loop: &EventLoop<EventPayload>,
         config: &rio_backend::config::Config,
-        font_library: &Box<rio_backend::sugarloaf::font::FontLibrary>,
+        font_library: &rio_backend::sugarloaf::font::FontLibrary,
         open_url: Option<String>,
     ) -> Result<RouteWindow, Box<dyn Error>> {
         let proxy = event_loop.create_proxy();
@@ -361,14 +361,8 @@ impl RouteWindow {
             theme: winit_window.theme(),
         };
 
-        let screen = Screen::new(
-            properties,
-            config,
-            event_proxy,
-            *font_library.clone(),
-            open_url,
-        )
-        .await?;
+        let screen =
+            Screen::new(properties, config, event_proxy, font_library, open_url).await?;
 
         Ok(Self {
             is_focused: false,
@@ -391,7 +385,7 @@ impl RouteWindow {
     ) -> RouteWindow {
         #[allow(unused_mut)]
         let mut window_builder =
-            create_window_builder(window_name, &config, tab_id.clone());
+            create_window_builder(window_name, config, tab_id.clone());
 
         #[cfg(not(any(target_os = "macos", windows)))]
         if let Some(token) = event_loop.read_token_from_env() {
@@ -404,7 +398,7 @@ impl RouteWindow {
 
         #[allow(deprecated)]
         let winit_window = event_loop.create_window(window_builder).unwrap();
-        let winit_window = configure_window(winit_window, &config);
+        let winit_window = configure_window(winit_window, config);
 
         let properties = ScreenWindowProperties {
             size: winit_window.inner_size(),
@@ -417,9 +411,9 @@ impl RouteWindow {
 
         let screen = futures::executor::block_on(Screen::new(
             properties,
-            &config,
+            config,
             event_proxy,
-            font_library.clone(),
+            font_library,
             open_url,
         ))
         .expect("Screen not created");

diff --git a/frontends/rioterm/src/screen/mod.rs b/frontends/rioterm/src/screen/mod.rs
@@ -91,7 +91,7 @@ impl Screen<'_> {
         window_properties: ScreenWindowProperties,
         config: &rio_backend::config::Config,
         event_proxy: EventProxy,
-        font_library: rio_backend::sugarloaf::font::FontLibrary,
+        font_library: &rio_backend::sugarloaf::font::FontLibrary,
         open_url: Option<String>,
     ) -> Result<Screen<'screen>, Box<dyn Error>> {
         let size = window_properties.size;

diff --git a/frontends/rioterm/src/sequencer.rs b/frontends/rioterm/src/sequencer.rs
@@ -40,7 +40,7 @@ impl Sequencer {
         }
 
         Sequencer {
-            config: config,
+            config,
             event_proxy: None,
             router,
         }
@@ -157,7 +157,7 @@ impl Sequencer {
                                     None
                                 };
 
-                                self.config = config.into();
+                                self.config = config;
                                 for (_id, route) in self.router.routes.iter_mut() {
                                     if has_font_updates {
                                         if let Some(ref err) = font_library_errors {
@@ -349,11 +349,10 @@ impl Sequencer {
                                 }
                             }
                             RioEventType::Rio(RioEvent::CreateWindow) => {
-                                let config = &self.config;
                                 self.router.create_window(
                                     event_loop_window_target,
                                     self.event_proxy.clone().unwrap(),
-                                    &config,
+                                    &self.config,
                                     None,
                                 );
                             }
@@ -383,14 +382,13 @@ impl Sequencer {
                                             working_dir: working_dir_overwrite,
                                             ..current_config.clone()
                                         };
-                                        self.config = config.into();
+                                        self.config = config;
                                     }
 
-                                    let config = &self.config;
                                     self.router.create_native_tab(
                                         event_loop_window_target,
                                         self.event_proxy.clone().unwrap(),
-                                        &config,
+                                        &self.config,
                                         Some(
                                             route
                                                 .window
@@ -403,16 +401,15 @@ impl Sequencer {
                                     if let Some(old_config) =
                                         should_revert_to_previous_config
                                     {
-                                        self.config = old_config.into();
+                                        self.config = old_config;
                                     }
                                 }
                             }
                             RioEventType::Rio(RioEvent::CreateConfigEditor) => {
-                                let config = &self.config;
                                 self.router.open_config_window(
                                     event_loop_window_target,
                                     self.event_proxy.clone().unwrap(),
-                                    config.clone(),
+                                    &self.config,
                                 );
                             }
                             #[cfg(target_os = "macos")]
@@ -434,7 +431,7 @@ impl Sequencer {
                                             self.router.create_window(
                                                 event_loop_window_target,
                                                 self.event_proxy.clone().unwrap(),
-                                                &config,
+                                                config,
                                                 None,
                                             );
                                         }
@@ -525,7 +522,7 @@ impl Sequencer {
                                 self.router.create_window(
                                     event_loop_window_target,
                                     self.event_proxy.clone().unwrap(),
-                                    &config,
+                                    config,
                                     Some(url),
                                 );
                             }

diff --git a/sugarloaf/benches/bench_sugar_pile.rs b/sugarloaf/benches/bench_sugar_pile.rs
@@ -3,8 +3,7 @@ extern crate sugarloaf;
 
 use crate::layout::SugarloafLayout;
 use criterion::{criterion_group, criterion_main, Criterion};
-// use raw_window_handle::{HasDisplayHandle, HasWindowHandle};
-use raw_window_handle::{HasRawDisplayHandle, HasRawWindowHandle};
+use raw_window_handle::{HasDisplayHandle, HasWindowHandle};
 use sugarloaf::*;
 use winit::dpi::LogicalSize;
 use winit::event_loop::EventLoop;
@@ -30,10 +29,8 @@ fn bench_sugar_pile(c: &mut Criterion) {
 
     let size = window.inner_size();
     let sugarloaf_window = SugarloafWindow {
-        // handle: window.window_handle().unwrap().into(),
-        // display: window.display_handle().unwrap().into(),
-        handle: window.raw_window_handle(),
-        display: window.raw_display_handle(),
+        handle: window.window_handle().unwrap().into(),
+        display: window.display_handle().unwrap().into(),
         scale: scale_factor as f32,
         size: SugarloafWindowSize {
             width: size.width as f32,

diff --git a/sugarloaf/benches/bench_sugar_pile_with_screen.rs b/sugarloaf/benches/bench_sugar_pile_with_screen.rs
@@ -3,8 +3,7 @@ extern crate sugarloaf;
 
 use crate::layout::SugarloafLayout;
 use criterion::{criterion_group, criterion_main, Criterion};
-// use raw_window_handle::{HasDisplayHandle, HasWindowHandle};
-use raw_window_handle::{HasRawDisplayHandle, HasRawWindowHandle};
+use raw_window_handle::{HasDisplayHandle, HasWindowHandle};
 use sugarloaf::*;
 use winit::dpi::LogicalSize;
 use winit::event::Event;
@@ -43,10 +42,8 @@ fn bench_sugar_pile_with_screen(c: &mut Criterion) {
 
     let size = window.inner_size();
     let sugarloaf_window = SugarloafWindow {
-        // handle: window.window_handle().unwrap().into(),
-        // display: window.display_handle().unwrap().into(),
-        handle: window.raw_window_handle(),
-        display: window.raw_display_handle(),
+        handle: window.window_handle().unwrap().into(),
+        display: window.display_handle().unwrap().into(),
         scale: scale_factor as f32,
         size: SugarloafWindowSize {
             width: size.width as f32,

diff --git a/sugarloaf/examples/image.rs b/sugarloaf/examples/image.rs
@@ -8,8 +8,7 @@ use winit::{
     dpi::LogicalSize, event::Event, event_loop::EventLoop, window::WindowAttributes,
 };
 
-// use raw_window_handle::{HasDisplayHandle, HasWindowHandle};
-use raw_window_handle::{HasRawDisplayHandle, HasRawWindowHandle};
+use raw_window_handle::{HasDisplayHandle, HasWindowHandle};
 use sugarloaf::components::rect::Rect;
 use sugarloaf::layout::SugarloafLayout;
 use sugarloaf::{Sugarloaf, SugarloafWindow, SugarloafWindowSize};
@@ -42,10 +41,8 @@ async fn main() {
 
     let size = window.inner_size();
     let sugarloaf_window = SugarloafWindow {
-        // handle: window.window_handle().unwrap().into(),
-        // display: window.display_handle().unwrap().into(),
-        handle: window.raw_window_handle(),
-        display: window.raw_display_handle(),
+        handle: window.window_handle().unwrap().into(),
+        display: window.display_handle().unwrap().into(),
         scale: scale_factor as f32,
         size: SugarloafWindowSize {
             width: size.width as f32,

diff --git a/sugarloaf/examples/rect.rs b/sugarloaf/examples/rect.rs
@@ -1,8 +1,7 @@
 extern crate png;
 extern crate tokio;
 
-// use raw_window_handle::{HasDisplayHandle, HasWindowHandle};
-use raw_window_handle::{HasRawDisplayHandle, HasRawWindowHandle};
+use raw_window_handle::{HasDisplayHandle, HasWindowHandle};
 use sugarloaf::components::rect::Rect;
 use sugarloaf::layout::SugarloafLayout;
 use sugarloaf::{Sugarloaf, SugarloafWindow, SugarloafWindowSize};
@@ -43,10 +42,8 @@ async fn main() {
 
     let size = window.inner_size();
     let sugarloaf_window = SugarloafWindow {
-        // handle: window.window_handle().unwrap().into(),
-        // display: window.display_handle().unwrap().into(),
-        handle: window.raw_window_handle(),
-        display: window.raw_display_handle(),
+        handle: window.window_handle().unwrap().into(),
+        display: window.display_handle().unwrap().into(),
         scale: scale_factor as f32,
         size: SugarloafWindowSize {
             width: size.width as f32,

diff --git a/sugarloaf/examples/rect_transparency.rs b/sugarloaf/examples/rect_transparency.rs
@@ -1,8 +1,7 @@
 extern crate png;
 extern crate tokio;
 
-// use raw_window_handle::{HasDisplayHandle, HasWindowHandle};
-use raw_window_handle::{HasRawDisplayHandle, HasRawWindowHandle};
+use raw_window_handle::{HasDisplayHandle, HasWindowHandle};
 use sugarloaf::components::rect::Rect;
 use sugarloaf::layout::SugarloafLayout;
 use sugarloaf::{Sugarloaf, SugarloafWindow, SugarloafWindowSize};
@@ -42,10 +41,8 @@ async fn main() {
 
     let size = window.inner_size();
     let sugarloaf_window = SugarloafWindow {
-        // handle: window.window_handle().unwrap().into(),
-        // display: window.display_handle().unwrap().into(),
-        handle: window.raw_window_handle(),
-        display: window.raw_display_handle(),
+        handle: window.window_handle().unwrap().into(),
+        display: window.display_handle().unwrap().into(),
         scale: scale_factor as f32,
         size: SugarloafWindowSize {
             width: size.width as f32,

diff --git a/sugarloaf/examples/term.rs b/sugarloaf/examples/term.rs
@@ -1,7 +1,6 @@
 extern crate tokio;
 
-// use raw_window_handle::{HasDisplayHandle, HasWindowHandle};
-use raw_window_handle::{HasRawDisplayHandle, HasRawWindowHandle};
+use raw_window_handle::{HasDisplayHandle, HasWindowHandle};
 use sugarloaf::{layout::SugarloafLayout, Sugar, SugarDecoration, SugarStyle};
 use sugarloaf::{Sugarloaf, SugarloafWindow, SugarloafWindowSize};
 use winit::event_loop::ControlFlow;
@@ -46,10 +45,8 @@ async fn main() {
 
     let size = window.inner_size();
     let sugarloaf_window = SugarloafWindow {
-        // handle: window.window_handle().unwrap().into(),
-        // display: window.display_handle().unwrap().into(),
-        handle: window.raw_window_handle(),
-        display: window.raw_display_handle(),
+        handle: window.window_handle().unwrap().into(),
+        display: window.display_handle().unwrap().into(),
         scale: scale_factor as f32,
         size: SugarloafWindowSize {
             width: size.width as f32,

diff --git a/sugarloaf/examples/text.rs b/sugarloaf/examples/text.rs
@@ -1,6 +1,5 @@
 extern crate tokio;
-// use raw_window_handle::{HasDisplayHandle, HasWindowHandle};
-use raw_window_handle::{HasRawDisplayHandle, HasRawWindowHandle};
+use raw_window_handle::{HasDisplayHandle, HasWindowHandle};
 use sugarloaf::{
     layout::SugarloafLayout, Sugar, SugarDecoration, Sugarloaf, SugarloafWindow,
     SugarloafWindowSize,
@@ -41,10 +40,8 @@ async fn main() {
 
     let size = window.inner_size();
     let sugarloaf_window = SugarloafWindow {
-        // handle: window.window_handle().unwrap().into(),
-        // display: window.display_handle().unwrap().into(),
-        handle: window.raw_window_handle(),
-        display: window.raw_display_handle(),
+        handle: window.window_handle().unwrap().into(),
+        display: window.display_handle().unwrap().into(),
         scale: scale_factor as f32,
         size: SugarloafWindowSize {
             width: size.width as f32,

diff --git a/sugarloaf/examples/text_with_cursors.rs b/sugarloaf/examples/text_with_cursors.rs
@@ -1,7 +1,6 @@
 extern crate tokio;
 
-// use raw_window_handle::{HasDisplayHandle, HasWindowHandle};
-use raw_window_handle::{HasRawDisplayHandle, HasRawWindowHandle};
+use raw_window_handle::{HasDisplayHandle, HasWindowHandle};
 use sugarloaf::{
     layout::SugarloafLayout, Sugar, SugarCursor, SugarDecoration, SugarStyle,
 };
@@ -40,10 +39,8 @@ async fn main() {
 
     let size = window.inner_size();
     let sugarloaf_window = SugarloafWindow {
-        // handle: window.window_handle().unwrap().into(),
-        // display: window.display_handle().unwrap().into(),
-        handle: window.raw_window_handle(),
-        display: window.raw_display_handle(),
+        handle: window.window_handle().unwrap().into(),
+        display: window.display_handle().unwrap().into(),
         scale: scale_factor as f32,
         size: SugarloafWindowSize {
             width: size.width as f32,

diff --git a/sugarloaf/src/sugarloaf.rs b/sugarloaf/src/sugarloaf.rs
@@ -20,10 +20,7 @@ use ab_glyph::{self, PxScale};
 use core::fmt::{Debug, Formatter};
 use primitives::ImageProperties;
 use raw_window_handle::{
-    DisplayHandle,
-    HandleError,
-    HasDisplayHandle,
-    HasWindowHandle, WindowHandle,
+    DisplayHandle, HandleError, HasDisplayHandle, HasWindowHandle, WindowHandle,
 };
 use state::SugarState;
 
@@ -117,7 +114,7 @@ impl Sugarloaf<'_> {
     pub async fn new<'a>(
         window: SugarloafWindow,
         renderer: SugarloafRenderer,
-        font_library: FontLibrary,
+        font_library: &FontLibrary,
         layout: SugarloafLayout,
     ) -> Result<Sugarloaf<'a>, SugarloafWithErrors<'a>> {
         let ctx = Context::new(window, renderer).await;
@@ -132,7 +129,7 @@ impl Sugarloaf<'_> {
         let layer_brush = LayerBrush::new(&ctx);
         let rich_text_brush = RichTextBrush::new(&ctx);
 
-        let state = SugarState::new(layout, &font_library);
+        let state = SugarState::new(layout, font_library);
 
         let instance = Sugarloaf {
             state,