f*ck it 0.2.0

changelog

···
   - Fixed the control icons do they actually do what they're supposed to do
   - Fixed window not focusing when opening from tray
 
-v0.1.8:
+v0.2.0:
   - Migrate to tauri v2
-  - Photo loading is slightly faster
+
+  - Photos shouldn't cause the ui to lag while loading
+  - Removed the metadata loading screen in favour of loading the metadata just before an image it rendered
+  - 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
+
+  Dev Stuff:
+    - Fixed indentation to be more constistant

public/icon/clock-regular.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 d="M464 256A208 208 0 1 1 48 256a208 208 0 1 1 416 0zM0 256a256 256 0 1 0 512 0A256 256 0 1 0 0 256zM232 120l0 136c0 8 4 15.5 10.7 20l96 64c11 7.4 25.9 4.4 33.3-6.7s4.4-25.9-6.7-33.3L280 243.2 280 120c0-13.3-10.7-24-24-24s-24 10.7-24 24z"/></svg>

public/icon/sliders-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 d="M0 416c0 17.7 14.3 32 32 32l54.7 0c12.3 28.3 40.5 48 73.3 48s61-19.7 73.3-48L480 448c17.7 0 32-14.3 32-32s-14.3-32-32-32l-246.7 0c-12.3-28.3-40.5-48-73.3-48s-61 19.7-73.3 48L32 384c-17.7 0-32 14.3-32 32zm128 0a32 32 0 1 1 64 0 32 32 0 1 1 -64 0zM320 256a32 32 0 1 1 64 0 32 32 0 1 1 -64 0zm32-80c-32.8 0-61 19.7-73.3 48L32 224c-17.7 0-32 14.3-32 32s14.3 32 32 32l246.7 0c12.3 28.3 40.5 48 73.3 48s61-19.7 73.3-48l54.7 0c17.7 0 32-14.3 32-32s-14.3-32-32-32l-54.7 0c-12.3-28.3-40.5-48-73.3-48zM192 128a32 32 0 1 1 0-64 32 32 0 1 1 0 64zm73.3-64C253 35.7 224.8 16 192 16s-61 19.7-73.3 48L32 64C14.3 64 0 78.3 0 96s14.3 32 32 32l86.7 0c12.3 28.3 40.5 48 73.3 48s61-19.7 73.3-48L480 128c17.7 0 32-14.3 32-32s-14.3-32-32-32L265.3 64z"/></svg>

src-tauri/Cargo.lock

···
 ]
 
 [[package]]
+name = "aligned-vec"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4aa90d7ce82d4be67b64039a3d588d38dbcc6736577de4a847025ce5b0c468d1"
+
+[[package]]
 name = "alloc-no-stdlib"
 version = "2.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 checksum = "b3d1d046238990b9cf5bcde22a3fb3584ee5cf65fb2765f454ed428c7a0063da"
 
 [[package]]
+name = "arbitrary"
+version = "1.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7d5a26814d8dcb93b0e5a0ff3c6d80a8843bafb21b39e8e18a6f05471870e110"
+
+[[package]]
+name = "arg_enum_proc_macro"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ae92a5119aa49cdbcf6b9f893fe4e1d98b04ccbf82ee0584ad948a44a734dea"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.75",
+]
+
+[[package]]
+name = "arrayvec"
+version = "0.7.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7c02d123df017efcdfbd739ef81735b36c5ba83ec3c59c80a9d7ecc718f92e50"
+
+[[package]]
 name = "atk"
 version = "0.18.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 checksum = "0c4b4d0bd25bd0b74681c0ad21497610ce1b7c91b1022cd21c80c6fbdd9476b0"
 
 [[package]]
+name = "av1-grain"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6678909d8c5d46a42abcf571271e15fdbc0a225e3646cf23762cd415046c78bf"
+dependencies = [
+ "anyhow",
+ "arrayvec",
+ "log",
+ "nom",
+ "num-rational",
+ "v_frame",
+]
+
+[[package]]
+name = "avif-serialize"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "876c75a42f6364451a033496a14c44bffe41f5f4a8236f697391f11024e596d2"
+dependencies = [
+ "arrayvec",
+]
+
+[[package]]
 name = "backtrace"
 version = "0.3.73"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
 
 [[package]]
+name = "bit_field"
+version = "0.10.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc827186963e592360843fb5ba4b973e145841266c1357f7180c43526f2e5b61"
+
+[[package]]
 name = "bitflags"
 version = "1.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 dependencies = [
  "serde",
 ]
+
+[[package]]
+name = "bitstream-io"
+version = "2.5.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b81e1519b0d82120d2fd469d5bfb2919a9361c48b02d82d04befc1cdd2002452"
 
 [[package]]
 name = "block"
···
  "alloc-no-stdlib",
  "alloc-stdlib",
 ]
+
+[[package]]
+name = "built"
+version = "0.7.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "236e6289eda5a812bc6b53c3b024039382a2895fbbeef2d748b2931546d392c4"
 
 [[package]]
 name = "bumpalo"
···
 checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
 
 [[package]]
+name = "byteorder-lite"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f1fe948ff07f4bd06c30984e69f5b4899c516a3ef74f34df92a2df2ab535495"
+
+[[package]]
 name = "bytes"
 version = "1.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "72db2f7947ecee9b03b510377e8bb9077afa27176fdbff55c51027e976fdcc48"
 dependencies = [
+ "jobserver",
+ "libc",
  "shlex",
 ]
 
···
 ]
 
 [[package]]
+name = "color_quant"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3d7b894f5411737b7867f4827955924d7c254fc9f4d91a6aad6b097804b1018b"
+
+[[package]]
 name = "combine"
 version = "4.6.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 ]
 
 [[package]]
+name = "crossbeam-deque"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "613f8cc01fe9cf1a3eb3d7f488fd2fa8388403e97039e2f73692932e291a770d"
+dependencies = [
+ "crossbeam-epoch",
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-epoch"
+version = "0.9.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5b82ac4a3c2ca9c3460964f020e1402edd5753411d7737aa39c3714ad1b5420e"
+dependencies = [
+ "crossbeam-utils",
+]
+
+[[package]]
 name = "crossbeam-utils"
 version = "0.8.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "22ec99545bb0ed0ea7bb9b8e1e9122ea386ff8a48c0922e43f36d45ab09e0e80"
 
 [[package]]
+name = "crunchy"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7a81dae078cea95a014a339291cec439d2f232ebe854a9d672b796c6afafa9b7"
+
+[[package]]
 name = "crypto-common"
 version = "0.1.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 ]
 
 [[package]]
+name = "document-features"
+version = "0.2.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cb6969eaabd2421f8a2775cfd2471a2b634372b4a25d41e3bd647b79912850a0"
+dependencies = [
+ "litrs",
+]
+
+[[package]]
 name = "dpi"
 version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 version = "1.0.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0d6ef0072f8a535281e4876be788938b528e9a1d43900b82c2569af7da799125"
+
+[[package]]
+name = "either"
+version = "1.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "60b1af1c220855b6ceac025d3f6ecdd2b7c4894bfe9cd9bda4fbb4bc7c0d4cf0"
 
 [[package]]
 name = "embed-resource"
···
 ]
 
 [[package]]
+name = "exr"
+version = "1.72.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "887d93f60543e9a9362ef8a21beedd0a833c5d9610e18c67abe15a5963dcb1a4"
+dependencies = [
+ "bit_field",
+ "flume",
+ "half",
+ "lebe",
+ "miniz_oxide 0.7.4",
+ "rayon-core",
+ "smallvec",
+ "zune-inflate",
+]
+
+[[package]]
+name = "fast_image_resize"
+version = "4.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2ca4b58827213977eabab8ee8d8258db8441338f3a1832a1c0f2de3372175531"
+dependencies = [
+ "bytemuck",
+ "cfg-if",
+ "document-features",
+ "image 0.25.2",
+ "num-traits",
+ "thiserror",
+]
+
+[[package]]
 name = "fastrand"
 version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 checksum = "17c704e9dbe1ddd863da1e6ff3567795087b1eb201ce80d8fa81162e1516500d"
 dependencies = [
  "bitflags 1.3.2",
+]
+
+[[package]]
+name = "flume"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "55ac459de2512911e4b674ce33cf20befaba382d05b62b008afc1c8b57cbf181"
+dependencies = [
+ "spin",
 ]
 
 [[package]]
···
 ]
 
 [[package]]
+name = "gif"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3fb2d69b19215e18bb912fa30f7ce15846e301408695e44e0ef719f1da9e19f2"
+dependencies = [
+ "color_quant",
+ "weezl",
+]
+
+[[package]]
 name = "gimli"
 version = "0.29.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 ]
 
 [[package]]
+name = "half"
+version = "2.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6dd08c532ae367adf81c312a4580bc67f1d0fe8bc9c460520283f4c0ff277888"
+dependencies = [
+ "cfg-if",
+ "crunchy",
+]
+
+[[package]]
 name = "hashbrown"
 version = "0.12.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 ]
 
 [[package]]
+name = "image"
+version = "0.24.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5690139d2f55868e080017335e4b94cb7414274c74f1669c84fb5feba2c9f69d"
+dependencies = [
+ "bytemuck",
+ "byteorder",
+ "color_quant",
+ "num-traits",
+ "png",
+]
+
+[[package]]
+name = "image"
+version = "0.25.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "99314c8a2152b8ddb211f924cdae532d8c5e4c8bb54728e12fff1b0cd5963a10"
+dependencies = [
+ "bytemuck",
+ "byteorder-lite",
+ "color_quant",
+ "exr",
+ "gif",
+ "image-webp",
+ "num-traits",
+ "png",
+ "qoi",
+ "ravif",
+ "rayon",
+ "rgb",
+ "tiff",
+ "zune-core",
+ "zune-jpeg",
+]
+
+[[package]]
+name = "image-webp"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f79afb8cbee2ef20f59ccd477a218c12a93943d075b492015ecb1bb81f8ee904"
+dependencies = [
+ "byteorder-lite",
+ "quick-error",
+]
+
+[[package]]
+name = "imgref"
+version = "1.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "44feda355f4159a7c757171a77de25daf6411e217b4cabd03bd6650690468126"
+
+[[package]]
 name = "indexmap"
 version = "1.9.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 ]
 
 [[package]]
