Format code

src/configuration.rs

@@ -1,19 +1,24 @@
+use std::{collections::BTreeMap, fs, path::PathBuf};
+
 use directories::ProjectDirs;
 use serde::{Deserialize, Serialize};
-use std::{collections::BTreeMap, fs, path::PathBuf};
 
 /// Application name for project directories
 const APPLICATION: &str = "Alloy";
 
-#[derive(Clone, Copy, Debug, Default, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(
+    Clone, Copy, Debug, Default, Eq, PartialEq, Serialize, Deserialize,
+)]
 pub enum WindowMode {
     #[default]
     Normal,
     Maximized,
     Fullscreen,
 }
 
-#[derive(Clone, Copy, Debug, Default, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(
+    Clone, Copy, Debug, Default, Eq, PartialEq, Serialize, Deserialize,
+)]
 pub enum Theme {
     #[default]
     Light,
@@ -29,15 +34,19 @@ impl Theme {
     }
 }
 
-#[derive(Clone, Copy, Debug, Default, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(
+    Clone, Copy, Debug, Default, Eq, PartialEq, Serialize, Deserialize,
+)]
 pub enum ScalingMode {
     #[default]
     Fixed,
     FitStretch,
     FitMin,
 }
 
-#[derive(Clone, Copy, Debug, Default, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(
+    Clone, Copy, Debug, Default, Eq, PartialEq, Serialize, Deserialize,
+)]
 pub enum Antialias {
     #[default]
     Auto,
@@ -101,7 +110,10 @@ impl Configuration {
     }
 
     pub fn scaling(&self) -> ScalingMode {
-        self.image.as_ref().and_then(|i| i.scaling).unwrap_or_default()
+        self.image
+            .as_ref()
+            .and_then(|i| i.scaling)
+            .unwrap_or_default()
     }
 
     pub fn set_scaling(&mut self, scaling: ScalingMode) {
@@ -114,7 +126,10 @@ impl Configuration {
     }
 
     pub fn antialiasing(&self) -> Antialias {
-        self.image.as_ref().and_then(|i| i.antialiasing).unwrap_or_default()
+        self.image
+            .as_ref()
+            .and_then(|i| i.antialiasing)
+            .unwrap_or_default()
     }
 
     pub fn set_antialiasing(&mut self, antialias: Antialias) {
@@ -127,15 +142,24 @@ impl Configuration {
     }
 
     pub fn title_folders(&self) -> u32 {
-        self.window.as_ref().and_then(|w| w.title_folders).unwrap_or_default()
+        self.window
+            .as_ref()
+            .and_then(|w| w.title_folders)
+            .unwrap_or_default()
     }
 
     pub fn window_mode(&self) -> WindowMode {
-        self.window.as_ref().and_then(|w| w.mode).unwrap_or_default()
+        self.window
+            .as_ref()
+            .and_then(|w| w.mode)
+            .unwrap_or_default()
     }
 
     pub fn theme(&self) -> Theme {
-        self.window.as_ref().and_then(|w| w.theme).unwrap_or_default()
+        self.window
+            .as_ref()
+            .and_then(|w| w.theme)
+            .unwrap_or_default()
     }
 
     pub fn set_theme(&mut self, theme: Theme) {

src/gelatin/button.rs

@@ -6,12 +6,17 @@ use glium::{
     uniform, Frame, Surface,
 };
 
-use crate::add_common_widget_functions;
-use crate::gelatin::{
-    misc::{Alignment, Length, LogicalRect, LogicalVector, WidgetPlacement},
-    picture::Picture,
-    window::RenderValidity,
-    DrawContext, Event, EventKind, NextUpdate, Widget, WidgetData, WidgetError,
+use crate::{
+    add_common_widget_functions,
+    gelatin::{
+        misc::{
+            Alignment, Length, LogicalRect, LogicalVector, WidgetPlacement,
+        },
+        picture::Picture,
+        window::RenderValidity,
+        DrawContext, Event, EventKind, NextUpdate, Widget, WidgetData,
+        WidgetError,
+    },
 };
 
 struct ButtonData {

src/gelatin/label.rs

@@ -3,12 +3,16 @@ use std::{cell::RefCell, rc::Rc};
 use cgmath::{Matrix4, Vector3};
 use glium::{uniform, Frame, Surface};
 
-use crate::add_common_widget_functions;
-use crate::gelatin::{
-    misc::{Alignment, Length, LogicalRect, LogicalVector, WidgetPlacement},
-    picture::Picture,
-    window::RenderValidity,
-    DrawContext, Event, NextUpdate, Widget, WidgetData, WidgetError,
+use crate::{
+    add_common_widget_functions,
+    gelatin::{
+        misc::{
+            Alignment, Length, LogicalRect, LogicalVector, WidgetPlacement,
+        },
+        picture::Picture,
+        window::RenderValidity,
+        DrawContext, Event, NextUpdate, Widget, WidgetData, WidgetError,
+    },
 };
 
 struct LabelData {

src/gelatin/line_layout_container.rs

@@ -2,15 +2,17 @@ use std::{cell::RefCell, rc::Rc};
 
 use glium::Frame;
 
-use crate::add_common_widget_functions;
-use crate::gelatin::{
-    misc::{
-        Alignment, HorDim, Length, LogicalRect, LogicalVector, PickDimension,
-        VerDim, WidgetPlacement,
+use crate::{
+    add_common_widget_functions,
+    gelatin::{
+        misc::{
+            Alignment, HorDim, Length, LogicalRect, LogicalVector,
+            PickDimension, VerDim, WidgetPlacement,
+        },
+        widget_data_ptr,
+        window::{RenderValidity, Window},
+        DrawContext, Event, NextUpdate, Widget, WidgetData, WidgetError,
     },
-    widget_data_ptr,
-    window::{RenderValidity, Window},
-    DrawContext, Event, NextUpdate, Widget, WidgetData, WidgetError,
 };
 
 pub type HorizontalLayoutContainer = LineLayoutContainer<HorDim>;

src/gelatin/mod.rs

@@ -1,8 +1,7 @@
 //! Idk man
 
 use std::{
-    any::Any, error::Error, fmt, path::PathBuf, rc::Rc,
-    time::Instant, vec::Vec,
+    any::Any, error::Error, fmt, path::PathBuf, rc::Rc, time::Instant, vec::Vec,
 };
 
 pub use cgmath;

src/gelatin/picture.rs

@@ -4,8 +4,10 @@ use std::{
     path,
 };
 
-use glium::texture::{MipmapsOption, RawImage2d, SrgbTexture2d};
-use glium::Display;
+use glium::{
+    texture::{MipmapsOption, RawImage2d, SrgbTexture2d},
+    Display,
+};
 use image::{error::ImageError, RgbaImage};
 
 pub struct PictureTextureRef<'a> {
@@ -109,10 +111,7 @@ impl Picture {
         }
     }
 
-    fn upload_to_texture(
-        &self,
-        display: &Display,
-    ) -> Result<(), ImageError> {
+    fn upload_to_texture(&self, display: &Display) -> Result<(), ImageError> {
         let mut borrowed = self.data.borrow_mut();
         let mut tmp_picture = PictureData::Path("".into());
         std::mem::swap(&mut *borrowed, &mut tmp_picture);
@@ -142,10 +141,7 @@ impl Picture {
         Ok(())
     }
 
-    fn cpu_to_texture(
-        img: RgbaImage,
-        display: &Display,
-    ) -> SrgbTexture2d {
+    fn cpu_to_texture(img: RgbaImage, display: &Display) -> SrgbTexture2d {
         let image_dimensions = img.dimensions();
         let image = RawImage2d::from_raw_rgba(img.into_raw(), image_dimensions);
         SrgbTexture2d::with_mipmaps(

src/gelatin/slider.rs

@@ -1,17 +1,22 @@
 use std::{cell::RefCell, rc::Rc};
 
 use cgmath::{Matrix4, Vector3};
-use crate::add_common_widget_functions;
-use crate::gelatin::{
-    misc::{Alignment, Length, LogicalRect, LogicalVector, WidgetPlacement},
-    window::RenderValidity,
-    DrawContext, Event, EventKind, NextUpdate, Widget, WidgetData, WidgetError,
-};
 use glium::{
     glutin::event::{ElementState, MouseButton},
-    DrawParameters,
-    Blend, BlendingFunction, LinearBlendingFactor,
-    uniform, Frame, Surface,
+    uniform, Blend, BlendingFunction, DrawParameters, Frame,
+    LinearBlendingFactor, Surface,
+};
+
+use crate::{
+    add_common_widget_functions,
+    gelatin::{
+        misc::{
+            Alignment, Length, LogicalRect, LogicalVector, WidgetPlacement,
+        },
+        window::RenderValidity,
+        DrawContext, Event, EventKind, NextUpdate, Widget, WidgetData,
+        WidgetError,
+    },
 };
 
 struct SliderData {

src/gelatin/window.rs

@@ -8,23 +8,25 @@ use std::{
 
 use cgmath::{ortho, Matrix4, Vector3};
 use glium::{
-    index::PrimitiveType,
     glutin::{
         self,
         dpi::{PhysicalPosition, PhysicalSize},
         event::WindowEvent,
         window::{CursorIcon, Icon, WindowId},
     },
-    program, uniform, Blend, BlendingFunction, Display, DrawParameters, Frame, IndexBuffer,
-    Program, Rect, Surface, VertexBuffer,
+    index::PrimitiveType,
+    program, uniform, Blend, BlendingFunction, Display, DrawParameters, Frame,
+    IndexBuffer, Program, Rect, Surface, VertexBuffer,
 };
 use typed_builder::TypedBuilder;
 
-use crate::VerticalLayoutContainer;
-use crate::gelatin::{
-    application::Application,
-    misc::{FromPhysical, LogicalRect, LogicalVector},
-    shaders, DrawContext, Event, EventKind, NextUpdate, Vertex, Widget,
+use crate::{
+    gelatin::{
+        application::Application,
+        misc::{FromPhysical, LogicalRect, LogicalVector},
+        shaders, DrawContext, Event, EventKind, NextUpdate, Vertex, Widget,
+    },
+    VerticalLayoutContainer,
 };
 
 const EVENT_UPDATE_DELTA: std::time::Duration =
@@ -146,8 +148,7 @@ impl Window {
             .with_gl_profile(glutin::GlProfile::Core)
             .with_vsync(true);
         let display =
-            Display::new(window, context, &application.event_loop)
-                .unwrap();
+            Display::new(window, context, &application.event_loop).unwrap();
 
         if let Some(pos) = desc.position {
             display.gl_window().window().set_outer_position(pos);
@@ -243,9 +244,7 @@ impl Window {
                 render_validity: RenderValidity {
                     validity: Rc::new(Cell::new(false)),
                 },
-                root_widget: Rc::new(
-                    VerticalLayoutContainer::new(),
-                ),
+                root_widget: Rc::new(VerticalLayoutContainer::new()),
                 bg_color: [0.85, 0.85, 0.85, 1.0],
 
                 global_event_handlers: Vec::new(),

src/image_cache/directory.rs

@@ -338,7 +338,9 @@ impl Directory {
     }
 
     fn set_image_index_from_file_index(&mut self) {
-        if let Some(Some(img_idx)) = self.file_i_to_img_i.get(self.curr_file_idx) {
+        if let Some(Some(img_idx)) =
+            self.file_i_to_img_i.get(self.curr_file_idx)
+        {
             self.curr_image_idx = *img_idx;
         }
     }

src/image_cache/image_loader.rs

@@ -23,6 +23,7 @@ use resvg::{
 
 pub mod errors {
     use std::io;
+
     use glium::texture;
 
     pub type Result<T = (), E = Error> = std::result::Result<T, E>;

src/image_cache/mod.rs

@@ -28,7 +28,9 @@ use self::{
 
 pub mod errors {
     use std::io;
+
     use glium::texture;
+
     use crate::image_cache::image_loader;
 
     pub type Result<T = (), E = Error> = std::result::Result<T, E>;

src/input_handling.rs

@@ -1,5 +1,8 @@
-use std::{collections::HashMap, process::Command};
-use std::sync::{Arc, Mutex};
+use std::{
+    collections::HashMap,
+    process::Command,
+    sync::{Arc, Mutex},
+};
 
 use glium::glutin::event::ModifiersState;
 use lazy_static::lazy_static;

src/main.rs

@@ -13,7 +13,7 @@ use crate::{
     configuration::{Configuration, Theme, WindowMode},
     gelatin::{
         application::*,
-        glium::glutin::{window::Icon},
+        glium::glutin::window::Icon,
         image,
         label::*,
         line_layout_container::*,
@@ -61,9 +61,8 @@ fn main() {
     let mut application = Application::new();
     let window: Rc<Window> = {
         let cfg = &mut config.lock().unwrap();
-        let window_desc = WindowDescriptor::builder()
-            .icon(Some(make_icon()))
-            .build();
+        let window_desc =
+            WindowDescriptor::builder().icon(Some(make_icon())).build();
         let window = Window::new(&mut application, window_desc);
 
         match cfg.window_mode() {