dsgkjhakljdsfhgdfskjhkh

changelog

···
   - Added the context menu back to the photo viewer screen
   - Fixed some weird bugs where the world data cache would be ignored
   - Fixed the ui forgetting the user account in some cases where the token stored it still valid
+  - Updated no photos text to be kinder
   - Settings menu can now be closed with ESC
+  - Fixed photos being extremely wide under certain conditions
+  - Fixed some icons not showing correctly
+
   - Photo viewer can now be navigated with keybinds:
     - Up Arrow: Open Tray
     - Down Arrow: Close Tray
···
     - Escape: Close Image
 
   Dev Stuff:
-    - Fixed indentation to be more constistant
+    - Fixed indentation to be more constistant
+    - main.rs is no longer like 400 quintillion lines long

public/icon/up-right-from-square-solid.svg

···
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512"><!--!Font Awesome Free 6.6.0 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license/free Copyright 2024 Fonticons, Inc.--><path fill="#ffffff" d="M352 0c-12.9 0-24.6 7.8-29.6 19.8s-2.2 25.7 6.9 34.9L370.7 96 201.4 265.4c-12.5 12.5-12.5 32.8 0 45.3s32.8 12.5 45.3 0L416 141.3l41.4 41.4c9.2 9.2 22.9 11.9 34.9 6.9s19.8-16.6 19.8-29.6l0-128c0-17.7-14.3-32-32-32L352 0zM80 32C35.8 32 0 67.8 0 112L0 432c0 44.2 35.8 80 80 80l320 0c44.2 0 80-35.8 80-80l0-112c0-17.7-14.3-32-32-32s-32 14.3-32 32l0 112c0 8.8-7.2 16-16 16L80 448c-8.8 0-16-7.2-16-16l0-320c0-8.8 7.2-16 16-16l112 0c17.7 0 32-14.3 32-32s-14.3-32-32-32L80 32z"/></svg>

src-tauri/src/frontend_calls/change_final_path.rs

···
+use std::fs;
+
+#[tauri::command]
+pub fn change_final_path(new_path: &str) {
+  let config_path = dirs::home_dir()
+    .unwrap()
+    .join("AppData\\Roaming\\PhazeDev\\VRChatPhotoManager\\.photos_path");
+
+  fs::write(&config_path, new_path.as_bytes()).unwrap();
+
+  match fs::metadata(&new_path) {
+    Ok(_) => {}
+    Err(_) => {
+      fs::create_dir(&new_path).unwrap();
+    }
+  };
+}

src-tauri/src/frontend_calls/close_splashscreen.rs

···
+use tauri::Manager;
+
+#[tauri::command]
+pub fn close_splashscreen(window: tauri::Window) {
+  window.get_webview_window("main").unwrap().show().unwrap();
+}

src-tauri/src/frontend_calls/delete_photo.rs

···
+use std::{ fs, thread, time::Duration };
+use crate::util::get_photo_path::get_photo_path;
+
+// Delete a photo when the users confirms the prompt in the ui
+#[tauri::command]
+pub fn delete_photo(path: String, token: String, is_syncing: bool) {
+  thread::spawn(move || {
+    let p = get_photo_path().join(&path);
+    fs::remove_file(p).unwrap();
+
+    let photo = path.split("\\").last().unwrap();
+
+    if is_syncing {
+      let client = reqwest::blocking::Client::new();
+      client
+        .delete(format!(
+          "https://photos-cdn.phazed.xyz/api/v1/photos?token={}&photo={}",
+          token, photo
+        ))
+        .timeout(Duration::from_secs(120))
+        .send()
+        .unwrap();
+    }
+  });
+}

src-tauri/src/frontend_calls/find_world_by_id.rs

···
+use std::thread;
+use crate::worldscraper::World;
+use tauri::Emitter;
+
+// Load vrchat world data
+#[tauri::command]
+pub fn find_world_by_id(world_id: String, window: tauri::Window) {
+  thread::spawn(move || {
+    let world = World::new(world_id);
+    window.emit("world_data", world).unwrap();
+  });
+}

src-tauri/src/frontend_calls/get_user_photos_path.rs

···
+use std::path;
+use crate::util::get_photo_path::get_photo_path;
+
+// Check if the photo config file exists
+// if not just return the default vrchat path
+#[tauri::command]
+pub fn get_user_photos_path() -> path::PathBuf {
+  get_photo_path()
+}

src-tauri/src/frontend_calls/load_photo_meta.rs

···
+use std::{ thread, fs, io::Read };
+use crate::util::get_photo_path::get_photo_path;
+use tauri::Emitter;
+use crate::PNGImage;
+
+// Reads the PNG file and loads the image metadata from it
+// then sends the metadata to the frontend, returns width, height, colour depth and so on... more info "pngmeta.rs"
+#[tauri::command]
+pub fn load_photo_meta(photo: &str, window: tauri::Window) {
+  let photo = photo.to_string();
+
+  thread::spawn(move || {
+    let base_dir = get_photo_path().join(&photo);
+
+    let file = fs::File::open(base_dir.clone());
+
+    match file {
+      Ok(mut file) => {
+        let mut buffer = Vec::new();
+
+        let _out = file.read_to_end(&mut buffer);
+        window
+          .emit("photo_meta_loaded", PNGImage::new(buffer, photo))
+          .unwrap();
+      }
+      Err(_) => {
+        println!("Cannot read image file");
+      }
+    }
+  });
+}

src-tauri/src/frontend_calls/load_photos.rs