+name = "interpolate_name"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c34819042dc3d3971c46c2190835914dfbe0c3c13f61449b2997f4e9722dfa60"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.75",
+]
+
+[[package]]
 name = "interprocess"
 version = "1.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 dependencies = [
  "is-docker",
  "once_cell",
+]
+
+[[package]]
+name = "itertools"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba291022dbbd398a455acf126c1e341954079855bc60dfdda641363bd6922569"
+dependencies = [
+ "either",
 ]
 
 [[package]]
···
 checksum = "8eaf4bc02d17cbdd7ff4c7438cafcdf7fb9a4613313ad11b4f8fefe7d3fa0130"
 
 [[package]]
+name = "jobserver"
+version = "0.1.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "48d1dbcbbeb6a7fec7e059840aa538bd62aaccf972c7346c4d9d2059312853d0"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "jpeg-decoder"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f5d4a7da358eff58addd2877a45865158f0d78c911d43a5784ceb7bbf52833b0"
+
+[[package]]
 name = "js-sys"
 version = "0.3.70"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
 
 [[package]]
+name = "lebe"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "03087c2bad5e1034e8cace5926dec053fb3790248370865f5117a7d0213354c8"
+
+[[package]]
 name = "libappindicator"
 version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 checksum = "d8adc4bb1803a324070e64a98ae98f38934d91957a99cfb3a43dcbc01bc56439"
 
 [[package]]
+name = "libfuzzer-sys"
+version = "0.4.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a96cfd5557eb82f2b83fed4955246c988d331975a002961b07c81584d107e7f7"
+dependencies = [
+ "arbitrary",
+ "cc",
+ "once_cell",
+]
+
+[[package]]
 name = "libloading"
 version = "0.7.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 checksum = "78b3ae25bc7c8c38cec158d1f2757ee79e9b3740fbc7ccf0e59e4b08d793fa89"
 
 [[package]]
+name = "litrs"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b4ce301924b7887e9d637144fdade93f9dfff9b60981d4ac161db09720d39aa5"
+
+[[package]]
 name = "lock_api"
 version = "0.4.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 ]
 
 [[package]]
+name = "loop9"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fae87c125b03c1d2c0150c90365d7d6bcc53fb73a9acaef207d2d065860f062"
+dependencies = [
+ "imgref",
+]
+
+[[package]]
 name = "mac"
 version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 checksum = "2532096657941c2fea9c289d370a250971c689d4f143798ff67113ec042024a5"
 
 [[package]]
+name = "maybe-rayon"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ea1f30cedd69f0a2954655f7188c6a834246d2bcf1e315e2ac40c4b24dc9519"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
 name = "memchr"
 version = "2.7.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 checksum = "6877bb514081ee2a7ff5ef9de3281f14a4dd4bceac4c09388074a6b5df8a139a"
 
 [[package]]
+name = "minimal-lexical"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a"
+
+[[package]]
 name = "miniz_oxide"
 version = "0.7.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 checksum = "72ef4a56884ca558e5ddb05a1d1e7e1bfd9a68d9ed024c21704cc98872dae1bb"
 
 [[package]]
+name = "nom"
+version = "7.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d273983c5a657a70a3e8f2a01329822f3b8c8172b73826411a55751e404a0a4a"
+dependencies = [
+ "memchr",
+ "minimal-lexical",
+]
+
+[[package]]
+name = "noop_proc_macro"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0676bb32a98c1a483ce53e500a81ad9c3d5b3f7c920c28c24e9cb0980d0b5bc8"
+
+[[package]]
 name = "notify"
 version = "6.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 ]
 
 [[package]]
+name = "num-bigint"
+version = "0.4.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a5e44f723f1133c9deac646763579fdb3ac745e418f2a7af9cd0c431da1f20b9"
+dependencies = [
+ "num-integer",
+ "num-traits",
+]
+
+[[package]]
 name = "num-conv"
 version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "51d515d32fb182ee37cda2ccdcb92950d6a3c2893aa280e540671c2cd0f3b1d9"
 
 [[package]]
+name = "num-derive"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed3955f1a9c7c0c15e092f9c887db08b1fc683305fdf6eb6684f22555355e202"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.75",
+]
+
+[[package]]
+name = "num-integer"
+version = "0.1.46"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7969661fd2958a5cb096e56c8e1ad0444ac2bbcd0061bd28660485a44879858f"
+dependencies = [
+ "num-traits",
+]
+
+[[package]]
+name = "num-rational"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f83d14da390562dca69fc84082e73e548e1ad308d24accdedd2720017cb37824"
+dependencies = [
+ "num-bigint",
+ "num-integer",
+ "num-traits",
+]
+
+[[package]]
 name = "num-traits"
 version = "0.2.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 ]
 
 [[package]]
+name = "paste"
+version = "1.0.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a"
+
+[[package]]
 name = "pathdiff"
 version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 ]
 
 [[package]]
+name = "profiling"
+version = "1.0.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "43d84d1d7a6ac92673717f9f6d1518374ef257669c24ebc5ac25d5033828be58"
+dependencies = [
+ "profiling-procmacros",
+]
+
+[[package]]
+name = "profiling-procmacros"
+version = "1.0.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8021cf59c8ec9c432cfc2526ac6b8aa508ecaf29cd415f271b8406c1b851c3fd"
+dependencies = [
+ "quote",
+ "syn 2.0.75",
+]
+
+[[package]]
 name = "psl-types"
 version = "2.0.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
  "idna 0.3.0",
  "psl-types",
 ]
+
+[[package]]
+name = "qoi"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f6d64c71eb498fe9eae14ce4ec935c555749aef511cca85b5568910d6e48001"
+dependencies = [
+ "bytemuck",
+]
+
+[[package]]
+name = "quick-error"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a993555f31e5a609f617c12db6250dedcac1b0a85076912c436e6fc9b2c8e6a3"
 
 [[package]]
 name = "quick-xml"
···
 ]
 
 [[package]]
+name = "rav1e"
+version = "0.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cd87ce80a7665b1cce111f8a16c1f3929f6547ce91ade6addf4ec86a8dda5ce9"
+dependencies = [
+ "arbitrary",
+ "arg_enum_proc_macro",
+ "arrayvec",
+ "av1-grain",
+ "bitstream-io",
+ "built",
+ "cfg-if",
+ "interpolate_name",
+ "itertools",
+ "libc",
+ "libfuzzer-sys",
+ "log",
+ "maybe-rayon",
+ "new_debug_unreachable",
+ "noop_proc_macro",
+ "num-derive",
+ "num-traits",
+ "once_cell",
+ "paste",
+ "profiling",
+ "rand 0.8.5",
+ "rand_chacha 0.3.1",
+ "simd_helpers",
+ "system-deps",
+ "thiserror",
+ "v_frame",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "ravif"
+version = "0.11.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a8f0bfd976333248de2078d350bfdf182ff96e168a24d23d2436cef320dd4bdd"
+dependencies = [
+ "avif-serialize",
+ "imgref",
+ "loop9",
+ "quick-error",
+ "rav1e",
+ "rgb",
+]
+
+[[package]]
 name = "raw-window-handle"
 version = "0.6.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "20675572f6f24e9e76ef639bc5552774ed45f1c30e2951e1e99c59888861c539"
+
+[[package]]
+name = "rayon"
+version = "1.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b418a60154510ca1a002a752ca9714984e21e4241e804d32555251faf8b78ffa"
+dependencies = [
+ "either",
+ "rayon-core",
+]
+
+[[package]]
+name = "rayon-core"
+version = "1.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1465873a3dfdaa8ae7cb14b4383657caab0b3e8a0aa9ae8e04b044854c8dfce2"
+dependencies = [
+ "crossbeam-deque",
+ "crossbeam-utils",
+]
 
 [[package]]
 name = "redox_syscall"
···
 ]
 
 [[package]]
+name = "rgb"
+version = "0.8.48"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0f86ae463694029097b846d8f99fd5536740602ae00022c0c50c5600720b2f71"
+dependencies = [
+ "bytemuck",
+]
+
+[[package]]
 name = "ring"
 version = "0.17.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 checksum = "d66dc143e6b11c1eddc06d5c423cfc97062865baf299914ab64caa38182078fe"
 
 [[package]]
+name = "simd_helpers"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "95890f873bec569a0362c235787f3aca6e1e887302ba4840839bcc6459c42da6"
+dependencies = [
+ "quote",
+]
+
+[[package]]
 name = "siphasher"
 version = "0.3.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 version = "0.9.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6980e8d7511241f8acf4aebddbb1ff938df5eebe98691418c4468d0b72a96a67"
+dependencies = [
+ "lock_api",
+]
 
 [[package]]
 name = "stable_deref_trait"
···
  "gtk",
  "heck 0.5.0",
  "http",
+ "image 0.24.9",
  "jni",
  "libc",
  "log",
···
 ]
 
 [[package]]
+name = "tiff"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba1310fcea54c6a9a4fd1aad794ecc02c31682f6bfbecdf460bf19533eed1e3e"
+dependencies = [
+ "flate2",
+ "jpeg-decoder",
+ "weezl",
+]
+
+[[package]]
 name = "time"
 version = "0.3.36"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 ]
 
 [[package]]
