stuff

changelog

···
 
 v0.2.2:
   - Use more linux friendly directories
-  - Move away from localstorage and use the .config file
+  - Move away from localstorage and use the .config file
+  - Seems to be semi-stable on linux
+  - Update deeplink library
+  - Fix bugs with multiple screens displaying on frontend

src-tauri/src/main.rs

···
 use notify::{EventKind, RecursiveMode, Watcher};
 use pngmeta::PNGImage;
 use regex::Regex;
-use util::handle_deeplink;
 use std::{env, fs, thread};
 use tauri::{Emitter, Manager, WindowEvent};
 use tauri_plugin_deep_link::DeepLinkExt;
···
     }
   }).unwrap();
 
+  println!("Watching dir: {:?}", util::get_photo_path::get_photo_path());
   watcher
     .watch(
       &util::get_photo_path::get_photo_path(),

src-tauri/src/photosync.rs

···
 pub fn sync_photos(token: String, path: path::PathBuf, window: tauri::Window) {
   let sync_lock_path = dirs::config_dir()
     .unwrap()
-    .join("PhazeDev\\VRChatPhotoManager\\.sync_lock");
+    .join("PhazeDev/VRChatPhotoManager/.sync_lock");
 
   match fs::metadata(&sync_lock_path) {
     Ok(_) => {
···
           folder_name.nth(0).unwrap()
         );
 
-        let full_path = format!("{}\\{}\\{}", path.to_str().unwrap(), folder_name, photo);
+        let full_path = format!("{}/{}/{}", path.to_str().unwrap(), folder_name, photo);
 
         let res = client
           .get(format!(
···
 
         match res {
           Ok(res) => {
-            let folder_path = format!("{}\\{}", path.to_str().unwrap(), folder_name);
+            let folder_path = format!("{}/{}", path.to_str().unwrap(), folder_name);
             match fs::metadata(&folder_path) {
               Ok(_) => {}
               Err(_) => {

src/Components/PhotoList.tsx

···
   })
 
   listen('show-window', () => {
-    requestAnimationFrame(render);
+    if(hasFirstLoaded)
+      requestAnimationFrame(render);
   })
 
   listen('photo_meta_loaded', ( event: any ) => {
···
 
   let loadPhotos = async () => {
     photoPath = await invoke('get_user_photos_path') + '/';
-    invoke('load_photos')
 
     listen('photos_loaded', ( event: any ) => {
       let photoPaths = event.payload.photos.reverse();
···
 
       let doesHaveLegacy = false;
 
-      if(photoPaths.length === 0){
+      photoPaths.forEach(( path: string ) => {
+        let photo
+
+        if(path.slice(0, 9) === "legacy://"){
+          photo = new Photo(path.slice(9), true);
+          doesHaveLegacy = true;
+        } else
+          photo = new Photo(path, false);
+
+        photos.push(photo);
+        photo.loadMeta();
+      })
+
+      if(doesHaveLegacy){
+        photos = photos.sort(( a, b ) => b.date.valueOf() - a.date.valueOf());
+      }
+
+      console.log(photos.length + ' Photos found.');
+      if(photos.length === 0){
+        console.log('No photos found, Skipping loading stage.');
+
+        filteredPhotos = photos;
+        hasFirstLoaded = true;
+  
         anime({
           targets: photoTreeLoadingContainer,
           height: 0,
···
             photoTreeLoadingContainer.style.display = 'none';
           }
         })
-
+  
         anime({
           targets: '.reload-photos',
           opacity: 1,
           duration: 150,
           easing: 'easeInOutQuad'
         })
-      }
 
-      photoPaths.forEach(( path: string ) => {
-        let photo
-
-        if(path.slice(0, 9) === "legacy://"){
-          photo = new Photo(path.slice(9), true);
-          doesHaveLegacy = true;
-        } else
-          photo = new Photo(path, false);
-
-        photos.push(photo);
-        photo.loadMeta();
-      })
-
-      if(doesHaveLegacy){
-        photos = photos.sort(( a, b ) => b.date.valueOf() - a.date.valueOf());
+        render();
       }
-    })
+    });
+
+    invoke('load_photos');
   }
 
   onMount(() => {