···
+use std::{ thread, fs, path };
+use crate::util::get_photo_path::get_photo_path;
+use regex::Regex;
+use tauri::Emitter;
+
+// Scans all files under the "Pictures/VRChat" path
+// then sends the list of photos to the frontend
+#[derive(Clone, serde::Serialize)]
+struct PhotosLoadedResponse {
+  photos: Vec<path::PathBuf>,
+  size: usize,
+}
+
+#[tauri::command]
+pub fn load_photos(window: tauri::Window) {
+  thread::spawn(move || {
+    let base_dir = get_photo_path();
+
+    let mut photos: Vec<path::PathBuf> = Vec::new();
+    let mut size: usize = 0;
+
+    for folder in fs::read_dir(&base_dir).unwrap() {
+      let f = folder.unwrap();
+
+      if f.metadata().unwrap().is_dir() {
+        for photo in fs::read_dir(f.path()).unwrap() {
+          let p = photo.unwrap();
+
+          if p.metadata().unwrap().is_file() {
+            let fname = p.path();
+
+            let re1 = Regex::new(r"(?m)VRChat_[0-9]{4}-[0-9]{2}-[0-9]{2}_[0-9]{2}-[0-9]{2}-[0-9]{2}.[0-9]{3}_[0-9]{4}x[0-9]{4}.png").unwrap();
+            let re2 = Regex::new(
+  r"(?m)VRChat_[0-9]{4}-[0-9]{2}-[0-9]{2}_[0-9]{2}-[0-9]{2}-[0-9]{2}.[0-9]{3}_[0-9]{4}x[0-9]{4}_wrld_[a-z0-9]{8}-[a-z0-9]{4}-[a-z0-9]{4}-[a-z0-9]{4}-[a-z0-9]{12}.png").unwrap();
+
+            if re1.is_match(p.file_name().to_str().unwrap())
+              || re2.is_match(p.file_name().to_str().unwrap())
+            {
+              let path = fname.to_path_buf().clone();
+              let metadata = fs::metadata(&path).unwrap();
+
+              if metadata.is_file() {
+                size += metadata.len() as usize;
+
+                let path = path.strip_prefix(&base_dir).unwrap().to_path_buf();
+                photos.push(path);
+              }
+            } else {
+              println!("Ignoring {:#?} as it doesn't match regex", p.file_name());
+            }
+          } else {
+            println!("Ignoring {:#?} as it is a directory", p.file_name());
+          }
+        }
+      } else {
+        println!("Ignoring {:#?} as it isn't a directory", f.file_name());
+      }
+    }
+
+    println!("Found {} photos", photos.len());
+    window
+        .emit("photos_loaded", PhotosLoadedResponse { photos, size })
+        .unwrap();
+  });
+}

src-tauri/src/frontend_calls/mod.rs

···
+pub mod close_splashscreen;
+pub mod start_user_auth;
+pub mod open_url;
+pub mod open_folder;
+pub mod get_user_photos_path;
+pub mod start_with_win;
+pub mod find_world_by_id;
+pub mod sync_photos;
+pub mod load_photos;
+pub mod load_photo_meta;
+pub mod change_final_path;
+pub mod delete_photo;
+pub mod relaunch;

src-tauri/src/frontend_calls/open_folder.rs

···
+use std::process::Command;
+
+#[tauri::command]
+pub fn open_folder(url: &str) {
+  Command::new("explorer.exe")
+    .arg(format!("/select,{}", url))
+    .spawn()
+    .unwrap();
+}

src-tauri/src/frontend_calls/open_url.rs

···
+#[tauri::command]
+pub fn open_url(url: &str) {
+  if url.starts_with("https://"){
+    open::that(url).unwrap();
+  }
+}

src-tauri/src/frontend_calls/relaunch.rs

···
+use std::process::{ self, Command };
+
+#[tauri::command]
+pub fn relaunch() {
+  let container_folder = dirs::home_dir()
+    .unwrap()
+    .join("AppData\\Roaming\\PhazeDev\\VRChatPhotoManager");
+
+  let mut cmd = Command::new(&container_folder.join("./vrchat-photo-manager.exe"));
+  cmd.current_dir(container_folder);
+  cmd.spawn().expect("Cannot run updater");
+
+  process::exit(0);
+}

src-tauri/src/frontend_calls/start_user_auth.rs

···
+#[tauri::command]
+pub fn start_user_auth() {
+  open::that("https://photos.phazed.xyz/api/v1/auth").unwrap();
+}

src-tauri/src/frontend_calls/start_with_win.rs

···
+use std::{ thread, fs };
+use mslnk::ShellLink;
+
+// When the user changes the start with windows toggle
+// create and delete the shortcut from the startup folder
+#[tauri::command]
+pub fn start_with_win(start: bool) {
+  thread::spawn(move || {
+    if start {
+      let target = dirs::home_dir()
+        .unwrap()
+        .join("AppData\\Roaming\\PhazeDev\\VRChatPhotoManager\\vrchat-photo-manager.exe");
+
+      match fs::metadata(&target) {
+        Ok(_) => {
+          let lnk = dirs::home_dir().unwrap().join("AppData\\Roaming\\Microsoft\\Windows\\Start Menu\\Programs\\Startup\\VRChat Photo Manager.lnk");
+
+          let sl = ShellLink::new(target).unwrap();
+          sl.create_lnk(lnk).unwrap();
+        }
+        Err(_) => {}
+      }
+    } else {
+      let lnk = dirs::home_dir().unwrap().join("AppData\\Roaming\\Microsoft\\Windows\\Start Menu\\Programs\\Startup\\VRChat Photo Manager.lnk");
+      fs::remove_file(lnk).unwrap();
+    }
+  });
+}

src-tauri/src/frontend_calls/sync_photos.rs

···
+use crate::photosync;
+use std::thread;
+use crate::util::get_photo_path::get_photo_path;
+
+// On requested sync the photos to the cloud
+#[tauri::command]
+pub fn sync_photos(token: String, window: tauri::Window) {
+  thread::spawn(move || {
+    photosync::sync_photos(token, get_photo_path(), window);
+  });
+}

src-tauri/src/main.rs

···
 mod photosync;
 mod pngmeta;
 mod worldscraper;
+mod frontend_calls;
+mod util;
 
 use core::time;
-use image::{ codecs::png::{ PngDecoder, PngEncoder }, DynamicImage, ImageEncoder };
-use fast_image_resize::{ images::Image, IntoImageView, ResizeOptions, Resizer };
-use mslnk::ShellLink;
+use frontend_calls::*;
+
 use notify::{EventKind, RecursiveMode, Watcher};
 use pngmeta::PNGImage;
 use regex::Regex;
-use std::{
-  env, fs,
-  io::{ BufReader, Read },
-  path,
-  process::{self, Command},
-  thread,
-  time::Duration,
-};
-use tauri::{
-  http::Response, menu::{MenuBuilder, MenuItemBuilder}, tray::{MouseButton, MouseButtonState, TrayIconBuilder, TrayIconEvent}, AppHandle, Emitter, Manager, WindowEvent
-};
-use worldscraper::World;
+use std::{ env, fs, thread, };
+use tauri::{ Emitter, Manager, WindowEvent };
 