+name = "v_frame"
+version = "0.3.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d6f32aaa24bacd11e488aa9ba66369c7cd514885742c9fe08cfe85884db3e92b"
+dependencies = [
+ "aligned-vec",
+ "num-traits",
+ "wasm-bindgen",
+]
+
+[[package]]
 name = "valuable"
 version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 version = "0.1.7"
 dependencies = [
  "dirs",
+ "fast_image_resize",
+ "image 0.25.2",
  "mslnk",
  "notify",
  "open",
···
  "windows 0.58.0",
  "windows-core 0.58.0",
 ]
+
+[[package]]
+name = "weezl"
+version = "0.1.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "53a85b86a771b1c87058196170769dd264f66c0782acf1ae6cc51bfd64b39082"
 
 [[package]]
 name = "winapi"
···
 version = "1.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ced3678a2879b30306d323f4542626697a464a97c0a07c9aebf7ebca65cd4dde"
+
+[[package]]
+name = "zune-core"
+version = "0.4.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f423a2c17029964870cfaabb1f13dfab7d092a62a29a89264f4d36990ca414a"
+
+[[package]]
+name = "zune-inflate"
+version = "0.2.54"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "73ab332fe2f6680068f3582b16a24f90ad7096d5d39b974d1c0aff0125116f02"
+dependencies = [
+ "simd-adler32",
+]
+
+[[package]]
+name = "zune-jpeg"
+version = "0.4.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "16099418600b4d8f028622f73ff6e3deaabdff330fb9a2a131dea781ee8b0768"
+dependencies = [
+ "zune-core",
+]

src-tauri/Cargo.toml

···
 tauri-build = { version = "2.0.0-rc", features = [] }
 
 [dependencies]
-tauri = { version = "2.0.0-rc", features = ["tray-icon"] }
+tauri = { version = "2.0.0-rc", features = ["tray-icon", "image-png"] }
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 open = "5.1.2"
···
 tauri-plugin-shell = "2.0.0-rc.2"
 tauri-plugin-http = "2.0.0-rc.0"
 tauri-plugin-process = "2.0.0-rc.0"
+image = "0.25.2"
+fast_image_resize = { version = "4.2.1", features = [ "image" ] }
 
 [features]
 # this feature is used for production builds or when `devPath` points to the filesystem

src-tauri/capabilities/migrated.json

···
     "core:window:allow-unmaximize",
     "core:window:allow-minimize",
     "core:window:allow-unminimize",
+    "core:window:allow-toggle-maximize",
     "core:window:allow-show",
     "core:window:allow-hide",
     "core:window:allow-close",

src-tauri/gen/schemas/capabilities.json

···
-{"migrated":{"identifier":"migrated","description":"permissions that were migrated from v1","local":true,"windows":["main"],"permissions":["core:default","core:window:allow-maximize","core:window:allow-unmaximize","core:window:allow-minimize","core:window:allow-unminimize","core:window:allow-show","core:window:allow-hide","core:window:allow-close","core:window:allow-start-dragging","shell:allow-open",{"identifier":"http:default","allow":[{"url":"https://photos.phazed.xyz/*"},{"url":"https://photos-cdn.phazed.xyz/*"}]},"process:allow-restart","shell:default","http:default","process:default"]}}
+{"migrated":{"identifier":"migrated","description":"permissions that were migrated from v1","local":true,"windows":["main"],"permissions":["core:default","core:window:allow-maximize","core:window:allow-unmaximize","core:window:allow-minimize","core:window:allow-unminimize","core:window:allow-toggle-maximize","core:window:allow-show","core:window:allow-hide","core:window:allow-close","core:window:allow-start-dragging","shell:allow-open",{"identifier":"http:default","allow":[{"url":"https://photos.phazed.xyz/*"},{"url":"https://photos-cdn.phazed.xyz/*"}]},"process:allow-restart","shell:default","http:default","process:default"]}}

src-tauri/src/main.rs

···
 mod worldscraper;
 
 use core::time;
+use image::{ codecs::png::{ PngDecoder, PngEncoder }, DynamicImage, ImageEncoder };
+use fast_image_resize::{ images::Image, IntoImageView, ResizeOptions, Resizer };
 use mslnk::ShellLink;
 use notify::{EventKind, RecursiveMode, Watcher};
 use pngmeta::PNGImage;
 use regex::Regex;
 use std::{
-    env, fs,
-    io::Read,
-    path,
-    process::{self, Command},
-    thread,
-    time::Duration,
+  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
+  http::Response, menu::{MenuBuilder, MenuItemBuilder}, tray::{MouseButton, MouseButtonState, TrayIconBuilder, TrayIconEvent}, AppHandle, Emitter, Manager, WindowEvent
 };
 use worldscraper::World;
+
+// 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,
+  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");
+  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"),
+  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();
+  window.get_webview_window("main").unwrap().show().unwrap();
 }
 
 #[tauri::command]
 fn start_user_auth() {
-    open::that("https://photos.phazed.xyz/api/v1/auth").unwrap();
+  open::that("https://photos.phazed.xyz/api/v1/auth").unwrap();
 }
 
 #[tauri::command]
 fn open_url(url: &str) {
-    open::that(url).unwrap();
+  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()
+  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");
+  thread::spawn(move || {
+    if start {
+      let target = dirs::home_dir()
+        .unwrap()
+        .join("AppData\\Roaming\\PhazeDev\\VRChatPhotoManager\\vrchat-photo-manager.exe");
 
-                    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();
+      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();
-    });
+  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);
-    });
+  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();
+  thread::spawn(move || {
+    let base_dir = get_photo_path();
 
-        let mut photos: Vec<path::PathBuf> = Vec::new();
-        let mut size: usize = 0;
+    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();
+    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 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();
+          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();
+            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 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;
+              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());
-                    }
-                }
+                let path = path.strip_prefix(&base_dir).unwrap().to_path_buf();
+                photos.push(path);
+              }
             } else {
-                println!("Ignoring {:#?} as it isn't a directory", f.file_name());
+              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();
-    });
+    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();
+  let photo = photo.to_string();
 
-    thread::spawn(move || {
-        let base_dir = get_photo_path().join(&photo);
+  thread::spawn(move || {
+    let base_dir = get_photo_path().join(&photo);
 
-        let file = fs::File::open(base_dir.clone());
+    let file = fs::File::open(base_dir.clone());
 
-        match file {
-            Ok(mut file) => {
-                let mut buffer = Vec::new();
+    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");
-            }
-        }
-    });
+        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();
+  thread::spawn(move || {
+    let p = get_photo_path().join(&path);
+    fs::remove_file(p).unwrap();
 
-        let photo = path.split("\\").last().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();
-        }
-    });
+    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();
+  let config_path = dirs::home_dir()
+    .unwrap()
+    .join("AppData\\Roaming\\PhazeDev\\VRChatPhotoManager\\.photos_path");
 
-    match fs::metadata(&new_path) {
-        Ok(_) => {}
-        Err(_) => {
-            fs::create_dir(&new_path).unwrap();
-        }
-    };
+  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)
+  String::from(VERSION)
 }
 
 #[tauri::command]
 fn relaunch() {
-    let container_folder = dirs::home_dir()
-        .unwrap()
-        .join("AppData\\Roaming\\PhazeDev\\VRChatPhotoManager");
+  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");
+  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);
+  process::exit(0);
 }
 
 fn main() {
-    std::env::set_var(
-        "WEBVIEW2_ADDITIONAL_BROWSER_ARGUMENTS",
-        "--ignore-gpu-blacklist",
-    );
-    tauri_plugin_deep_link::prepare("uk.phaz.vrcpm");
+  tauri_plugin_deep_link::prepare("uk.phaz.vrcpm");
+
+  // Double check the app has an install directory
+  let container_folder = dirs::home_dir()
+    .unwrap()
+    .join("AppData\\Roaming\\PhazeDev\\VRChatPhotoManager");
 
-    // Double check the app has an install directory
-    let container_folder = dirs::home_dir()
-        .unwrap()
-        .join("AppData\\Roaming\\PhazeDev\\VRChatPhotoManager");
-    match fs::metadata(&container_folder) {
-        Ok(meta) => {
-            if meta.is_file() {
-                panic!("Cannot launch app as the container path is a file not a directory");
-            }
-        }
-        Err(_) => {
-            fs::create_dir(&container_folder).unwrap();
-        }
+  match fs::metadata(&container_folder) {
+    Ok(meta) => {
+      if meta.is_file() {
+        panic!("Cannot launch app as the container path is a file not a directory");
+      }
     }
+    Err(_) => {
+      fs::create_dir(&container_folder).unwrap();
+    }
+  }
 
-    let sync_lock_path = dirs::home_dir()
-        .unwrap()
-        .join("AppData\\Roaming\\PhazeDev\\VRChatPhotoManager\\.sync_lock");
-    match fs::metadata(&sync_lock_path) {
-        Ok(_) => {
-            fs::remove_file(&sync_lock_path).unwrap();
-        }
-        Err(_) => {}
+  let sync_lock_path = dirs::home_dir()
+    .unwrap()
+    .join("AppData\\Roaming\\PhazeDev\\VRChatPhotoManager\\.sync_lock");
+
+  match fs::metadata(&sync_lock_path) {
+    Ok(_) => {
+      fs::remove_file(&sync_lock_path).unwrap();
     }
+    Err(_) => {}
+  }
 
-    println!("Loading App...");
-    let photos_path = get_photo_path();
+  println!("Loading App...");
+  let photos_path = get_photo_path();
 
-    match fs::metadata(&photos_path) {
-        Ok(_) => {}
-        Err(_) => {
-            fs::create_dir(&photos_path).unwrap();
-        }
-    };
+  match fs::metadata(&photos_path) {
+    Ok(_) => {}
+    Err(_) => {
+      fs::create_dir(&photos_path).unwrap();
+    }
+  };
 
-    let args: Vec<String> = env::args().collect();
+  let args: Vec<String> = env::args().collect();
 
-    let mut update = true;
-    for arg in args {
-        if arg == "--no-update" {
-            update = false;
-        }
+  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();
+  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();
+      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();
+      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();
-                    }
-                }
+            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");
+        let mut cmd = Command::new(&container_folder.join("./updater.exe"));
+        cmd.current_dir(container_folder);
+        cmd.spawn().expect("Cannot run updater");
 
-                process::exit(0);
-            }
-        });
-    }
+        process::exit(0);
+      }
+    });
+  }
 
