jlkdfgjhslk;jg sedlk;f utgkjerdfgh k;lredhfgvlkjdh gflkjhj vkj hykiludfh fkjedhbnukj

src-tauri/src/main.rs

···
 mod pngmeta;
 mod worldscraper;
 
-use tauri::{ CustomMenuItem, Manager, SystemTray, SystemTrayEvent, SystemTrayMenu, SystemTrayMenuItem, WindowEvent, http::ResponseBuilder };
+use tauri::{ http::ResponseBuilder, CustomMenuItem, Manager, SystemTray, SystemTrayEvent, SystemTrayMenu, SystemTrayMenuItem, WindowEvent };
 use core::time;
 use std::{ fs, io::Read, path, thread };
 use regex::Regex;
···
   path: String,
 }
 
+// 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
+}
+
+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(){
+        let dir = path::PathBuf::from(path);
+        match fs::metadata(&dir){
+          Ok(_) => {}
+          Err(_) => {
+            fs::create_dir(&dir).unwrap();
+          }
+        };
+
+        dir
+      } else{
+        let dir =  dirs::picture_dir().unwrap().join("VRChat");
+        match fs::metadata(&dir){
+          Ok(_) => {}
+          Err(_) => {
+            fs::create_dir(&dir).unwrap();
+          }
+        };
+
+        dir
+      }
+    }
+    Err(_) => {
+      let dir =  dirs::picture_dir().unwrap().join("VRChat");
+      match fs::metadata(&dir){
+        Ok(_) => {}
+        Err(_) => {
+          fs::create_dir(&dir).unwrap();
+        }
+      };
+
+      dir
+    }
+  }
+}
+
 #[tauri::command]
 async fn close_splashscreen(window: tauri::Window) {
   window.get_window("main").unwrap().show().unwrap();
···
   open::that(url).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 {
-  dirs::picture_dir().unwrap().join("VRChat")
+  get_photo_path()
 }
 
 // When the user changes the start with windows toggle
···
   });
 }
 