-// TODO: for the love of fuck please seperate this file out into multiple files at some point
 // TODO: Linux support
 
-// Scans all files under the "Pictures/VRChat" path
-// then sends the list of photos to the frontend
-#[derive(Clone, serde::Serialize)]
-struct PhotosLoadedResponse {
-  photos: Vec<path::PathBuf>,
-  size: usize,
-}
-
-const VERSION: &str = env!("CARGO_PKG_VERSION");
-
-pub fn get_photo_path() -> path::PathBuf {
-  let config_path = dirs::home_dir()
-    .unwrap()
-    .join("AppData\\Roaming\\PhazeDev\\VRChatPhotoManager\\.photos_path");
-
-  match fs::read_to_string(config_path) {
-    Ok(path) => {
-      if path
-        != dirs::picture_dir()
-          .unwrap()
-          .join("VRChat")
-          .to_str()
-          .unwrap()
-          .to_owned()
-      {
-        path::PathBuf::from(path)
-      } else {
-        dirs::picture_dir().unwrap().join("VRChat")
-      }
-    }
-    Err(_) => dirs::picture_dir().unwrap().join("VRChat"),
-  }
-}
-
-#[tauri::command]
-fn close_splashscreen(window: tauri::Window) {
-  window.get_webview_window("main").unwrap().show().unwrap();
-}
-
-#[tauri::command]
-fn start_user_auth() {
-  open::that("https://photos.phazed.xyz/api/v1/auth").unwrap();
-}
-
-#[tauri::command]
-fn open_url(url: &str) {
-  open::that(url).unwrap();
-}
-
-#[tauri::command]
-fn open_folder(url: &str) {
-  Command::new("explorer.exe")
-    .arg(format!("/select,{}", url))
-    .spawn()
-    .unwrap();
-}
-
-// Check if the photo config file exists
-// if not just return the default vrchat path
-#[tauri::command]
-fn get_user_photos_path() -> path::PathBuf {
-  get_photo_path()
-}
-
-// When the user changes the start with windows toggle
-// create and delete the shortcut from the startup folder
-#[tauri::command]
-fn start_with_win(start: bool) {
-  thread::spawn(move || {
-    if start {
-      let target = dirs::home_dir()
-        .unwrap()
-        .join("AppData\\Roaming\\PhazeDev\\VRChatPhotoManager\\vrchat-photo-manager.exe");
-
-      match fs::metadata(&target) {
-        Ok(_) => {
-          let lnk = dirs::home_dir().unwrap().join("AppData\\Roaming\\Microsoft\\Windows\\Start Menu\\Programs\\Startup\\VRChat Photo Manager.lnk");
-
-          let sl = ShellLink::new(target).unwrap();
-          sl.create_lnk(lnk).unwrap();
-        }
-        Err(_) => {}
-      }
-    } else {
-      let lnk = dirs::home_dir().unwrap().join("AppData\\Roaming\\Microsoft\\Windows\\Start Menu\\Programs\\Startup\\VRChat Photo Manager.lnk");
-      fs::remove_file(lnk).unwrap();
-    }
-  });
-}
-
-// Load vrchat world data
-#[tauri::command]
-fn find_world_by_id(world_id: String, window: tauri::Window) {
-  thread::spawn(move || {
-    let world = World::new(world_id);
-    window.emit("world_data", world).unwrap();
-  });
-}
-
-// On requested sync the photos to the cloud
-#[tauri::command]
-fn sync_photos(token: String, window: tauri::Window) {
-  thread::spawn(move || {
-    photosync::sync_photos(token, get_photo_path(), window);
-  });
-}
-
-#[tauri::command]
-fn load_photos(window: tauri::Window) {
-  thread::spawn(move || {
-    let base_dir = get_photo_path();
-
-    let mut photos: Vec<path::PathBuf> = Vec::new();
-    let mut size: usize = 0;
-
-    for folder in fs::read_dir(&base_dir).unwrap() {
-      let f = folder.unwrap();
-
-      if f.metadata().unwrap().is_dir() {
-        for photo in fs::read_dir(f.path()).unwrap() {
-          let p = photo.unwrap();
-
-          if p.metadata().unwrap().is_file() {
-            let fname = p.path();
-
-            let re1 = Regex::new(r"(?m)VRChat_[0-9]{4}-[0-9]{2}-[0-9]{2}_[0-9]{2}-[0-9]{2}-[0-9]{2}.[0-9]{3}_[0-9]{4}x[0-9]{4}.png").unwrap();
-            let re2 = Regex::new(
-  r"(?m)VRChat_[0-9]{4}-[0-9]{2}-[0-9]{2}_[0-9]{2}-[0-9]{2}-[0-9]{2}.[0-9]{3}_[0-9]{4}x[0-9]{4}_wrld_[a-z0-9]{8}-[a-z0-9]{4}-[a-z0-9]{4}-[a-z0-9]{4}-[a-z0-9]{12}.png").unwrap();
-
-            if re1.is_match(p.file_name().to_str().unwrap())
-              || re2.is_match(p.file_name().to_str().unwrap())
-            {
-              let path = fname.to_path_buf().clone();
-              let metadata = fs::metadata(&path).unwrap();
-
-              if metadata.is_file() {
-                size += metadata.len() as usize;
-
-                let path = path.strip_prefix(&base_dir).unwrap().to_path_buf();
-                photos.push(path);
-              }
-            } else {
-              println!("Ignoring {:#?} as it doesn't match regex", p.file_name());
-            }
-          } else {
-            println!("Ignoring {:#?} as it is a directory", p.file_name());
-          }
-        }
-      } else {
-        println!("Ignoring {:#?} as it isn't a directory", f.file_name());
-      }
-    }
-
-    println!("Found {} photos", photos.len());
-    window
-        .emit("photos_loaded", PhotosLoadedResponse { photos, size })
-        .unwrap();
-  });
-}
-
-// Reads the PNG file and loads the image metadata from it
-// then sends the metadata to the frontend, returns width, height, colour depth and so on... more info "pngmeta.rs"
-#[tauri::command]
-fn load_photo_meta(photo: &str, window: tauri::Window) {
-  let photo = photo.to_string();
-
-  thread::spawn(move || {
-    let base_dir = get_photo_path().join(&photo);
-
-    let file = fs::File::open(base_dir.clone());
-
-    match file {
-      Ok(mut file) => {
-        let mut buffer = Vec::new();
-
-        let _out = file.read_to_end(&mut buffer);
-        window
-          .emit("photo_meta_loaded", PNGImage::new(buffer, photo))
-          .unwrap();
-      }
-      Err(_) => {
-        println!("Cannot read image file");
-      }
-    }
-  });
-}
-
-// Delete a photo when the users confirms the prompt in the ui
-#[tauri::command]
-fn delete_photo(path: String, token: String, is_syncing: bool) {
-  thread::spawn(move || {
-    let p = get_photo_path().join(&path);
-    fs::remove_file(p).unwrap();
-
-    let photo = path.split("\\").last().unwrap();
-
-    if is_syncing {
-      let client = reqwest::blocking::Client::new();
-      client
-        .delete(format!(
-          "https://photos-cdn.phazed.xyz/api/v1/photos?token={}&photo={}",
-          token, photo
-        ))
-        .timeout(Duration::from_secs(120))
-        .send()
-        .unwrap();
-    }
-  });
-}
-
-#[tauri::command]
-fn change_final_path(new_path: &str) {
-  let config_path = dirs::home_dir()
-    .unwrap()
-    .join("AppData\\Roaming\\PhazeDev\\VRChatPhotoManager\\.photos_path");
-
-  fs::write(&config_path, new_path.as_bytes()).unwrap();
-
-  match fs::metadata(&new_path) {
-    Ok(_) => {}
-    Err(_) => {
-      fs::create_dir(&new_path).unwrap();
-    }
-  };
-}
-
-#[tauri::command]
-fn get_version() -> String {
-  String::from(VERSION)
-}
-
-#[tauri::command]
-fn relaunch() {
-  let container_folder = dirs::home_dir()
-    .unwrap()
-    .join("AppData\\Roaming\\PhazeDev\\VRChatPhotoManager");
-
-  let mut cmd = Command::new(&container_folder.join("./vrchat-photo-manager.exe"));
-  cmd.current_dir(container_folder);
-  cmd.spawn().expect("Cannot run updater");
-
-  process::exit(0);
-}
-
 fn main() {
   tauri_plugin_deep_link::prepare("uk.phaz.vrcpm");
 
···
   }
 
   println!("Loading App...");