-    // Listen for file updates, store each update in an mpsc channel and send to the frontend
-    let (sender, receiver) = std::sync::mpsc::channel();
-    let mut watcher = notify::recommended_watcher(move | res: Result<notify::Event, notify::Error> | {
+  // Listen for file updates, store each update in an mpsc channel and send to the frontend
+  let (sender, receiver) = std::sync::mpsc::channel();
+  let mut watcher = notify::recommended_watcher(move | res: Result<notify::Event, notify::Error> | {
     match res {
-       Ok(event) => {
+        Ok(event) => {
         match event.kind{
           EventKind::Remove(_) => {
             let path = event.paths.first().unwrap();
···
     }
   }).unwrap();
 
-    watcher
-        .watch(&get_photo_path(), RecursiveMode::Recursive)
-        .unwrap();
+  watcher
+    .watch(&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| {
+        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();
 
-    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| {
-            thread::spawn(move || {
-                // Loads the requested image file, sends data back to the user
-                let uri = request.uri();
+                  let opts = ResizeOptions::new()
+                    .resize_alg(fast_image_resize::ResizeAlg::Nearest);
 
-                if request.method() != "GET" {
-                  responder.respond(Response::builder()
-                    .status(404)
-                    .header("Access-Control-Allow-Origin", "*")
-                    .body(Vec::new())
-                    .unwrap());
+                  resizer.resize(&src_image, &mut dst_image, Some(&opts)).unwrap();
 
-                  return;
-                }
+                  let mut buf = Vec::new();
+                  let encoder = PngEncoder::new(&mut buf);
 
-                let path = uri.path().split_at(1).1;
-                let file = fs::File::open(path);
+                  encoder.write_image(dst_image.buffer(), dst_width, dst_height, src_image.color().into()).unwrap();
 
-                match file {
-                    Ok(mut file) => {
-                        let mut buffer = Vec::new();
+                  let res = Response::builder()
+                    .status(200)
+                    .header("Access-Control-Allow-Origin", "*")
+                    .body(buf)
+                    .unwrap();
 
-                        let _out = file.read_to_end(&mut buffer);
+                  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(buffer)
-                            .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());
-                    }
+                  responder.respond(res);
                 }
-            });
-        })
-        .on_window_event(| window, event | match event {
-            WindowEvent::CloseRequested { api, .. } => {
-              window.hide().unwrap();
-              api.prevent_close();
+              }
             }
-            _ => {}
-        })
-        .setup(|app| {
-            let handle = app.handle().clone();
+            Err(_) => {
+              responder.respond(
+                Response::builder()
+                  .status(404)
+                  .header("Access-Control-Allow-Origin", "*")
+                  .body(b"File Not Found")
+                  .unwrap(),
+              );
+            }
+          }
+        });
+    })
+    .on_window_event(|window, event| match event {
+        WindowEvent::CloseRequested { api, .. } => {
+          window.hide().unwrap();
+          api.prevent_close();
+        }
+        _ => {}
+    })
+    .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();
+      // Setup the tray icon and menu buttons
+      let quit = MenuItemBuilder::new("Quit")
+        .id("quit")
+        .build(&handle)
+        .unwrap();
 
-            let tray_menu = MenuBuilder::new(&handle)
-              .items(&[ &quit, &hide ])
-              .build().unwrap();
+      let hide = MenuItemBuilder::new("Hide / Show")
+        .id("hide")
+        .build(&handle)
+        .unwrap();
 
-            TrayIconBuilder::with_id("vrcpm-tray")
-              .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();
+      let tray_menu = MenuBuilder::new(&handle)
+        .items(&[&quit, &hide])
+        .build()
+        .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();
+      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();
 
-                  window.show().unwrap();
-                  window.set_focus().unwrap();
-                }
-              })
-              .build(&handle).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();
 
-            // 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;
+            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;
+        for part in request.split('/').into_iter() {
+          index += 1;
 
-                if index == 3 && part == "auth-callback" {
-                  command = 1;
-                }
+          if index == 3 && part == "auth-callback" {
+            command = 1;
+          }
 
-                if index == 3 && part == "auth-denied" {
-                  handle.emit("auth-denied", "null").unwrap();
-                }
+          if index == 3 && part == "auth-denied" {
+            handle.emit("auth-denied", "null").unwrap();
+          }
 
-                if index == 4 && command == 1 {
-                  handle.emit("auth-callback", part).unwrap();
-                }
-              }
-            })
-            .unwrap();
+          if index == 4 && command == 1 {
+            handle.emit("auth-callback", part).unwrap();
+          }
+        }
+      })
+      .unwrap();
 
-            // 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
-            let window = app.get_webview_window("main").unwrap();
-            thread::spawn(move || {
-                thread::sleep(time::Duration::from_millis(100));
+      // 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
+      let window = app.get_webview_window("main").unwrap();
+      thread::spawn(move || {
+        thread::sleep(time::Duration::from_millis(100));
 
-                for event in receiver {
-                    match event.0 {
-                        1 => {
-                            window.emit("photo_create", event.1).unwrap();
-                        }
-                        2 => {
-                            window.emit("photo_remove", event.1).unwrap();
-                        }
-                        _ => {}
-                    }
-                }
-            });
+        for event in receiver {
+          match event.0 {
+            1 => {
+              window.emit("photo_create", event.1).unwrap();
+            }
+            2 => {
+              window.emit("photo_remove", event.1).unwrap();
+            }
+            _ => {}
+          }
+        }
+      });
 
-            Ok(())
-        })
-        .invoke_handler(tauri::generate_handler![
-            start_user_auth,
-            load_photos,
-            close_splashscreen,
-            load_photo_meta,
-            delete_photo,
-            open_url,
-            find_world_by_id,
-            start_with_win,
-            get_user_photos_path,
-            change_final_path,
-            sync_photos,
-            get_version,
-            relaunch
-        ])
-        .run(tauri::generate_context!())
-        .expect("error while running tauri application");
+      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
+    ])
+    .run(tauri::generate_context!())
+    .expect("error while running tauri application");
 }

src-tauri/src/photosync.rs