-// 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]
 fn load_photos(window: tauri::Window) {
   thread::spawn(move || {
-    let base_dir = dirs::picture_dir().unwrap().join("VRChat");
+    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() {
+    for folder in fs::read_dir(&base_dir).unwrap() {
       let f = folder.unwrap();
 
       if f.metadata().unwrap().is_dir() {
···
               if metadata.is_file() {
                 size += metadata.len() as usize;
 
-                let path = path.strip_prefix(dirs::picture_dir().unwrap().join("VRChat")).unwrap().to_path_buf();
+                let path = path.strip_prefix(&base_dir).unwrap().to_path_buf();
                 photos.push(path);
               }
             }
···
   let photo = photo.to_string();
 
   thread::spawn(move || {
-    let mut base_dir = dirs::picture_dir().unwrap().join("VRChat");
-    base_dir.push(&photo);
-  
+    let base_dir = get_photo_path().join(&photo);
+
     let mut file =  fs::File::open(base_dir.clone()).expect("Cannot read image file.");
     let mut buffer = Vec::new();
-  
+
     let _out = file.read_to_end(&mut buffer);
     window.emit("photo_meta_loaded", PNGImage::new(buffer, photo)).unwrap();
   });
···
 // Delete a photo when the users confirms the prompt in the ui
 #[tauri::command]
 fn delete_photo( path: &str ){
-  let p = dirs::picture_dir().unwrap().join("VRChat").join(path);
+  let p = get_photo_path().join(path);
   fs::remove_file(p).unwrap();
 }
 
 #[tauri::command]
 fn change_final_path( new_path: &str ){
-  let config_path = dirs::picture_dir().unwrap().join(".vrchat_photos");
+  let config_path = dirs::home_dir().unwrap().join("AppData\\Roaming\\PhazeDev\\VRChatPhotoManager\\.photos_path");
   fs::write(&config_path, new_path.as_bytes()).unwrap();
 }
 
 fn main() {
   std::env::set_var("WEBVIEW2_ADDITIONAL_BROWSER_ARGUMENTS", "--ignore-gpu-blacklist");
   tauri_plugin_deep_link::prepare("uk.phaz.vrcpm");
+
+  println!("Loading App...");
 
   // Double check the app has an install directory
   let container_folder = dirs::home_dir().unwrap().join("AppData\\Roaming\\PhazeDev\\VRChatPhotoManager");
···
               re1.is_match(path.to_str().unwrap()) ||
               re2.is_match(path.to_str().unwrap())
             {
-              sender.send((2, path.clone().strip_prefix(dirs::picture_dir().unwrap().join("VRChat")).unwrap().to_path_buf())).unwrap();
+              sender.send((2, path.clone().strip_prefix(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(dirs::picture_dir().unwrap().join("VRChat")).unwrap().to_path_buf())).unwrap();
+              sender.send((1, path.clone().strip_prefix(get_photo_path()).unwrap().to_path_buf())).unwrap();
             }
           },
           _ => {}
···
     }
   }).unwrap();
 
-  watcher.watch(&dirs::picture_dir().unwrap().join("VRChat"), RecursiveMode::Recursive).unwrap();
+  watcher.watch(&get_photo_path(), RecursiveMode::Recursive).unwrap();
 
   tauri::Builder::default()
     .system_tray(tray)
···
       }
 
       let path = uri.replace("photo://localhost/", "");
-
-      let mut base_dir = dirs::picture_dir().unwrap().join("VRChat");
-      base_dir.push(path);
-
-      let file = fs::File::open(base_dir);
+      let file = fs::File::open(path);
 
       match file{
         Ok(mut file) => {

src/Components/App.tsx

···
   let [ photoCount, setPhotoCount ] = createSignal(0);
   let [ photoSize, setPhotoSize ] = createSignal(0);
 
+  let [ requestPhotoReload, setRequestPhotoReload ] = createSignal(false);
+
   let setConfirmationBox = ( text: string, cb: () => void ) => {
     setConfirmationBoxText(text);
     confirmationBoxCallback = cb;
   }
 
+  console.log(localStorage.getItem('token'));
   if(localStorage.getItem('token')){
     fetch<any>('https://photos.phazed.xyz/api/v1/account', {
       method: 'GET',
···
           return console.error(data);
         }
 
+        console.log(data.data);
         setLoggedIn({ loggedIn: true, username: data.data.user.username, avatar: data.data.user.avatar, id: data.data.user._id });
       })
       .catch(e => {
···
           return setLoadingType('none');
         }
 
+        console.log(data.data);
         localStorage.setItem('token', token);
 
         setLoadingType('none');
···
         setPhotoNavChoice={setPhotoNavChoice}
         setConfirmationBox={setConfirmationBox}
         setPhotoCount={setPhotoCount}
-        setPhotoSize={setPhotoSize} />
+        setPhotoSize={setPhotoSize}
+        requestPhotoReload={requestPhotoReload}
+        setRequestPhotoReload={setRequestPhotoReload} />
 
       <PhotoViewer
         setPhotoNavChoice={setPhotoNavChoice}
···
 
       <SettingsMenu
         photoCount={photoCount}
-        photoSize={photoSize} />
+        photoSize={photoSize}
+        setRequestPhotoReload={setRequestPhotoReload} />
 
       <div class="copy-notif">Image Copied!</div>
 

src/Components/PhotoList.tsx

···
   photoNavChoice!: () => string;
   setPhotoNavChoice!: ( view: any ) => any;
   setConfirmationBox!: ( text: string, cb: () => void ) => void;
+  requestPhotoReload!: () => boolean;
+  setRequestPhotoReload!: ( val: boolean ) => boolean;
 }
 
 let PhotoList = ( props: PhotoListProps ) => {
···
   let photoMetaDataLoadingContainer: HTMLElement;
   let photoMetaDataLoadingBar: HTMLElement;
 
+  let scrollToTop: HTMLElement;
+  let scrollToTopActive = false;
+
   let photoContainer: HTMLCanvasElement;
   let ctx: CanvasRenderingContext2D;
 
···
   let targetScroll: number = 0;
 
   let quitRender: boolean = false;
+  let photoPath: string;
+
+  createEffect(() => {
+    if(props.requestPhotoReload()){
+      props.setRequestPhotoReload(false);
+      reloadPhotos();
+    }
+  })
 
   class PhotoMetadata{
     width!: number;
···
 
       this.imageEl = document.createElement('img');
       this.imageEl.crossOrigin = 'anonymous';
-      this.imageEl.src = 'https://photo.localhost/' + this.path;
+      this.imageEl.src = 'https://photo.localhost/' + photoPath + this.path;
 
       this.imageEl.onload = () => {
         this.image!.width = this.scaledWidth!;
···
     else
       return quitRender = false;
 
+    if(!scrollToTopActive && scroll > photoContainer.height){
+      scrollToTop.style.display = 'flex';
+      anime({ targets: scrollToTop, opacity: 1, translateY: '0px', easing: 'easeInOutQuad', duration: 100 });
+
+      scrollToTopActive = true;
+    } else if(scrollToTopActive && scroll < photoContainer.height){
+      anime({ targets: scrollToTop, opacity: 0, translateY: '-10px', complete: () => scrollToTop.style.display = 'none', easing: 'easeInOutQuad', duration: 100 });
+      scrollToTopActive = false;
+    }
+
     if(!ctx)return;
     ctx.clearRect(0, 0, photoContainer.width, photoContainer.height);
 
···
 
       if(currentRowIndex * 210 - scroll > photoContainer.height){
         p.shown = false;
-        break;
+        continue;
       }
 
       if(!lastPhoto || (lastPhoto.dateString !== p.dateString)){
···
 
       lastPhoto = p;
     }
+
+    if(photos.length == 0){
+      ctx.textAlign = 'center';
+      ctx.textBaseline = 'middle';
+      ctx.globalAlpha = 1;
+      ctx.fillStyle = '#fff';
+      ctx.font = '50px Rubik';
+
+      ctx.fillText("You have no bitches", photoContainer.width / 2, photoContainer.height / 2);
+    }
   }
 
   listen('photo_meta_loaded', ( event: any ) => {
     let data: PhotoMetadata = event.payload;
-    let photo = photos.find(x => x.path === data.path);
 
+    let photo = photos.find(x => x.path === data.path);
     if(!photo)return;
 
     photo.width = data.width;
···
   })
 
   listen('photo_create', ( event: any ) => {
-    console.log(event);
-
     let photo = new Photo(event.payload);
     photos.splice(0, 0, photo);
   })
···
     }
   })
 
-  let reloadPhotos = () => {
+  let reloadPhotos = async () => {
+    photoPath = await invoke('get_user_photos_path') + '/';
+
     photoTreeLoadingContainer.style.opacity = '1';
     photoTreeLoadingContainer.style.height = '100%';
     photoTreeLoadingContainer.style.display = 'flex';
···
   }
 
   let loadPhotos = async () => {
+    photoPath = await invoke('get_user_photos_path') + '/';
     invoke('load_photos')
 
     listen('photos_loaded', ( event: any ) => {
···
         photos.push(photo);
       })
 
+      if(photoPaths.length == 0){
+        anime.set(photoMetaDataLoadingContainer, { height: 0, opacity: 0, display: 'none' });
+        render();
+
+        anime({
+          targets: '.reload-photos',
+          opacity: 1,
+          duration: 150,
+          easing: 'easeInOutQuad'
+        })
+      }
+
       anime({
         targets: photoTreeLoadingContainer,
         height: 0,
···
   onMount(() => {
     ctx = photoContainer.getContext('2d')!;
     loadPhotos();
+
+    anime.set(scrollToTop, { opacity: 0, translateY: '-10px', display: 'none' });
 
     photoContainer.addEventListener('wheel', ( e: WheelEvent ) => {
       targetScroll += e.deltaY;
···
         </div>
       </div>
 
+      <div class="scroll-to-top" ref={( el ) => scrollToTop = el} onClick={() => targetScroll = 0}><i class="fa-solid fa-angle-up"></i></div>
       <div class="reload-photos" onClick={() => props.setConfirmationBox("Are you sure you want to reload all photos? This can cause the application to slow down while it is loading...", reloadPhotos)}><i class="fa-solid fa-arrows-rotate"></i></div>
 
       <canvas class="photo-container" ref={( el ) => photoContainer = el}></canvas>

src/Components/PhotoViewer.tsx

···
   let photoTrayCloseBtn: HTMLElement;
 
   let worldInfoContainer: HTMLElement;
+  let photoPath: string;
 
   let openTray = () => {
     if(trayOpen)return;
···
       imageViewer.style.opacity = '0';
 
       if(photo){
-        imageViewer.style.background = 'url(\'https://photo.localhost/' + props.currentPhotoView().path.replace('\\', '/') +'\')';
+        (async () => {
+          if(!photoPath)
+            photoPath = await invoke('get_user_photos_path') + '/';
+
+          imageViewer.style.background = 'url(\'https://photo.localhost/' + (photoPath + props.currentPhotoView().path).split('\\').join('/') +'\')';
+        })();
 
         anime({
           targets: imageViewer,

src/Components/SettingsMenu.tsx

···
 class SettingsMenuProps{
   photoCount!: () => number;
   photoSize!: () => number;
+  setRequestPhotoReload!: ( val: boolean ) => boolean;
 }
 
 let SettingsMenu = ( props: SettingsMenuProps ) => {
···
           </div>
 
           <br />
-          <p>VRChat Photo Path: <span class="path" ref={( el ) => invoke('get_user_photos_path').then(( path: any ) => el.innerHTML = path)}>Loading...</span></p>
           <p>
-            Final Photo Path:
+            VRChat Photo Path:
             <span class="path" ref={( el ) =>
               invoke('get_user_photos_path').then(( path: any ) => {
                 el.innerHTML = '';
···
               <span class="path" style={{ color: 'green' }} onClick={() => {
                 finalPathPreviousData = finalPathData;
                 finalPathConfirm.style.display = 'none';
+                invoke('change_final_path', { newPath: finalPathData });
+
+                anime({
+                  targets: '.settings',
+                  opacity: 0,
+                  translateX: '500px',
+                  easing: 'easeInOutQuad',
+                  duration: 250,
+                  complete: () => {
+                    anime.set('.settings', { display: 'none' });
+                  }
+                })
+
+                props.setRequestPhotoReload(true);
               }}><i class="fa-solid fa-check"></i></span>
 
               <span class="path" style={{ color: 'red' }} onClick={() => {

src/styles.css

···
   border-radius: 5px;
   margin-left: 5px;
   cursor: pointer;
+}
+
+.scroll-to-top{
+  position: fixed;
+  bottom: 10px;
+  right: 10px;
+  color: white;
+  width: 40px;
+  height: 40px;
+  cursor: pointer;
+  border-radius: 50%;
+  border: 2px solid white;
+  display: flex;
+  justify-content: center;
+  align-items: center;
 }