-  let photos_path = get_photo_path();
+  let photos_path = util::get_photo_path::get_photo_path();
 
   match fs::metadata(&photos_path) {
     Ok(_) => {}
···
     }
   };
 
-  let args: Vec<String> = env::args().collect();
-
-  let mut update = true;
-  for arg in args {
-    if arg == "--no-update" {
-      update = false;
-    }
-  }
-
-  if update {
-    // Auto update
-    thread::spawn(move || {
-      let client = reqwest::blocking::Client::new();
-
-      let latest_version = client
-        .get("https://cdn.phaz.uk/vrcpm/latest")
-        .send()
-        .unwrap()
-        .text()
-        .unwrap();
-
-      if latest_version != VERSION {
-        match fs::metadata(&container_folder.join("./updater.exe")) {
-          Ok(_) => {}
-          Err(_) => {
-            let latest_installer = client
-              .get("https://cdn.phaz.uk/vrcpm/vrcpm-installer.exe")
-              .timeout(Duration::from_secs(120))
-              .send()
-              .unwrap()
-              .bytes()
-              .unwrap();
-
-            fs::write(&container_folder.join("./updater.exe"), latest_installer)
-              .unwrap();
-          }
-        }
-
-        let mut cmd = Command::new(&container_folder.join("./updater.exe"));
-        cmd.current_dir(container_folder);
-        cmd.spawn().expect("Cannot run updater");
-
-        process::exit(0);
-      }
-    });
-  }
+  util::check_updates::check_updates(container_folder);
 
   // Listen for file updates, store each update in an mpsc channel and send to the frontend
   let (sender, receiver) = std::sync::mpsc::channel();
···
               re1.is_match(path.to_str().unwrap()) ||
               re2.is_match(path.to_str().unwrap())
             {
-              sender.send((2, path.clone().strip_prefix(get_photo_path()).unwrap().to_path_buf())).unwrap();
+              sender.send((2, path.clone().strip_prefix(util::get_photo_path::get_photo_path()).unwrap().to_path_buf())).unwrap();
             }
           },
           EventKind::Create(_) => {
···
               re2.is_match(path.to_str().unwrap())
             {
               thread::sleep(time::Duration::from_millis(1000));
-              sender.send((1, path.clone().strip_prefix(get_photo_path()).unwrap().to_path_buf())).unwrap();
+              sender.send((1, path.clone().strip_prefix(util::get_photo_path::get_photo_path()).unwrap().to_path_buf())).unwrap();
             }
           },
           _ => {}
···
   }).unwrap();
 
   watcher
-    .watch(&get_photo_path(), RecursiveMode::Recursive)
+    .watch(&util::get_photo_path::get_photo_path(), RecursiveMode::Recursive)
     .unwrap();
 
   tauri::Builder::default()
     .plugin(tauri_plugin_process::init())
     .plugin(tauri_plugin_http::init())
     .plugin(tauri_plugin_shell::init())