···
 
 #[derive(Clone, Serialize)]
 struct PhotoUploadMeta {
-    photos_uploading: usize,
-    photos_total: usize,
+  photos_uploading: usize,
+  photos_total: usize,
 }
 
 pub fn sync_photos(token: String, path: path::PathBuf, window: tauri::Window) {
-    let sync_lock_path = dirs::home_dir()
-        .unwrap()
-        .join("AppData\\Roaming\\PhazeDev\\VRChatPhotoManager\\.sync_lock");
-    match fs::metadata(&sync_lock_path) {
-        Ok(_) => {
-            return;
-        }
-        Err(_) => {}
+  let sync_lock_path = dirs::home_dir()
+    .unwrap()
+    .join("AppData\\Roaming\\PhazeDev\\VRChatPhotoManager\\.sync_lock");
+
+  match fs::metadata(&sync_lock_path) {
+    Ok(_) => {
+      return;
     }
+    Err(_) => {}
+  }
 
-    fs::write(&sync_lock_path, "Currently Syncing").unwrap();
+  fs::write(&sync_lock_path, "Currently Syncing").unwrap();
 
-    match fs::metadata(&path) {
-        Ok(_) => {}
-        Err(_) => {
-            fs::create_dir(&path).unwrap();
-        }
-    };
+  match fs::metadata(&path) {
+    Ok(_) => {}
+    Err(_) => {
+      fs::create_dir(&path).unwrap();
+    }
+  };
 
-    let mut photos: Vec<String> = Vec::new();
+  let mut photos: Vec<String> = Vec::new();
 
-    for folder in fs::read_dir(&path).unwrap() {
-        let f = folder.unwrap();
+  for folder in fs::read_dir(&path).unwrap() {
+    let f = folder.unwrap();
 
-        if f.metadata().unwrap().is_dir() {
-            match fs::read_dir(f.path()) {
-                Ok(dir) => {
-                    for photo in dir {
-                        let p = photo.unwrap();
+    if f.metadata().unwrap().is_dir() {
+      match fs::read_dir(f.path()) {
+        Ok(dir) => {
+          for photo in dir {
+            let p = photo.unwrap();
 
-                        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();
+            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())
-                        {
-                            photos.push(p.file_name().into_string().unwrap());
-                        }
-                    }
-                }
-                Err(_) => {}
+            if re1.is_match(p.file_name().to_str().unwrap())
+              || re2.is_match(p.file_name().to_str().unwrap())
+            {
+              photos.push(p.file_name().into_string().unwrap());
             }
+          }
         }
+        Err(_) => {}
+      }
     }
+  }
 
-    let body = reqwest::blocking::get(format!(
-        "https://photos-cdn.phazed.xyz/api/v1/photos/exists?token={}",
-        &token
-    ))
-    .unwrap()
-    .text()
-    .unwrap();
+  let body = reqwest::blocking::get(format!(
+    "https://photos-cdn.phazed.xyz/api/v1/photos/exists?token={}",
+    &token
+  ))
+  .unwrap()
+  .text()
+  .unwrap();
 
-    let body: Value = serde_json::from_str(&body).unwrap();
+  let body: Value = serde_json::from_str(&body).unwrap();
 
-    let mut photos_to_upload: Vec<String> = Vec::new();
-    let uploaded_photos = body["files"].as_array().unwrap();
+  let mut photos_to_upload: Vec<String> = Vec::new();
+  let uploaded_photos = body["files"].as_array().unwrap();
 
-    let photos_len = photos.len();
+  let photos_len = photos.len();
 
-    for photo in &photos {
-        let mut found_photo = false;
+  for photo in &photos {
+    let mut found_photo = false;
 
-        for uploaded_photo in uploaded_photos {
-            if photo == uploaded_photo.as_str().unwrap() {
-                found_photo = true;
-                break;
-            }
-        }
+    for uploaded_photo in uploaded_photos {
+      if photo == uploaded_photo.as_str().unwrap() {
+        found_photo = true;
+        break;
+      }
+    }
 
-        if !found_photo {
-            photos_to_upload.push(photo.clone());
-        }
+    if !found_photo {
+      photos_to_upload.push(photo.clone());
     }
+  }
 
-    window
-        .emit(
-            "photos-upload-meta",
-            PhotoUploadMeta {
-                photos_uploading: photos_to_upload.len(),
-                photos_total: photos_len,
-            },
-        )
-        .unwrap();
-    let mut photos_left = photos_to_upload.len();
+  window
+    .emit(
+      "photos-upload-meta",
+      PhotoUploadMeta {
+        photos_uploading: photos_to_upload.len(),
+        photos_total: photos_len,
+      },
+    )
+    .unwrap();
 
-    let client = reqwest::blocking::Client::new();
+  let mut photos_left = photos_to_upload.len();
 
-    loop {
-        match photos_to_upload.pop() {
-            Some(photo) => {
-                let folder_name = photo.clone().replace("VRChat_", "");
-                let mut folder_name = folder_name.split("-");
-                let folder_name = format!(
-                    "{}-{}",
-                    folder_name.nth(0).unwrap(),
-                    folder_name.nth(0).unwrap()
-                );
+  let client = reqwest::blocking::Client::new();
 
-                let full_path = format!("{}\\{}\\{}", path.to_str().unwrap(), folder_name, photo);
-                let file = fs::File::open(full_path);
+  loop {
+    match photos_to_upload.pop() {
+      Some(photo) => {
+        let folder_name = photo.clone().replace("VRChat_", "");
+        let mut folder_name = folder_name.split("-");
+        let folder_name = format!(
+            "{}-{}",
+            folder_name.nth(0).unwrap(),
+            folder_name.nth(0).unwrap()
+        );
 
-                match file {
-                    Ok(file) => {
-                        let res = client
-                            .put(format!(
-                                "https://photos-cdn.phazed.xyz/api/v1/photos?token={}",
-                                &token
-                            ))
-                            .header("Content-Type", "image/png")
-                            .header("filename", photo)
-                            .body(file)
-                            .timeout(Duration::from_secs(120))
-                            .send()
-                            .unwrap()
-                            .text()
-                            .unwrap();
+        let full_path = format!("{}\\{}\\{}", path.to_str().unwrap(), folder_name, photo);
+        let file = fs::File::open(full_path);
 
-                        let res: Result<Value, Error> = serde_json::from_str(&res);
+        match file {
+            Ok(file) => {
+                let res = client
+                  .put(format!(
+                    "https://photos-cdn.phazed.xyz/api/v1/photos?token={}",
+                    &token
+                  ))
+                  .header("Content-Type", "image/png")
+                  .header("filename", photo)
+                  .body(file)
+                  .timeout(Duration::from_secs(120))
+                  .send()
+                  .unwrap()
+                  .text()
+                  .unwrap();
 
-                        match res {
-                            Ok(res) => {
-                                if !res["ok"].as_bool().unwrap() {
-                                    println!(
-                                        "Failed to upload: {}",
-                                        res["error"].as_str().unwrap()
-                                    );
-                                    window
-                                        .emit("sync-failed", res["error"].as_str().unwrap())
-                                        .unwrap();
-                                    break;
-                                }
-                            }
-                            Err(err) => {
-                                dbg!(err);
-                            }
-                        }
+                let res: Result<Value, Error> = serde_json::from_str(&res);
+
+                match res {
+                  Ok(res) => {
+                    if !res["ok"].as_bool().unwrap() {
+                      println!(
+                        "Failed to upload: {}",
+                        res["error"].as_str().unwrap()
+                      );
+
+                      window
+                        .emit("sync-failed", res["error"].as_str().unwrap())
+                        .unwrap();
+
+                      break;
                     }
-                    Err(_) => {}
+                  }
+                  Err(err) => {
+                    dbg!(err);
+                  }
                 }
-
-                photos_left -= 1;
-                window
-                    .emit(
-                        "photos-upload-meta",
-                        PhotoUploadMeta {
-                            photos_uploading: photos_left,
-                            photos_total: photos_len,
-                        },
-                    )
-                    .unwrap();
             }
-            None => {
-                break;
-            }
+            Err(_) => {}
         }
+
+        photos_left -= 1;
+        window
+          .emit(
+            "photos-upload-meta",
+            PhotoUploadMeta {
+              photos_uploading: photos_left,
+              photos_total: photos_len,
+            },
+          )
+          .unwrap();
+      }
+      None => {
+        break;
+      }
     }
+  }
 
-    println!("Finished Uploading.");
-    let mut photos_to_download: Vec<String> = Vec::new();
+  println!("Finished Uploading.");
+  let mut photos_to_download: Vec<String> = Vec::new();
 
-    for photo in uploaded_photos {
-        let mut found_photo = false;
-        let photo = photo.as_str().unwrap().to_string();
-
-        for uploaded_photo in &photos {
-            if &photo == uploaded_photo {
-                found_photo = true;
-                break;
-            }
-        }
+  for photo in uploaded_photos {
+    let mut found_photo = false;
+    let photo = photo.as_str().unwrap().to_string();
 
-        if !found_photo {
-            photos_to_download.push(photo);
-        }
+    for uploaded_photo in &photos {
+      if &photo == uploaded_photo {
+        found_photo = true;
+        break;
+      }
     }
 
-    photos_to_download.reverse();
+    if !found_photo {
+      photos_to_download.push(photo);
+    }
+  }
 
-    let photos_len = photos_to_download.len();
-    let mut photos_left = photos_to_download.len();
-
-    loop {
-        match photos_to_download.pop() {
-            Some(photo) => {
-                let folder_name = photo.clone().replace("VRChat_", "");
-                let mut folder_name = folder_name.split("-");
-                let folder_name = format!(
-                    "{}-{}",
-                    folder_name.nth(0).unwrap(),
-                    folder_name.nth(0).unwrap()
-                );
+  photos_to_download.reverse();
 
-                let full_path = format!("{}\\{}\\{}", path.to_str().unwrap(), folder_name, photo);
+  let photos_len = photos_to_download.len();
+  let mut photos_left = photos_to_download.len();
 
-                let res = client
-                    .get(format!(
-                        "https://photos-cdn.phazed.xyz/api/v1/photos?token={}&photo={}",
-                        &token, &photo
-                    ))
-                    .timeout(Duration::from_secs(120))
-                    .send()
-                    .unwrap()
-                    .bytes();
+  loop {
+    match photos_to_download.pop() {
+      Some(photo) => {
+        let folder_name = photo.clone().replace("VRChat_", "");
+        let mut folder_name = folder_name.split("-");
+        let folder_name = format!(
+          "{}-{}",
+          folder_name.nth(0).unwrap(),
+          folder_name.nth(0).unwrap()
+        );
 
-                match res {
-                    Ok(res) => {
-                        let folder_path = format!("{}\\{}", path.to_str().unwrap(), folder_name);
-                        match fs::metadata(&folder_path) {
-                            Ok(_) => {}
-                            Err(_) => {
-                                fs::create_dir(folder_path).unwrap();
-                            }
-                        }
+        let full_path = format!("{}\\{}\\{}", path.to_str().unwrap(), folder_name, photo);
 
-                        let mut file = fs::File::create(full_path).unwrap();
-                        file.write_all(&res).unwrap();
-                    }
-                    Err(err) => {
-                        dbg!(err);
-                    }
-                }
+        let res = client
+          .get(format!(
+            "https://photos-cdn.phazed.xyz/api/v1/photos?token={}&photo={}",
+            &token, &photo
+          ))
+          .timeout(Duration::from_secs(120))
+          .send()
+          .unwrap()
+          .bytes();
 
-                photos_left -= 1;
-                window
-                    .emit(
-                        "photos-download-meta",
-                        PhotoUploadMeta {
-                            photos_uploading: photos_left,
-                            photos_total: photos_len,
-                        },
-                    )
-                    .unwrap();
+        match res {
+          Ok(res) => {
+            let folder_path = format!("{}\\{}", path.to_str().unwrap(), folder_name);
+            match fs::metadata(&folder_path) {
+              Ok(_) => {}
+              Err(_) => {
+                fs::create_dir(folder_path).unwrap();
+              }
             }
-            None => {
-                break;
-            }
+
+            let mut file = fs::File::create(full_path).unwrap();
+            file.write_all(&res).unwrap();
+          }
+          Err(err) => {
+            dbg!(err);
+          }
         }
+
+        photos_left -= 1;
+        window
+          .emit(
+            "photos-download-meta",
+            PhotoUploadMeta {
+              photos_uploading: photos_left,
+              photos_total: photos_len,
+            },
+          )
+          .unwrap();
+      }
+      None => {
+          break;
+      }
     }
+  }
 
-    println!("Finished Downloading.");
+  println!("Finished Downloading.");
 
-    fs::remove_file(&sync_lock_path).unwrap();
-    window.emit("sync-finished", "h").unwrap();
+  fs::remove_file(&sync_lock_path).unwrap();
+  window.emit("sync-finished", "h").unwrap();
 }

src-tauri/src/pngmeta.rs

···
 
 #[derive(Clone)]
 pub struct PNGImage {
-    width: u32,
-    height: u32,
-    bit_depth: u8,
-    colour_type: u8,
-    compression_method: u8,
-    filter_method: u8,
-    interlace_method: u8,
-    metadata: String,
-    path: String,
+  width: u32,
+  height: u32,
+  bit_depth: u8,
+  colour_type: u8,
+  compression_method: u8,
+  filter_method: u8,
+  interlace_method: u8,
+  metadata: String,
+  path: String,
 }
 
 impl PNGImage {
-    pub fn new(buff: Vec<u8>, path: String) -> PNGImage {
-        let mut img = PNGImage {
-            width: 0,
-            height: 0,
-            bit_depth: 0,
-            colour_type: 0,
-            compression_method: 0,
-            filter_method: 0,
-            interlace_method: 0,
-            metadata: "".to_string(),
-            path: path,
-        };
+  pub fn new(buff: Vec<u8>, path: String) -> PNGImage {
+    let mut img = PNGImage {
+      width: 0,
+      height: 0,
+      bit_depth: 0,
+      colour_type: 0,
+      compression_method: 0,
+      filter_method: 0,
+      interlace_method: 0,
+      metadata: "".to_string(),
+      path: path,
+    };
+
+    if buff[0] != 0x89
+      || buff[1] != 0x50
+      || buff[2] != 0x4E
+      || buff[3] != 0x47
+      || buff[4] != 0x0D
+      || buff[5] != 0x0A
+      || buff[6] != 0x1A
+      || buff[7] != 0x0A
+    {
+      panic!("Image is not a PNG file");
+    }
 
-        if buff[0] != 0x89
-            || buff[1] != 0x50
-            || buff[2] != 0x4E
-            || buff[3] != 0x47
-            || buff[4] != 0x0D
-            || buff[5] != 0x0A
-            || buff[6] != 0x1A
-            || buff[7] != 0x0A
-        {
-            panic!("Image is not a PNG file");
-        }
+    img.read_png_chunk(8, buff);
+    img
+  }
 
-        img.read_png_chunk(8, buff);
+  fn read_png_chunk(&mut self, start_byte: usize, buff: Vec<u8>) {
+    let data_buff = buff[start_byte..].to_vec();
 
-        img
-    }
+    let length = u32::from_le_bytes([data_buff[3], data_buff[2], data_buff[1], data_buff[0]]);
+    let chunk_type = str::from_utf8(&data_buff[4..8]).unwrap();
 
-    fn read_png_chunk(&mut self, start_byte: usize, buff: Vec<u8>) {
-        let data_buff = buff[start_byte..].to_vec();
+    match chunk_type {
+      "IHDR" => {
+        self.width =
+          u32::from_le_bytes([data_buff[11], data_buff[10], data_buff[9], data_buff[8]]);
 
-        let length = u32::from_le_bytes([data_buff[3], data_buff[2], data_buff[1], data_buff[0]]);
-        let chunk_type = str::from_utf8(&data_buff[4..8]).unwrap();
+        self.height = u32::from_le_bytes([
+          data_buff[15],
+          data_buff[14],
+          data_buff[13],
+          data_buff[12],
+        ]);
 
-        match chunk_type {
-            "IHDR" => {
-                self.width =
-                    u32::from_le_bytes([data_buff[11], data_buff[10], data_buff[9], data_buff[8]]);
-                self.height = u32::from_le_bytes([
-                    data_buff[15],
-                    data_buff[14],
-                    data_buff[13],
-                    data_buff[12],
-                ]);
-                self.bit_depth = data_buff[16];
-                self.colour_type = data_buff[17];
-                self.compression_method = data_buff[18];
-                self.filter_method = data_buff[19];
-                self.interlace_method = data_buff[20];
+        self.bit_depth = data_buff[16];
+        self.colour_type = data_buff[17];
+        self.compression_method = data_buff[18];
+        self.filter_method = data_buff[19];
+        self.interlace_method = data_buff[20];
 
-                self.read_png_chunk((length + 12) as usize, data_buff);
-            }
-            "iTXt" => {
-                let end_byte = (8 + length) as usize;
-                let d = str::from_utf8(&data_buff[8..end_byte]).unwrap();
+        self.read_png_chunk((length + 12) as usize, data_buff);
+      }
+      "iTXt" => {
+        let end_byte = (8 + length) as usize;
+        let d = str::from_utf8(&data_buff[8..end_byte]).unwrap();
 
-                self.metadata = d.to_string();
+        self.metadata = d.to_string();
 
-                self.read_png_chunk((length + 12) as usize, data_buff);
-            }
-            "IEND" => {}
-            "IDAT" => {}
-            _ => {
-                self.read_png_chunk((length + 12) as usize, data_buff);
-            }
-        }
+        self.read_png_chunk((length + 12) as usize, data_buff);
+      }
+      "IEND" => {}
+      "IDAT" => {}
+      _ => {
+        self.read_png_chunk((length + 12) as usize, data_buff);
+      }
     }
+  }
 }
 
 impl Serialize for PNGImage {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        let mut s = serializer.serialize_struct("PNGImage", 7)?;
-        s.serialize_field("width", &self.width)?;
-        s.serialize_field("height", &self.height)?;
-        s.serialize_field("bit_depth", &self.bit_depth)?;
-        s.serialize_field("colour_type", &self.colour_type)?;
-        s.serialize_field("compression_method", &self.compression_method)?;
-        s.serialize_field("filter_method", &self.filter_method)?;
-        s.serialize_field("interlace_method", &self.interlace_method)?;
-        s.serialize_field("metadata", &self.metadata)?;
-        s.serialize_field("path", &self.path)?;
-        s.end()
-    }
+  fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+  where
+    S: Serializer,
+  {
+    let mut s = serializer.serialize_struct("PNGImage", 7)?;
+    s.serialize_field("width", &self.width)?;
+    s.serialize_field("height", &self.height)?;
+    s.serialize_field("bit_depth", &self.bit_depth)?;
+    s.serialize_field("colour_type", &self.colour_type)?;
+    s.serialize_field("compression_method", &self.compression_method)?;
+    s.serialize_field("filter_method", &self.filter_method)?;
+    s.serialize_field("interlace_method", &self.interlace_method)?;
+    s.serialize_field("metadata", &self.metadata)?;
+    s.serialize_field("path", &self.path)?;
+    s.end()
+  }
 }

src-tauri/src/worldscraper.rs

···
 
 #[derive(Clone)]
 pub struct World {
-    id: String,
-    name: String,
-    author: String,
-    author_id: String,
-    desc: String,
-    img: String,
-    max_users: u64,
-    visits: u64,
-    favourites: u64,
-    tags: String,
-    from: String,
-    from_site: String,
-    found: bool,
+  id: String,
+  name: String,
+  author: String,
+  author_id: String,
+  desc: String,
+  img: String,
+  max_users: u64,
+  visits: u64,
+  favourites: u64,
+  tags: String,
+  from: String,
+  from_site: String,
+  found: bool,
 }
 
 impl World {
-    pub fn new(world_id: String) -> World {
-        println!("Fetching world data for {}", &world_id);
+  pub fn new(world_id: String) -> World {
+    println!("Fetching world data for {}", &world_id);
 
-        let mut world = World {
-            id: world_id.clone(),
-            name: "".into(),
-            author: "".into(),
-            author_id: "".into(),
-            desc: "".into(),
-            img: "".into(),
-            max_users: 0,
-            visits: 0,
-            favourites: 0,
-            tags: "".into(),
-            from: "https://vrclist.com/worlds/".into(),
-            from_site: "vrclist.com".into(),
-            found: false,
-        };
+    let mut world = World {
+      id: world_id.clone(),
+      name: "".into(),
+      author: "".into(),
+      author_id: "".into(),
+      desc: "".into(),
+      img: "".into(),
+      max_users: 0,
+      visits: 0,
+      favourites: 0,
+      tags: "".into(),
+      from: "https://vrclist.com/worlds/".into(),
+      from_site: "vrclist.com".into(),
+      found: false,
+    };
 
-        let client = reqwest::blocking::Client::new();
+    let client = reqwest::blocking::Client::new();
 
-        let world_id_str = world_id.to_owned();
-        let fixed_id_req = client
-            .post("https://api.vrclist.com/worlds/id-convert")
-            .header("Content-Type", "application/json")
-            .header("User-Agent", "VRChat-Photo-Manager-Rust/0.0.1")
-            .body(json!({ "world_id": world_id_str }).to_string())
-            .send()
-            .unwrap()
-            .text()
-            .unwrap();
+    let world_id_str = world_id.to_owned();
+    let fixed_id_req = client
+      .post("https://api.vrclist.com/worlds/id-convert")
+      .header("Content-Type", "application/json")
+      .header("User-Agent", "VRChat-Photo-Manager-Rust/0.0.1")
+      .body(json!({ "world_id": world_id_str }).to_string())
+      .send()
+      .unwrap()
+      .text()
+      .unwrap();
 
-        if &fixed_id_req == "" {
-            return world;
-        }
+    if &fixed_id_req == "" {
+      println!("World {} not found", world_id);
+      return world;
+    }
 
-        world.found = true;
+    world.found = true;
 
-        let fixed_id: serde_json::Value = serde_json::from_str(&fixed_id_req).unwrap();
-        world.from = format!("https://vrclist.com/worlds/{}", fixed_id["id"].to_string());
+    let fixed_id: serde_json::Value = serde_json::from_str(&fixed_id_req).unwrap();
+    world.from = format!("https://vrclist.com/worlds/{}", fixed_id["id"].to_string());
 
-        let world_data = client
-            .post("https://api.vrclist.com/worlds/single")
-            .header("Content-Type", "application/json")
-            .header("User-Agent", "VRChat-Photo-Manager-Rust/0.0.1")
-            .body(json!({ "id": fixed_id["id"].to_string() }).to_string())
-            .send()
-            .unwrap()
-            .text()
-            .unwrap();
-
-        let world_data: serde_json::Value = serde_json::from_str(&world_data).unwrap();
+    let world_data = client
+      .post("https://api.vrclist.com/worlds/single")
+      .header("Content-Type", "application/json")
+      .header("User-Agent", "VRChat-Photo-Manager-Rust/0.0.1")
+      .body(json!({ "id": fixed_id["id"].to_string() }).to_string())
+      .send()
+      .unwrap()
+      .text()
+      .unwrap();
 
-        world.name = world_data["name"].to_string();
-        world.author = world_data["authorName"].to_string();
-        world.author_id = world_data["authorId"].to_string();
-        world.desc = world_data["description"].to_string();
-        world.img = world_data["imageUrl"].to_string();
-        world.tags = world_data["tags"].to_string();
+    let world_data: serde_json::Value = serde_json::from_str(&world_data).unwrap();
 
-        match world_data["vrchat_visits"].as_u64() {
-            Some(visits) => world.visits = visits,
-            None => {}
-        }
+    world.name = world_data["name"].to_string();
+    world.author = world_data["authorName"].to_string();
+    world.author_id = world_data["authorId"].to_string();
+    world.desc = world_data["description"].to_string();
+    world.img = world_data["imageUrl"].to_string();
+    world.tags = world_data["tags"].to_string();
 
-        match world_data["capacity"].as_u64() {
-            Some(cap) => {
-                world.max_users = cap;
-            }
-            None => {}
-        }
+    match world_data["vrchat_visits"].as_u64() {
+      Some(visits) => world.visits = visits,
+      None => {}
+    }
 
-        println!("Fetched world data for {}", &world_id);
-        world
+    match world_data["capacity"].as_u64() {
+      Some(cap) => {
+        world.max_users = cap;
+      }
+      None => {}
     }
+
+    println!("Fetched world data for {}", &world_id);
+    world
+  }
 }
 
 impl Serialize for World {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        let mut s = serializer.serialize_struct("World", 7)?;
-        s.serialize_field("id", &self.id)?;
-        s.serialize_field("name", &self.name)?;
-        s.serialize_field("author", &self.author)?;
-        s.serialize_field("authorId", &self.author_id)?;
-        s.serialize_field("desc", &self.desc)?;
-        s.serialize_field("img", &self.img)?;
-        s.serialize_field("maxUsers", &self.max_users)?;
-        s.serialize_field("visits", &self.visits)?;
-        s.serialize_field("favourites", &self.favourites)?;
-        s.serialize_field("tags", &self.tags)?;
-        s.serialize_field("from", &self.from)?;
-        s.serialize_field("fromSite", &self.from_site)?;
-        s.serialize_field("found", &self.found)?;
+  fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+  where
+    S: Serializer,
+  {
+    let mut s = serializer.serialize_struct("World", 7)?;
+    s.serialize_field("id", &self.id)?;
+    s.serialize_field("name", &self.name)?;
+    s.serialize_field("author", &self.author)?;
+    s.serialize_field("authorId", &self.author_id)?;
+    s.serialize_field("desc", &self.desc)?;
+    s.serialize_field("img", &self.img)?;
+    s.serialize_field("maxUsers", &self.max_users)?;
+    s.serialize_field("visits", &self.visits)?;
+    s.serialize_field("favourites", &self.favourites)?;
+    s.serialize_field("tags", &self.tags)?;
+    s.serialize_field("from", &self.from)?;
+    s.serialize_field("fromSite", &self.from_site)?;
+    s.serialize_field("found", &self.found)?;
 
-        s.end()
-    }
+    s.end()
+  }
 }

src-tauri/tauri.conf.json

···
     "security": {
       "csp": "https://photos.phazed.xyz; connect-src ipc: http://ipc.localhost"
     },
-    "trayIcon": {
-      "iconPath": "./icons/icon.ico",
-      "title": "VRChat Photo Manager"
-    },
     "windows": [
       {
         "fullscreen": false,
         "resizable": true,
         "title": "VRChat Photo Manager",
-        "width": 1200,
+        "width": 1220,
         "height": 580,
         "minWidth": 600,
         "minHeight": 400,

src/Components/NavBar.tsx

···
           fetch('https://photos.phazed.xyz/api/v1/account?token='+localStorage.getItem('token')!)
             .then(data => data.json())
             .then(data => {
-              if(!data.data.ok){
+              if(!data.ok){
                 console.error(data);
                 return;
               }
 
-              console.log(data.data);
-              props.setStorageInfo({ storage: data.data.user.storage, used: data.data.user.used, sync: data.data.user.settings.enableSync });
+              console.log(data);
+              props.setStorageInfo({ storage: data.user.storage, used: data.user.used, sync: data.user.settings.enableSync });
             })
             .catch(e => {
               console.error(e);

src/Components/PhotoList.tsx

···
 import anime from "animejs";
 
 const PHOTO_HEIGHT = 200;
-const MAX_IMAGE_LOAD = 3;
+const MAX_IMAGE_LOAD = 10;
 
 let months = [ "January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December" ];
 
···
   let imagesLoading = 0;
 
   let photoTreeLoadingContainer: HTMLElement;
-  let photoMetaDataLoadingContainer: HTMLElement;
-  let photoMetaDataLoadingBar: HTMLElement;
 
   let scrollToTop: HTMLElement;
   let scrollToTopActive = false;
···
 
   let quitRender: boolean = false;
   let photoPath: string;
-
-  let finishedFirstLoad = false;
 
   createEffect(() => {
     if(props.requestPhotoReload()){
···
     constructor( path: string ){
       this.path = path;
       this.dateString = this.path.split('_')[1];
-
-      invoke('load_photo_meta', { photo: this.path });
     }
 
     loadImage(){
-      if(this.loading || this.loaded || !this.metaLoaded || imagesLoading >= MAX_IMAGE_LOAD)return;
+      if(this.loading || this.loaded || imagesLoading >= MAX_IMAGE_LOAD)return;
+
+      invoke('load_photo_meta', { photo: this.path });
+      if(!this.metaLoaded)return;
+
       this.loading = true;
 
       imagesLoading++;
···
       this.imageEl = document.createElement('img');
       this.imageEl.crossOrigin = 'anonymous';
 
-      this.imageEl.src = "http://photo.localhost/" + photoPath + this.path;
+      this.imageEl.src = "http://photo.localhost/" + photoPath + this.path + "?downscale";
 
       this.imageEl.onload = () => {
         this.image!.width = this.scaledWidth!;
···
         currentRowIndex += 1.4;
       }
 
-      if(currentRowWidth + p.scaledWidth! + 10 < photoContainer.width - 20){
+      if(currentRowWidth + p.scaledWidth! + 10 < photoContainer.width - 100){
         currentRowWidth += p.scaledWidth! + 10;
         currentRow.push(p);
       } else{
···
     photo.metadata = data.metadata.split('\u0000').filter(x => x !== '')[1];
     amountLoaded++;
 
-    photoMetaDataLoadingBar.style.width = (amountLoaded / photos.length) * 100 + '%';
     photo.metaLoaded = true;
-
-    if(amountLoaded / photos.length === 1 && !finishedFirstLoad){
-      finishedFirstLoad = true;
-      render();
-
-      anime({
-        targets: photoMetaDataLoadingContainer,
-        height: 0,
-        easing: 'easeInOutQuad',
-        duration: 500,
-        opacity: 0,
-        complete: () => {
-          photoMetaDataLoadingContainer.style.display = 'none';
-        }
-      })
-
-      anime({
-        targets: '.reload-photos',
-        opacity: 1,
-        duration: 150,
-        easing: 'easeInOutQuad'
-      })
-    }
   })
 
   listen('photo_create', ( event: any ) => {
···
     photoTreeLoadingContainer.style.height = '100%';
     photoTreeLoadingContainer.style.display = 'flex';
 
-    photoMetaDataLoadingContainer.style.opacity = '1';
-    photoMetaDataLoadingContainer.style.height = '100%';
-    photoMetaDataLoadingContainer.style.display = 'flex';
-
-    photoMetaDataLoadingBar.style.width = '0%';
-
     quitRender = true;
-    finishedFirstLoad = false;
     amountLoaded = 0;
     scroll = 0;
     photos = [];
···
         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,
···
           photoTreeLoadingContainer.style.display = 'none';
         }
       })
+
+      anime({
+        targets: '.reload-photos',
+        opacity: 1,
+        duration: 150,
+        easing: 'easeInOutQuad'
+      })
+
+      render();
     })
   }
 
···
   return ( 
     <div class="photo-list">
       <div class="photo-tree-loading" ref={( el ) => photoTreeLoadingContainer = el}>Scanning Photo Tree...</div>
-      <div class="photo-tree-loading" ref={( el ) => photoMetaDataLoadingContainer = el}>
-        <div>
-          Loading MetaData...
-          <div class="loading-bar"><div class="loading-bar-inner" ref={( el ) => photoMetaDataLoadingBar = el}></div></div>
-        </div>
-      </div>
 
       <div class="scroll-to-top" ref={( el ) => scrollToTop = el} onClick={() => targetScroll = 0}>
         <div class="icon">
           <img draggable="false" src="/icon/angle-up-solid.svg"></img>
         </div>
       </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)}>
+      <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...", () => window.location.reload())}>
         <div class="icon" style={{ width: '17px' }}>
           <img draggable="false" src="/icon/arrows-rotate-solid.svg"></img>
+        </div>
+      </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 class="icon" style={{ width: '20px', height: '5px', padding: '20px' }}>
+          <img draggable="false" src="/icon/clock-regular.svg"></img>
         </div>
       </div>
 

src/Components/PhotoViewer.tsx

···
 
 let worldCache: WorldCache[] = JSON.parse(localStorage.getItem('worldCache') || "[]");
 
-// TODO: Context Menu, (Open file in explorer, Copy Image)
 let PhotoViewer = ( props: PhotoViewerProps ) => {
   let viewer: HTMLElement;
-  let imageViewer: HTMLElement;
+  let imageViewer: HTMLImageElement;
   let isOpen = false;
   let trayOpen = false;
 
···
   let worldInfoContainer: HTMLElement;
   let photoPath: string;
 
+  let viewerContextMenu: HTMLElement;
+  let viewerContextMenuButtons: HTMLElement[] = [];
+
   let openTray = () => {
     if(trayOpen)return;
     trayOpen = true;
 
+    window.CloseAllPopups.forEach(p => p());
     anime({ targets: photoTray, bottom: '0px', duration: 500 });
 
     anime({
···
   let closeTray = () => {
     if(!trayOpen)return;
 
+    window.CloseAllPopups.forEach(p => p());
     anime({ targets: photoTray, bottom: '-150px', duration: 500 });
 
     anime({
···
     anime.set(photoControls, { translateX: '-50%' });
     anime.set(photoTrayCloseBtn, { translateX: '-50%', opacity: 0, scale: '0.75', bottom: '10px' });
 
+    let contextMenuOpen = false;
+    window.CloseAllPopups.push(() => {
+      contextMenuOpen = false;
+      anime.set(viewerContextMenu, { opacity: 1, rotate: '0deg' });
+
+      anime({
+        targets: viewerContextMenu,
+        opacity: 0,
+        easing: 'easeInOutQuad',
+        rotate: '30deg',
+        duration: 100,
+        complete: () => {
+          viewerContextMenu.style.display = 'none';
+        }
+      })
+    });
+
+    viewerContextMenuButtons[0].onclick = async () => {
+      window.CloseAllPopups.forEach(p => p());
+      // Context Menu -> Open file location
+
+      let path = await invoke('get_user_photos_path') + '\\' + props.currentPhotoView().path;
+      invoke('open_folder', { url: path });
+    }
+
+    viewerContextMenuButtons[1].onclick = () => {
+      window.CloseAllPopups.forEach(p => p());
+      // Context Menu -> Copy image
+
+      let canvas = document.createElement('canvas');
+      let ctx = canvas.getContext('2d')!;
+
+      canvas.width = props.currentPhotoView().width;
+      canvas.height = props.currentPhotoView().height;
+
+      ctx.drawImage(imageViewer, 0, 0);
+
+      canvas.toBlob(( blob ) => {
+        navigator.clipboard.write([
+          new ClipboardItem({
+            'image/png': blob!
+          })
+        ]);
+  
+        canvas.remove();
+
+        anime.set('.copy-notif', { translateX: '-50%', translateY: '-100px' });
+        anime({
+          targets: '.copy-notif',
+          opacity: 1,
+          translateY: '0px'
+        });
+
+        setTimeout(() => {
+          anime({
+            targets: '.copy-notif',
+            opacity: 0,
+            translateY: '-100px'
+          });
+        }, 2000);
+      });
+    }
+
+    imageViewer.oncontextmenu = ( e ) => {
+      if(contextMenuOpen){
+        contextMenuOpen = false;
+
+        anime.set(viewerContextMenu, { opacity: 1, rotate: '0deg' });
+
+        anime({
+          targets: viewerContextMenu,
+          opacity: 0,
+          rotate: '30deg',
+          easing: 'easeInOutQuad',
+          duration: 100,
+          complete: () => {
+            viewerContextMenu.style.display = 'none';
+          }
+        })
+      } else{
+        contextMenuOpen = true;
+
+        viewerContextMenu.style.top = e.clientY + 'px';
+        viewerContextMenu.style.left = e.clientX + 'px';
+        viewerContextMenu.style.display = 'block';
+
+        anime.set(viewerContextMenu, { opacity: 0, rotate: '-30deg' });
+  
+        anime({
+          targets: viewerContextMenu,
+          opacity: 1,
+          rotate: '0deg',
+          easing: 'easeInOutQuad',
+          duration: 100
+        })
+      }
+    }
+
     createEffect(() => {
       let photo = props.currentPhotoView();
 
···
           if(!photoPath)
             photoPath = await invoke('get_user_photos_path') + '/';
 
-          imageViewer.style.background = 'url(\'http://photo.localhost/' + (photoPath + props.currentPhotoView().path).split('\\').join('/') +'\')';
+          imageViewer.src = 'http://photo.localhost/' + (photoPath + props.currentPhotoView().path).split('\\').join('/') + "?full";
+          imageViewer.crossOrigin = 'anonymous';
         })();
 
         anime({
···
             </div> as Node
           );
 
-          if(!worldData)
+
+          if(!worldData){
+            console.log('Fetching new world data');
+
             invoke('find_world_by_id', { worldId: meta.world.id });
-          else if(worldData.expiresOn < Date.now()){
+          } else if(worldData.expiresOn < Date.now()){
+            console.log('Fetching new world data since cache has expired');
+
             worldCache = worldCache.filter(x => x !== worldData)
             invoke('find_world_by_id', { worldId: meta.world.id });
           } else
···
           targets: '.navbar',
           top: '0px'
         })
-  
+
         window.CloseAllPopups.forEach(p => p());
 
         anime({ targets: '.prev-button', top: '75%', easing: 'easeInOutQuad', duration: 100 });
···
 
   return (
     <div class="photo-viewer" ref={( el ) => viewer = el}>
+      <div class="photo-context-menu" ref={( el ) => viewerContextMenu = el}>
+        <div ref={( el ) => viewerContextMenuButtons.push(el)}>Open file location</div>
+        <div ref={( el ) => viewerContextMenuButtons.push(el)}>Copy image</div>
+      </div>
+
       <div class="viewer-close viewer-button" onClick={() => props.setCurrentPhotoView(null)}>
         <div class="icon" style={{ width: '10px', margin: '0' }}>
           <img draggable="false" src="/icon/x-solid.svg"></img>
         </div>
       </div>
-      <div class="image-container" ref={( el ) => imageViewer = el}></div>
+      <img class="image-container" ref={( el ) => imageViewer = el} />
 
-      <div class="prev-button" onClick={() => props.setPhotoNavChoice('prev')}>
+      <div class="prev-button" onClick={() => {
+        window.CloseAllPopups.forEach(p => p());
+        props.setPhotoNavChoice('prev');
+      }}>
         <div class="icon" style={{ width: '15px', margin: '0' }}>
           <img draggable="false" src="/icon/arrow-left-solid.svg"></img>
         </div>
       </div>
 
-      <div class="next-button" onClick={() => props.setPhotoNavChoice('next')}>
+      <div class="next-button" onClick={() => {
+        window.CloseAllPopups.forEach(p => p());
+        props.setPhotoNavChoice('next');
+      }}>
         <div class="icon" style={{ width: '15px', margin: '0' }}>
           <img draggable="false" src="/icon/arrow-right-solid.svg"></img>
         </div>
···
             canvas.width = props.currentPhotoView().width;
             canvas.height = props.currentPhotoView().height;
 
-            ctx.drawImage(props.currentPhotoView().imageEl, 0, 0);
+            ctx.drawImage(imageViewer, 0, 0);
 
             canvas.toBlob(( blob ) => {
               navigator.clipboard.write([

src/Components/SettingsMenu.tsx

···
           return;
         }
 
-        console.log(data.data);
+        console.log(data);
         props.setLoggedIn({ loggedIn: true, username: data.user.username, avatar: data.user.avatar, id: data.user._id, serverVersion: data.user.serverVersion });
         props.setStorageInfo({ storage: data.user.storage, used: data.user.used, sync: data.user.settings.enableSync });
       })

src/index.tsx

···
 
 window.CloseAllPopups = [];
 
+window.oncontextmenu = ( e ) => e.preventDefault(); 
+
 import "./styles.css";
 import App from "./Components/App";
 

src/styles.css

···
   overflow: hidden;
 }
 
+.filter-options{
+  position: fixed;
+  top: 55px;
+  left: 5px;
+  width: 40px;
+  height: 50px;
+}
+
 .photo-tree-loading{
   width: 100%;
   height: 100%;
···
   backdrop-filter: blur(75px);
   opacity: 0;
   display: none;
+}
+
+.photo-context-menu{
+  position: fixed;
+  top: 0;
+  left: 0;
+  padding: 10px;
+  border-radius: 5px;
+  backdrop-filter: blur(5px);
+  background: #555a;
+  color: #aaa;
+  box-shadow: #0005 0 0 10px;
+  opacity: 0;
+}
+
+.photo-context-menu > div{
+  padding: 2px 10px;
+  width: calc(100% - 10px);
+  text-align: center;
+  transition: 0.1s;
+}
+
+.photo-context-menu > div:hover{
+  color: #fff;
+  cursor: pointer;
+  user-select: none;
 }
 
 .image-container{