-    .register_asynchronous_uri_scheme_protocol("photo", move |_app, request, responder| {
-        // TODO: Fix photos being W I D E
-        thread::spawn(move || {
-          // Loads the requested image file, sends data back to the user
-          let uri = request.uri();
-
-          if request.method() != "GET" {
-            responder.respond(
-              Response::builder()
-                .status(404)
-                .header("Access-Control-Allow-Origin", "*")
-                .body(Vec::new())
-                .unwrap(),
-            );
-
-            return;
-          }
-
-          let path = uri.path().split_at(1).1;
-          let file = fs::File::open(path);
-
-          match file {
-            Ok(mut file) => {
-              match uri.query().unwrap(){
-                "downscale" => {
-                  let decoder = PngDecoder::new(BufReader::new(&file)).unwrap();
-                  let src_image = DynamicImage::from_decoder(decoder).unwrap();
-
-                  let size_multiplier: f32 = 200.0 / src_image.height() as f32;
-
-                  let dst_width = (src_image.width() as f32 * size_multiplier).floor() as u32;
-                  let dst_height: u32 = 200;
-
-                  let mut dst_image = Image::new(dst_width, dst_height, src_image.pixel_type().unwrap());
-                  let mut resizer = Resizer::new();
-
-                  let opts = ResizeOptions::new()
-                    .resize_alg(fast_image_resize::ResizeAlg::Nearest);
-
-                  resizer.resize(&src_image, &mut dst_image, Some(&opts)).unwrap();
-
-                  let mut buf = Vec::new();
-                  let encoder = PngEncoder::new(&mut buf);
-
-                  encoder.write_image(dst_image.buffer(), dst_width, dst_height, src_image.color().into()).unwrap();
-
-                  let res = Response::builder()
-                    .status(200)
-                    .header("Access-Control-Allow-Origin", "*")
-                    .body(buf)
-                    .unwrap();
-
-                  responder.respond(res);
-                },
-                _ => {
-                  let mut buf = Vec::new();
-                  file.read_to_end(&mut buf).unwrap();
-
-                  let res = Response::builder()
-                    .status(200)
-                    .header("Access-Control-Allow-Origin", "*")
-                    .body(buf)
-                    .unwrap();
-
-                  responder.respond(res);
-                }
-              }
-            }
-            Err(_) => {
-              responder.respond(
-                Response::builder()
-                  .status(404)
-                  .header("Access-Control-Allow-Origin", "*")
-                  .body(b"File Not Found")
-                  .unwrap(),
-              );
-            }
-          }
-        });
-    })
+    .register_asynchronous_uri_scheme_protocol("photo", util::handle_uri_proto::handle_uri_proto)
     .on_window_event(|window, event| match event {
         WindowEvent::CloseRequested { api, .. } => {
           window.hide().unwrap();
···
         _ => {}
     })
     .setup(|app| {
-      let handle = app.handle().clone();
-
-      // Setup the tray icon and menu buttons
-      let quit = MenuItemBuilder::new("Quit")
-        .id("quit")
-        .build(&handle)
-        .unwrap();
-
-      let hide = MenuItemBuilder::new("Hide / Show")
-        .id("hide")
-        .build(&handle)
-        .unwrap();
-
-      let tray_menu = MenuBuilder::new(&handle)
-        .items(&[&quit, &hide])
-        .build()
-        .unwrap();
-
-      TrayIconBuilder::with_id("main")
-        .icon(tauri::image::Image::from_bytes(include_bytes!("../icons/32x32.png")).unwrap())
-        .menu(&tray_menu)
-        .on_menu_event(move |app: &AppHandle, event| match event.id().as_ref() {
-            "quit" => {
-              std::process::exit(0);
-            }
-            "hide" => {
-              let window = app.get_webview_window("main").unwrap();
-
-              if window.is_visible().unwrap() {
-                window.hide().unwrap();
-              } else {
-                window.show().unwrap();
-                window.set_focus().unwrap();
-              }
-            }
-            _ => {}
-        })
-        .on_tray_icon_event(|tray, event| {
-          if let TrayIconEvent::Click {
-            button: MouseButton::Left,
-            button_state: MouseButtonState::Up,
-              ..
-          } = event
-          {
-            let window = tray.app_handle().get_webview_window("main").unwrap();
-
-            window.show().unwrap();
-            window.set_focus().unwrap();
-          }
-        })
-        .build(&handle)
-        .unwrap();
-      // Register "deep link" for authentication via vrcpm://
-      tauri_plugin_deep_link::register("vrcpm", move |request| {
-        let mut command: u8 = 0;
-        let mut index: u8 = 0;
-
-        for part in request.split('/').into_iter() {
-          index += 1;
-
-          if index == 3 && part == "auth-callback" {
-            command = 1;
-          }
+      let handle = app.handle();
 
-          if index == 3 && part == "auth-denied" {
-            handle.emit("auth-denied", "null").unwrap();
-          }
-
-          if index == 4 && command == 1 {
-            handle.emit("auth-callback", part).unwrap();
-          }
-        }
-      })
-      .unwrap();
+      util::setup_traymenu::setup_traymenu(handle);
+      util::setup_deeplink::setup_deeplink(handle);
 
       // I hate this approach but i have no clue how else to do this...
       // reads the mpsc channel and sends the events to the frontend
···
       Ok(())
     })
     .invoke_handler(tauri::generate_handler![
-      start_user_auth,
-      load_photos,
-      close_splashscreen,
-      load_photo_meta,
-      delete_photo,
-      open_url,
-      open_folder,
-      find_world_by_id,
-      start_with_win,
-      get_user_photos_path,
-      change_final_path,
-      sync_photos,
-      get_version,
-      relaunch
+      start_user_auth::start_user_auth,
+      load_photos::load_photos,
+      close_splashscreen::close_splashscreen,
+      load_photo_meta::load_photo_meta,
+      delete_photo::delete_photo,
+      open_url::open_url,
+      open_folder::open_folder,
+      find_world_by_id::find_world_by_id,
+      start_with_win::start_with_win,
+      get_user_photos_path::get_user_photos_path,
+      change_final_path::change_final_path,
+      sync_photos::sync_photos,
+      util::get_version::get_version,
+      relaunch::relaunch
     ])
     .run(tauri::generate_context!())
     .expect("error while running tauri application");

src-tauri/src/util/check_updates.rs

···
+use std::{ env, fs, path, process::{ self, Command }, thread, time::Duration };
+use crate::util;
+
+pub fn check_updates( container_folder: path::PathBuf ){
+  let args: Vec<String> = env::args().collect();
+
+  let mut update = true;
+  for arg in args {
+    if arg == "--no-update" {
+      update = false;
+    }
+  }
+
+  if update {
+    // Auto update
+    thread::spawn(move || {
+      let client = reqwest::blocking::Client::new();
+
+      let latest_version = client
+        .get("https://cdn.phaz.uk/vrcpm/latest")
+        .send()
+        .unwrap()
+        .text()
+        .unwrap();
+
+      if latest_version != util::get_version::get_version() {
+        match fs::metadata(&container_folder.join("./updater.exe")) {
+          Ok(_) => {}
+          Err(_) => {
+            let latest_installer = client
+              .get("https://cdn.phaz.uk/vrcpm/vrcpm-installer.exe")
+              .timeout(Duration::from_secs(120))
+              .send()
+              .unwrap()
+              .bytes()
+              .unwrap();
+
+            fs::write(&container_folder.join("./updater.exe"), latest_installer)
+              .unwrap();
+          }
+        }
+
+        let mut cmd = Command::new(&container_folder.join("./updater.exe"));
+        cmd.current_dir(container_folder);
+        cmd.spawn().expect("Cannot run updater");
+
+        process::exit(0);
+      }
+    });
+  }
+}

src-tauri/src/util/get_photo_path.rs

···
+use std::{ fs, path };
+
+pub fn get_photo_path() -> path::PathBuf {
+  let config_path = dirs::home_dir()
+    .unwrap()
+    .join("AppData\\Roaming\\PhazeDev\\VRChatPhotoManager\\.photos_path");
+
+  match fs::read_to_string(config_path) {
+    Ok(path) => {
+      if path
+        != dirs::picture_dir()
+          .unwrap()
+          .join("VRChat")
+          .to_str()
+          .unwrap()
+          .to_owned()
+      {
+        path::PathBuf::from(path)
+      } else {
+        dirs::picture_dir().unwrap().join("VRChat")
+      }
+    }
+    Err(_) => dirs::picture_dir().unwrap().join("VRChat"),
+  }
+}

src-tauri/src/util/get_version.rs

···
+const VERSION: &str = env!("CARGO_PKG_VERSION");
+
+#[tauri::command]
+pub fn get_version() -> String {
+  String::from(VERSION)
+}

src-tauri/src/util/handle_uri_proto.rs

···
+use std::{ fs, io::{ BufReader, Read }, thread };
+use fast_image_resize::{ images::Image, IntoImageView, ResizeOptions, Resizer };
+use image::{ codecs::png::{ PngDecoder, PngEncoder }, DynamicImage, ImageEncoder };
+use tauri::{ http::{ Request, Response }, AppHandle, UriSchemeResponder };
+
+pub fn handle_uri_proto( _app: &AppHandle, request: Request<Vec<u8>>, responder: UriSchemeResponder ){
+  thread::spawn(move || {
+    // Loads the requested image file, sends data back to the user
+    let uri = request.uri();
+
+    if request.method() != "GET" {
+      responder.respond(
+        Response::builder()
+          .status(404)
+          .header("Access-Control-Allow-Origin", "*")
+          .body(Vec::new())
+          .unwrap(),
+      );
+
+      return;
+    }
+
+    // TODO: Only accept files that are in the vrchat photos folder
+    let path = uri.path().split_at(1).1;
+    let file = fs::File::open(path);
+
+    match file {
+      Ok(mut file) => {
+        match uri.query().unwrap(){
+          "downscale" => {
+            let decoder = PngDecoder::new(BufReader::new(&file)).unwrap();
+            let src_image = DynamicImage::from_decoder(decoder).unwrap();
+
+            let size_multiplier: f32 = 200.0 / src_image.height() as f32;
+
+            let dst_width = (src_image.width() as f32 * size_multiplier).floor() as u32;
+            let dst_height: u32 = 200;
+
+            let mut dst_image = Image::new(dst_width, dst_height, src_image.pixel_type().unwrap());
+            let mut resizer = Resizer::new();
+
+            let opts = ResizeOptions::new()
+              .resize_alg(fast_image_resize::ResizeAlg::Nearest);
+
+            resizer.resize(&src_image, &mut dst_image, Some(&opts)).unwrap();
+
+            let mut buf = Vec::new();
+            let encoder = PngEncoder::new(&mut buf);
+
+            encoder.write_image(dst_image.buffer(), dst_width, dst_height, src_image.color().into()).unwrap();
+
+            let res = Response::builder()
+              .status(200)
+              .header("Access-Control-Allow-Origin", "*")
+              .body(buf)
+              .unwrap();
+
+            responder.respond(res);
+          },
+          _ => {
+            let mut buf = Vec::new();
+            file.read_to_end(&mut buf).unwrap();
+
+            let res = Response::builder()
+              .status(200)
+              .header("Access-Control-Allow-Origin", "*")
+              .body(buf)
+              .unwrap();
+
+            responder.respond(res);
+          }
+        }
+      }
+      Err(_) => {
+        responder.respond(
+          Response::builder()
+            .status(404)
+            .header("Access-Control-Allow-Origin", "*")
+            .body(b"File Not Found")
+            .unwrap(),
+        );
+      }
+    }
+  });
+}

src-tauri/src/util/mod.rs

···
+pub mod get_photo_path;
+pub mod get_version;
+pub mod check_updates;
+pub mod setup_traymenu;
+pub mod setup_deeplink;
+pub mod handle_uri_proto;

src-tauri/src/util/setup_deeplink.rs

···
+use tauri::{ AppHandle, Emitter };
+
+pub fn setup_deeplink( handle: &AppHandle ){
+  let handle = handle.clone();
+
+  // Register "deep link" for authentication via vrcpm://
+  tauri_plugin_deep_link::register("vrcpm", move |request| {
+    let mut command: u8 = 0;
+    let mut index: u8 = 0;
+
+    for part in request.split('/').into_iter() {
+      index += 1;
+
+      if index == 3 && part == "auth-callback" {
+        command = 1;
+      }
+
+      if index == 3 && part == "auth-denied" {
+        handle.emit("auth-denied", "null").unwrap();
+      }
+
+      if index == 4 && command == 1 {
+        handle.emit("auth-callback", part).unwrap();
+      }
+    }
+  })
+  .unwrap();
+}

src-tauri/src/util/setup_traymenu.rs

···
+use tauri::{ menu::{ MenuBuilder, MenuItemBuilder }, tray::{MouseButton, MouseButtonState, TrayIconBuilder, TrayIconEvent}, AppHandle, Manager };
+
+pub fn setup_traymenu( handle: &AppHandle ){
+  // Setup the tray icon and menu buttons
+  let quit = MenuItemBuilder::new("Quit")
+    .id("quit")
+    .build(handle)
+    .unwrap();
+
+  let hide = MenuItemBuilder::new("Hide / Show")
+    .id("hide")
+    .build(handle)
+    .unwrap();
+
+  let tray_menu = MenuBuilder::new(handle)
+    .items(&[&quit, &hide])
+    .build()
+    .unwrap();
+
+  TrayIconBuilder::with_id("main")
+    .icon(tauri::image::Image::from_bytes(include_bytes!("../../icons/32x32.png")).unwrap())
+    .menu(&tray_menu)
+    .on_menu_event(move |app: &AppHandle, event| match event.id().as_ref() {
+        "quit" => {
+          std::process::exit(0);
+        }
+        "hide" => {
+          let window = app.get_webview_window("main").unwrap();
+
+          if window.is_visible().unwrap() {
+            window.hide().unwrap();
+          } else {
+            window.show().unwrap();
+            window.set_focus().unwrap();
+          }
+        }
+        _ => {}
+    })
+    .on_tray_icon_event(|tray, event| {
+      if let TrayIconEvent::Click {
+        button: MouseButton::Left,
+        button_state: MouseButtonState::Up,
+          ..
+      } = event
+      {
+        let window = tray.app_handle().get_webview_window("main").unwrap();
+
+        window.show().unwrap();
+        window.set_focus().unwrap();
+      }
+    })
+    .build(handle)
+    .unwrap();
+}

src-tauri/tauri.conf.json

···
         "minHeight": 400,
         "visible": false,
         "decorations": false,
-        "transparent": true
+        "transparent": true,
+        "titleBarStyle": "Transparent"
       }
     ]
   }

src/Components/App.tsx

···
 import PhotoViewer from "./PhotoViewer";
 import SettingsMenu from "./SettingsMenu";
 
+// TODO: Clean up frontend files, split up into smaller files PLEASE
+
 function App() {
   if(!localStorage.getItem('start-in-bg')){
     invoke('close_splashscreen')

src/Components/PhotoList.tsx

···
-import { createEffect, onMount } from "solid-js";
+import { createEffect, onCleanup, onMount } from "solid-js";
 import { invoke } from '@tauri-apps/api/core';
 import { listen } from '@tauri-apps/api/event';
 
···
   setIsPhotosSyncing!: ( syncing: boolean ) => boolean;
 }
 
+enum ListPopup{
+  FILTERS,
+  DATE,
+  NONE
+}
+
 // TODO: Photo filtering / Searching (By users, By date, By world)
 let PhotoList = ( props: PhotoListProps ) => {
   let amountLoaded = 0;
···
   let photoContainerBG: HTMLCanvasElement;
 
   let filterContainer: HTMLDivElement;
+  let scrollDateContainer: HTMLDivElement;
+  let dateListContainer: HTMLDivElement;
 
   let ctx: CanvasRenderingContext2D;
   let ctxBG: CanvasRenderingContext2D;
···
   let photos: Photo[] = [];
   let currentPhotoIndex: number = -1;
 
+  let datesList: any = {};
+
   let scroll: number = 0;
   let targetScroll: number = 0;
 
   let quitRender: boolean = false;
   let photoPath: string;
 
+  let currentPopup = ListPopup.NONE;
+  let targetScrollPhoto: Photo | null = null;
+
+  let closeWithKey = ( e: KeyboardEvent ) => {
+    if(e.key === 'Escape'){
+      closeCurrentPopup();
+    }
+  }
+
+  let closeCurrentPopup = () => {
+    switch(currentPopup){
+      case ListPopup.FILTERS:
+        anime({
+          targets: filterContainer,
+          opacity: 0,
+          easing: 'easeInOutQuad',
+          duration: 100,
+          complete: () => {
+            filterContainer.style.display = 'none';
+            currentPopup = ListPopup.NONE;
+          }
+        });
+
+        break;
+      case ListPopup.DATE:
+        anime({
+          targets: scrollDateContainer,
+          opacity: 0,
+          easing: 'easeInOutQuad',
+          duration: 100,
+          complete: () => {
+            scrollDateContainer.style.display = 'none';
+            currentPopup = ListPopup.NONE;
+          }
+        });
+
+        break;
+    }
+  }
+
   createEffect(() => {
     if(props.requestPhotoReload()){
       props.setRequestPhotoReload(false);
···
     let currentRowIndex = -1;
 
     scroll = scroll + (targetScroll - scroll) * 0.2;
+
+    if(targetScrollPhoto){
+      // TODO: Check if previous date.
+      targetScroll += 100;
+    }
 
     let lastPhoto;
     for (let i = 0; i < photos.length; i++) {
···
         ctx.fillStyle = '#fff';
         ctx.font = '30px Rubik';
 
+        if(targetScrollPhoto && p.dateString === targetScrollPhoto.dateString){
+          targetScrollPhoto = null;
+        }
+
         let dateParts = p.dateString.split('-');
         ctx.fillText(dateParts[2] + ' ' + months[parseInt(dateParts[1]) - 1] + ' ' + dateParts[0], photoContainer.width / 2, 60 + (currentRowIndex + 1.2) * 210 - scroll);
 
···
       ctx.fillStyle = '#fff';
       ctx.font = '50px Rubik';
 
-      ctx.fillText("You have no bitches", photoContainer.width / 2, photoContainer.height / 2);
+      ctx.fillText("It's looking empty in here! You have no photos :O", photoContainer.width / 2, photoContainer.height / 2);
     }
 
     ctxBG.filter = 'blur(100px)';
···
         easing: 'easeInOutQuad'
       })
 
+      photoPaths.forEach(( path: string ) => {
+        let date = path.split('_')[1];
+
+        if(!datesList[date])
+          datesList[date] = 1;
+      });
+
+      dateListContainer.innerHTML = '';
+
+      Object.keys(datesList).forEach(( date ) => {
+        dateListContainer.appendChild(<div onClick={() => {
+          let p = photos.find(x => x.dateString === date)!;
+          targetScrollPhoto = p;
+        }} class="date-list-date">{ date }</div> as HTMLElement);
+      })
+
       render();
     })
   }
···
       if(targetScroll < 0)
         targetScroll = 0;
     });
+
+    window.addEventListener('keyup', closeWithKey);
 
     photoContainer.width = window.innerWidth;
     photoContainer.height = window.innerHeight;
···
     })
   })
 
+  onCleanup(() => {
+    window.removeEventListener('keyup', closeWithKey);
+  })
+
   return ( 
     <div class="photo-list">
       <div ref={filterContainer!} class="filter-container">
         <div class="filter-title">Filters</div>
       </div>
 
+      <div ref={scrollDateContainer!} class="filter-container">
+        <div class="date-list" ref={dateListContainer!}>
+          <div class="filter-title">Loading Dates...</div>
+        </div>
+      </div>
+
       <div class="photo-tree-loading" ref={( el ) => photoTreeLoadingContainer = el}>Scanning Photo Tree...</div>
 
       <div class="scroll-to-top" ref={( el ) => scrollToTop = el} onClick={() => targetScroll = 0}>
···
       </div>
 
       <div class="filter-options">
-        <div class="icon" style={{ width: '20px', height: '5px', padding: '20px' }}>
-          <img draggable="false" src="/icon/sliders-solid.svg"></img>
+        <div>
+          <div onClick={() => {
+            if(currentPopup != ListPopup.NONE)return closeCurrentPopup();
+            currentPopup = ListPopup.FILTERS;
+
+            filterContainer.style.display = 'block';
+
+            anime({
+              targets: filterContainer,
+              opacity: 1,
+              easing: 'easeInOutQuad',
+              duration: 100
+            });
+          }} class="icon" style={{ width: '20px', height: '5px', padding: '20px' }}>
+            <img draggable="false" src="/icon/sliders-solid.svg"></img>
+          </div>
+          <div class="icon-label">Filters</div>
         </div>
-        <div class="icon" style={{ width: '20px', height: '5px', padding: '20px' }}>
-          <img draggable="false" src="/icon/clock-regular.svg"></img>
+        <div>
+          <div onClick={() => {
+            if(currentPopup != ListPopup.NONE)return closeCurrentPopup();
+            currentPopup = ListPopup.DATE;
+
+            scrollDateContainer.style.display = 'block';
+
+            anime({
+              targets: scrollDateContainer,
+              opacity: 1,
+              easing: 'easeInOutQuad',
+              duration: 100
+            });
+          }} class="icon" style={{ width: '20px', height: '5px', padding: '20px' }}>
+            <img draggable="false" src="/icon/clock-regular.svg"></img>
+          </div>
+          <div class="icon-label">Scroll to Date</div>
         </div>
       </div>
 

src/Components/PhotoViewer.tsx

···
                       <div>
                         { item.displayName }
                         <Show when={item.id}>
-                          <i onClick={() => invoke('open_url', { url: 'https://vrchat.com/home/user/' + item.id })} style={{ "margin-left": '10px', "font-size": '12px', 'color': '#bbb', cursor: 'pointer' }} class="fa-solid fa-arrow-up-right-from-square"></i>
+                          <img width="15" src="/icon/up-right-from-square-solid.svg" onClick={() => invoke('open_url', { url: 'https://vrchat.com/home/user/' + item.id })} style={{ "margin-left": '10px', "font-size": '12px', 'color': '#bbb', cursor: 'pointer' }} />
                         </Show>
                       </div>
                     }
···
       }
 
       if(photo && !isOpen){
-        viewer.style.display = 'block';
+        viewer.style.display = 'flex';
   
         anime({
           targets: viewer,
···
       <div>
         <Show when={ data.worldData.found == false && meta }>
           <div>
-            <div class="world-name">{ JSON.parse(meta).world.name } <i onClick={() => invoke('open_url', { url: 'https://vrchat.com/home/world/' + data.worldData.id })} style={{ "margin-left": '0px', "font-size": '12px', 'color': '#bbb', cursor: 'pointer' }} class="fa-solid fa-arrow-up-right-from-square"></i></div>
+            <div class="world-name">{ JSON.parse(meta).world.name } <img width="15" src="/icon/up-right-from-square-solid.svg" onClick={() => invoke('open_url', { url: 'https://vrchat.com/home/world/' + data.worldData.id })} style={{ "margin-left": '0px', "font-size": '12px', 'color': '#bbb', cursor: 'pointer' }} /></div>
             <div style={{ width: '75%', margin: 'auto' }}>Could not fetch world information... Is the world private?</div>
           </div>
         </Show>
         <Show when={ data.worldData.found == true }>
-          <div class="world-name">{ data.worldData.name } <i onClick={() => invoke('open_url', { url: 'https://vrchat.com/home/world/' + data.worldData.id })} style={{ "margin-left": '0px', "font-size": '12px', 'color': '#bbb', cursor: 'pointer' }} class="fa-solid fa-arrow-up-right-from-square"></i></div>
+          <div class="world-name">{ data.worldData.name } <img width="15" src="/icon/up-right-from-square-solid.svg" onClick={() => invoke('open_url', { url: 'https://vrchat.com/home/world/' + data.worldData.id })} style={{ "margin-left": '0px', "font-size": '12px', 'color': '#bbb', cursor: 'pointer' }} /></div>
           <div style={{ width: '75%', margin: 'auto' }}>{ data.worldData.desc }</div>
 
           <br />

src/styles.css

···
   height: 100%;
 }
 
+.icon-label{
+  margin-top: -20px;
+  margin-right: -200px;
+  width: 200px;
+  color: white;
+  pointer-events: none;
+  transform: translate(40px, -12px);
+  opacity: 0;
+  transition: 0.25s;
+  user-select: none;
+}
+
+.icon:hover ~ .icon-label{
+  opacity: 1;
+  transform: translate(60px, -12px);
+}
+
 .user-pfp{
   width: 35px;
   height: 35px;
···
   color: #fff;
   text-align: center;
   box-shadow: #0005 0 0 10px;
+  opacity: 0;
 }
 
 .filter-container > .filter-title{
   font-size: 30px;
 }
 
+.date-list{
+  mask-image: linear-gradient(to bottom, #0000, #000, #0000);
+  overflow: auto;
+  scrollbar-width: thin;
+  height: calc(100% - 100px);
+  padding: 50px 0;
+}
+
+.date-list-date{
+  padding: 10px;
+  user-select: none;
+  cursor: pointer;
+  transition: 0.1s;
+  border-radius: 10px;
+}
+
+.date-list-date:hover{
+  background: #0005;
+  box-shadow: inset #0005 0 0 10px;
+}
+
 .photo-tree-loading{
   width: 100%;
   height: 100%;
···
 }
 
 .photo-viewer{
+  justify-content: center;
   width: 100%;
   height: 100%;
   position: fixed;
···
 }
 
 .image-container{
-  width: 100%;
   height: 100%;
   background-size: contain !important;
   background-repeat: no-repeat !important;