diff --git a/src/steam/utils.rs b/src/steam/utils.rs index e81c804..e2e1ddd 100644 --- a/src/steam/utils.rs +++ b/src/steam/utils.rs @@ -43,7 +43,7 @@ pub struct ShortcutInfo { pub shortcuts: Vec, } -#[derive(Default, PartialEq, Clone)] +#[derive(Default, PartialEq, Clone, Debug)] pub struct SteamUsersInfo { pub steam_user_data_folder: String, pub shortcut_path: Option, diff --git a/src/steamgriddb/cached_search.rs b/src/steamgriddb/cached_search.rs index 6124dfa..08bbb88 100644 --- a/src/steamgriddb/cached_search.rs +++ b/src/steamgriddb/cached_search.rs @@ -20,10 +20,11 @@ impl<'a> CachedSearch<'a> { save_search_map(&self.search_map); } - pub fn set_cache(&mut self, app_id: u32, name:S, new_grid_id:usize) + pub fn set_cache(&mut self, app_id: u32, name: S, new_grid_id: usize) where - S: Into{ - self.search_map.insert(app_id,(name.into(),new_grid_id)); + S: Into, + { + self.search_map.insert(app_id, (name.into(), new_grid_id)); self.save(); } diff --git a/src/steamgriddb/downloader.rs b/src/steamgriddb/downloader.rs index 5697113..3d08658 100644 --- a/src/steamgriddb/downloader.rs +++ b/src/steamgriddb/downloader.rs @@ -248,9 +248,12 @@ async fn get_images_for_ids( image_search_result.map_err(|e| format!("Image search failed {:?}", e)) } -const BIG_PICTURE_DIMS : [GridDimentions;2] = [GridDimentions::D920x430, GridDimentions::D460x215]; +const BIG_PICTURE_DIMS: [GridDimentions; 2] = [GridDimentions::D920x430, GridDimentions::D460x215]; -pub fn get_query_type(download_animated: bool, image_type: &ImageType) -> steamgriddb_api::QueryType { +pub fn get_query_type( + download_animated: bool, + image_type: &ImageType, +) -> steamgriddb_api::QueryType { let anymation_type = if download_animated { Some(&[steamgriddb_api::query_parameters::AnimtionType::Animated][..]) } else { @@ -366,6 +369,3 @@ pub struct ToDownload { pub app_name: String, pub image_type: ImageType, } - -unsafe impl Send for ToDownload { -} \ No newline at end of file diff --git a/src/steamgriddb/image_type.rs b/src/steamgriddb/image_type.rs index 95f3191..31a7fcf 100644 --- a/src/steamgriddb/image_type.rs +++ b/src/steamgriddb/image_type.rs @@ -1,4 +1,4 @@ -#[derive(Debug, Clone, Copy,PartialEq)] +#[derive(Debug, Clone, Copy, PartialEq)] pub enum ImageType { Hero, Grid, @@ -8,16 +8,21 @@ pub enum ImageType { Icon, } -pub const ALL_TYPES : [ImageType;6] = - [ImageType::Hero,ImageType::Grid,ImageType::WideGrid,ImageType::Logo,ImageType::BigPicture,ImageType::Icon]; +pub const ALL_TYPES: [ImageType; 6] = [ + ImageType::Hero, + ImageType::Grid, + ImageType::WideGrid, + ImageType::Logo, + ImageType::BigPicture, + ImageType::Icon, +]; impl ImageType { - - pub fn all() -> &'static [ImageType;6]{ + pub fn all() -> &'static [ImageType; 6] { &ALL_TYPES } - pub fn name(&self) -> &str{ + pub fn name(&self) -> &str { match self { ImageType::Hero => "Hero", ImageType::Grid => "Grid", diff --git a/src/ui/ui_image_download.rs b/src/ui/ui_image_download.rs index 66885f5..b5a9b1d 100644 --- a/src/ui/ui_image_download.rs +++ b/src/ui/ui_image_download.rs @@ -1,11 +1,14 @@ -use std::path::{Path, PathBuf}; +use std::{ + path::{Path, PathBuf}, + sync::Arc, +}; use crate::{ steam::{get_shortcuts_paths, SteamUsersInfo}, - steamgriddb::{CachedSearch, ImageType, get_query_type, ToDownload}, + steamgriddb::{get_query_type, CachedSearch, ImageType, ToDownload}, }; use dashmap::DashMap; -use egui::{ImageButton, ScrollArea}; +use egui::{ImageButton, ScrollArea, TextureHandle}; use futures::executor::block_on; use steam_shortcuts_util::shortcut::ShortcutOwned; use tokio::sync::watch::{self, Receiver}; @@ -13,7 +16,7 @@ use tokio::sync::watch::{self, Receiver}; use super::{ui_images::load_image_from_path, FetcStatus, MyEguiApp}; pub struct ImageSelectState { - pub selected_image: Option, + pub selected_shortcut: Option, pub grid_id: Option, pub hero_image: Option, @@ -25,22 +28,39 @@ pub struct ImageSelectState { pub steam_user: Option, pub steam_users: Option>, - pub image_to_replace: Option, + pub image_type_selected: Option, pub image_options: Receiver>>, - pub image_handles: DashMap, + pub image_handles: std::sync::Arc>, +} + +pub enum TextureState { + Downloading, + Downloaded, + Loaded(egui::TextureHandle), +} + +impl ImageSelectState { + pub fn has_multiple_users(&self) -> bool { + match &self.steam_users { + Some(users) => users.len() > 1, + None => false, + } + } } -#[derive(Clone)] -pub struct PossibleImage{ +#[derive(Clone, Debug)] +pub struct PossibleImage { thumbnail_path: PathBuf, - full_url: String + thumbnail_url: String, + full_url: String, + id: u32, } impl Default for ImageSelectState { fn default() -> Self { Self { - selected_image: Default::default(), + selected_shortcut: Default::default(), grid_id: Default::default(), hero_image: Default::default(), grid_image: Default::default(), @@ -49,329 +69,369 @@ impl Default for ImageSelectState { wide_image: Default::default(), steam_user: Default::default(), steam_users: Default::default(), - image_to_replace: Default::default(), + image_type_selected: Default::default(), image_options: watch::channel(FetcStatus::NeedsFetched).1, - image_handles: DashMap::new() + image_handles: Arc::new(DashMap::new()), } } } -impl MyEguiApp { - pub(crate) fn render_ui_images(&mut self, ui: &mut egui::Ui) { - self.ensure_games_loaded(); +#[derive(Debug)] +enum UserAction { + UserSelected(SteamUsersInfo), + ShortcutSelected(ShortcutOwned), + ImageTypeSelected(ImageType), + ImageSelected(PossibleImage), + GridIdChanged(usize), + BackButton, + NoAction, +} +impl MyEguiApp { + fn render_ui_image_action(&self, ui: &mut egui::Ui) -> UserAction { + let state = &self.image_selected_state; ui.heading("Images"); + if (state.selected_shortcut.is_some() || state.has_multiple_users()) + && ui.button("Back").clicked() + { + return UserAction::BackButton; + } + if state.steam_user.is_none() { + return render_user_select(state, ui); + } + if let Some(shortcut) = state.selected_shortcut.as_ref() { + ui.heading(&shortcut.app_name); + if let Some(image_type) = state.image_type_selected.as_ref() { + if let Some(action) = self.render_possible_images(ui, image_type, state) { + return action; + } + } else if let Some(action) = render_shortcut_images(ui, state) { + return action; + } + } else if let Some(action) = self.render_shortcut_select(ui) { + return action; + } + UserAction::NoAction + } - match &self.image_selected_state.steam_user { - Some(user) => { - if self.image_selected_state.selected_image.is_some(){ - if ui.button("Back").clicked() { - if self.image_selected_state.image_to_replace.is_some(){ - self.image_selected_state.image_to_replace = None; - }else{ - self.image_selected_state.selected_image = None; + fn render_shortcut_select(&self, ui: &mut egui::Ui) -> Option { + match &*self.games_to_sync.borrow() { + FetcStatus::Fetched(shortcuts) => { + for (platform_name, shortcuts) in shortcuts { + ui.heading(platform_name); + for shortcut in shortcuts { + if ui.button(&shortcut.app_name).clicked() { + return Some(UserAction::ShortcutSelected(shortcut.clone())); } - return; } } - - ScrollArea::vertical() - .stick_to_right() - .auto_shrink([false, true]) - .show(ui, |ui| { - ui.reset_style(); - let borrowed_games = &*self.games_to_sync.borrow(); - match borrowed_games { - super::FetcStatus::Fetched(games_to_sync) => { - match &self.image_selected_state.selected_image { - Some(selected_image) => { - - ui.heading(&selected_image.app_name); - let mut reset = false; - if let Some(selected_image_type) = - &self.image_selected_state.image_to_replace - { - let borrowed_images = - &*self.image_selected_state.image_options.borrow(); - match borrowed_images { - FetcStatus::Fetched(images) => { - for image in images{ - let image_key = image.thumbnail_path.as_path().to_string_lossy().to_string(); - if ! self.image_selected_state.image_handles.contains_key(&image_key){ - //TODO remove this unwrap - let image_data = load_image_from_path(&image.thumbnail_path).unwrap(); - let handle = ui.ctx().load_texture(&image_key, image_data); - self.image_selected_state.image_handles.insert(image_key.clone(),handle); - } - if let Some(texture_handle) = self.image_selected_state.image_handles.get(&image_key){ - let mut size = texture_handle.size_vec2(); - clamp_to_width(&mut size,MAX_WIDTH); - let image_button = ImageButton::new(texture_handle.value(), size); - if ui.add(image_button).clicked(){ - let to = - Path::new(&user.steam_user_data_folder) - .join("config") - .join("grid") - .join(selected_image_type.file_name(selected_image.app_id)); - let app_name = selected_image.app_name.clone(); - - let to_download = ToDownload{ - path: to, - url: image.full_url.clone(), - app_name: app_name.clone(), - image_type: selected_image_type.clone() - }; - //TODO make this actually parallel - self.rt.spawn_blocking(move ||{ - let _ = block_on(crate::steamgriddb::download_to_download(&to_download)); - }); - - let image_ref = match selected_image_type { - ImageType::Hero => { - &mut self.image_selected_state.hero_image - } - ImageType::Grid => { - &mut self.image_selected_state.grid_image - } - ImageType::WideGrid => { - &mut self.image_selected_state.wide_image - } - ImageType::Logo => { - &mut self.image_selected_state.logo_image - } - ImageType::BigPicture => { - &mut self.image_selected_state.wide_image - } - ImageType::Icon => { - &mut self.image_selected_state.icon_image - } - }; - *image_ref = Some(texture_handle.clone()); - reset = true; - } - } - } - }, - _ => { - ui.label("Finding possible images"); - }, - - } - } else { - if let Some(grid_id) = self.image_selected_state.grid_id - { - ui.horizontal(|ui| { - ui.label("Grid id:"); - let mut text_id = format!("{}", grid_id); - if ui - .text_edit_singleline(&mut text_id) - .changed() - { - if let Ok(grid_id) = - text_id.parse::() - { - if let Some(auth_key) = - &self.settings.steamgrid_db.auth_key - { - let client = - steamgriddb_api::Client::new( - auth_key, - ); - let mut search = - CachedSearch::new(&client); - search.set_cache( - selected_image.app_id, - selected_image - .app_name - .to_string(), - grid_id, - ); - } - self.image_selected_state.grid_id = - Some(grid_id); - } - }; - }); - } - - for image_type in ImageType::all() { - ui.label(image_type.name()); - - let image_ref = match image_type { - ImageType::Hero => { - &mut self.image_selected_state.hero_image - } - ImageType::Grid => { - &mut self.image_selected_state.grid_image - } - ImageType::WideGrid => { - &mut self.image_selected_state.wide_image - } - ImageType::Logo => { - &mut self.image_selected_state.logo_image - } - ImageType::BigPicture => { - &mut self.image_selected_state.wide_image - } - ImageType::Icon => { - &mut self.image_selected_state.icon_image - } - }; - if render_image(ui, image_ref) { - self.image_selected_state.image_to_replace = - Some(image_type.clone()); - let (mut tx,rx)= watch::channel(FetcStatus::Fetching); - self.image_selected_state.image_options = rx; - let settings = self.settings.clone(); - if let Some(auth_key) = settings.steamgrid_db.auth_key{ - if let Some(grid_id) = self.image_selected_state.grid_id{ - let auth_key = auth_key.clone(); - let image_type = image_type.clone(); - let app_name = selected_image.app_name.clone(); - self.rt.spawn_blocking( move|| { - //Find somewhere else to put this - std::fs::create_dir_all(".thumbnails"); - let thumbnails_folder = Path::new(".thumbnails"); - let client =steamgriddb_api::Client::new(auth_key); - let query = get_query_type(false,&image_type); - let search_res = block_on(client.get_images_for_id(grid_id, &query)); - - if let Ok(possible_images) = search_res{ - let mut result = vec![]; - for possible_image in &possible_images{ - let path = thumbnails_folder.join(format!("{}.png",possible_image.id)); - - if !&path.exists(){ - let to_download = ToDownload{ - path: path.clone(), - url: possible_image.thumb.clone(), - app_name: app_name.clone(), - image_type: image_type.clone() - }; - //TODO make this actually parallel - block_on(crate::steamgriddb::download_to_download(&to_download)); - } - result.push(PossibleImage { thumbnail_path: path, full_url: possible_image.url.clone() }); - let _ = tx.send(FetcStatus::Fetched(result.clone())); - } - } - }); - } - }; - } - } - } - if reset { - self.image_selected_state.image_to_replace = None; - self.image_selected_state.image_options = watch::channel(FetcStatus::NeedsFetched).1; - self.image_selected_state.image_handles.clear(); - } - } - None => { - for (platform_name, shortcuts) in games_to_sync { - ui.heading(platform_name); - for shortcut in shortcuts { - if ui.button(&shortcut.app_name).clicked() { - if let Some(auth_key) = - &self.settings.steamgrid_db.auth_key - { - let client = - steamgriddb_api::Client::new(auth_key); - let search = CachedSearch::new(&client); - //TODO make this multithreaded - self.image_selected_state.grid_id = self - .rt - .block_on(search.search( - shortcut.app_id, - &shortcut.app_name, - )) - .ok() - .flatten(); - } - - self.image_selected_state.selected_image = - Some(shortcut.clone()); - - let folder = - Path::new(&user.steam_user_data_folder) - .join("config") - .join("grid"); - - //TODO put this in seperate thread - self.image_selected_state.hero_image = - get_image( - ui, - shortcut, - &folder, - &ImageType::Hero, - ); - self.image_selected_state.grid_image = - get_image( - ui, - shortcut, - &folder, - &ImageType::Grid, - ); - self.image_selected_state.icon_image = - get_image( - ui, - shortcut, - &folder, - &ImageType::Icon, - ); - self.image_selected_state.logo_image = - get_image( - ui, - shortcut, - &folder, - &ImageType::Logo, - ); - self.image_selected_state.wide_image = - get_image( - ui, - shortcut, - &folder, - &ImageType::WideGrid, - ); - }; - } - } + } + _ => { + ui.ctx().request_repaint(); + ui.label("Finding installed games"); + } + } + None + } + + fn render_possible_images( + &self, + ui: &mut egui::Ui, + image_type: &ImageType, + state: &ImageSelectState, + ) -> Option { + ui.heading(image_type.name()); + + match &*state.image_options.borrow() { + FetcStatus::Fetched(images) => { + for image in images { + let image_key = image.thumbnail_path.as_path().to_string_lossy().to_string(); + + match state.image_handles.get_mut(&image_key) { + Some(mut state) => { + match state.value() { + TextureState::Downloading => { + ui.ctx().request_repaint(); + //nothing to do,just wait + ui.label(format!("Downloading id {}", image.id)); + } + TextureState::Downloaded => { + //Need to load + let image_data = + load_image_from_path(&image.thumbnail_path).unwrap(); + let handle = ui.ctx().load_texture(&image_key, image_data); + *state.value_mut() = TextureState::Loaded(handle); + ui.ctx().request_repaint(); + ui.label("Loading"); + } + TextureState::Loaded(texture_handle) => { + //need to show + let mut size = texture_handle.size_vec2(); + clamp_to_width(&mut size, MAX_WIDTH); + let image_button = ImageButton::new(texture_handle, size); + if ui.add(image_button).clicked() { + return Some(UserAction::ImageSelected(image.clone())); } } } - _ => { - ui.label("Finding installed games"); + } + None => { + //We need to start a download + let image_handles = &self.image_selected_state.image_handles; + let path = &image.thumbnail_path; + if !path.exists() { + image_handles.insert(image_key.clone(), TextureState::Downloading); + let to_download = ToDownload { + path: path.clone(), + url: image.thumbnail_url.clone(), + app_name: "Thumbnail".to_string(), + image_type: *image_type, + }; + let image_handles = image_handles.clone(); + let image_key = image_key.clone(); + self.rt.spawn_blocking(move || { + block_on(crate::steamgriddb::download_to_download( + &to_download, + )) + .unwrap(); + image_handles.insert(image_key, TextureState::Downloaded); + }); + } else { + image_handles.insert(image_key.clone(), TextureState::Downloaded); } } - }); - } - None => { - let users = self - .image_selected_state - .steam_users - .get_or_insert_with(|| { - get_shortcuts_paths(&self.settings.steam).expect("Should have steam user") - }); - if users.len() == 1{ - self.image_selected_state.steam_user = Some(users[0].clone()) - } - for user in users { - if ui.button(&user.user_id).clicked() { - self.image_selected_state.steam_user = Some(user.clone()); } } } + _ => { + ui.label("Finding possible images"); + ui.ctx().request_repaint(); + } + } + None + } + + fn ensure_steam_users_loaded(&mut self) { + self.image_selected_state + .steam_users + .get_or_insert_with(|| { + get_shortcuts_paths(&self.settings.steam).expect("Should have steam user") + }); + } + + pub(crate) fn render_ui_images(&mut self, ui: &mut egui::Ui) { + self.ensure_games_loaded(); + self.ensure_steam_users_loaded(); + + let mut action = UserAction::NoAction; + ScrollArea::vertical() + .stick_to_right() + .auto_shrink([false, true]) + .show(ui, |ui| { + ui.reset_style(); + action = self.render_ui_image_action(ui); + }); + match action { + UserAction::UserSelected(user) => { + self.handle_user_selected(user); + } + UserAction::ShortcutSelected(shortcut) => { + self.handle_shortcut_selected(shortcut, ui); + } + UserAction::ImageTypeSelected(image_type) => { + self.handle_image_type_selected(image_type); + } + UserAction::ImageSelected(image) => { + self.handle_image_selected(image); + } + UserAction::BackButton => { + let state = &mut self.image_selected_state; + handle_back_button_action(state); + } + UserAction::GridIdChanged(grid_id) => { + self.handle_grid_change(grid_id); + } + + UserAction::NoAction => {} + }; + } + + fn handle_grid_change(&mut self, grid_id: usize) { + self.image_selected_state.grid_id = Some(grid_id); + if let Some(auth_key) = &self.settings.steamgrid_db.auth_key { + let client = steamgriddb_api::Client::new(auth_key); + let mut cache = CachedSearch::new(&client); + if let Some(shortcut) = &self.image_selected_state.selected_shortcut { + cache.set_cache(shortcut.app_id, shortcut.app_name.clone(), grid_id); + cache.save(); + } + } + } + + fn handle_user_selected(&mut self, user: SteamUsersInfo) { + let state = &mut self.image_selected_state; + state.steam_user = Some(user); + } + + fn handle_image_type_selected(&mut self, image_type: ImageType) { + let state = &mut self.image_selected_state; + state.image_type_selected = Some(image_type); + let (tx, rx) = watch::channel(FetcStatus::Fetching); + self.image_selected_state.image_options = rx; + let settings = self.settings.clone(); + if let Some(auth_key) = settings.steamgrid_db.auth_key { + if let Some(grid_id) = self.image_selected_state.grid_id { + let auth_key = auth_key; + let image_type = image_type; + self.rt.spawn_blocking(move || { + //Find somewhere else to put this + let _ = std::fs::create_dir_all(".thumbnails"); + let thumbnails_folder = Path::new(".thumbnails"); + let client = steamgriddb_api::Client::new(auth_key); + let query = get_query_type(false, &image_type); + let search_res = block_on(client.get_images_for_id(grid_id, &query)); + if let Ok(possible_images) = search_res { + let mut result = vec![]; + for possible_image in &possible_images { + let path = thumbnails_folder.join(format!("{}.png", possible_image.id)); + result.push(PossibleImage { + thumbnail_path: path, + thumbnail_url: possible_image.thumb.clone(), + full_url: possible_image.url.clone(), + id: possible_image.id, + }); + let _ = tx.send(FetcStatus::Fetched(result.clone())); + } + } + }); + } + }; + } + + fn handle_image_selected(&mut self, image: PossibleImage) { + //We must have a user here + let user = self.image_selected_state.steam_user.as_ref().unwrap(); + let selected_image_type = self + .image_selected_state + .image_type_selected + .as_ref() + .unwrap(); + let selected_image = self + .image_selected_state + .selected_shortcut + .as_ref() + .unwrap(); + let to = Path::new(&user.steam_user_data_folder) + .join("config") + .join("grid") + .join(selected_image_type.file_name(selected_image.app_id)); + let app_name = selected_image.app_name.clone(); + let to_download = ToDownload { + path: to, + url: image.full_url.clone(), + app_name, + image_type: *selected_image_type, + }; + //TODO make this actually parallel + self.rt.spawn_blocking(move || { + let _ = block_on(crate::steamgriddb::download_to_download(&to_download)); + }); + let image_ref = match selected_image_type { + ImageType::Hero => &mut self.image_selected_state.hero_image, + ImageType::Grid => &mut self.image_selected_state.grid_image, + ImageType::WideGrid => &mut self.image_selected_state.wide_image, + ImageType::Logo => &mut self.image_selected_state.logo_image, + ImageType::BigPicture => &mut self.image_selected_state.wide_image, + ImageType::Icon => &mut self.image_selected_state.icon_image, + }; + let image_key = image.thumbnail_path.as_path().to_string_lossy().to_string(); + let texture_handle = self + .image_selected_state + .image_handles + .get(&image_key) + .unwrap(); + if let TextureState::Loaded(texture_handle) = texture_handle.value() { + *image_ref = Some(texture_handle.clone()); } + self.image_selected_state.image_type_selected = None; + self.image_selected_state.image_options = watch::channel(FetcStatus::NeedsFetched).1; + } + + fn handle_shortcut_selected(&mut self, shortcut: ShortcutOwned, ui: &mut egui::Ui) { + let state = &mut self.image_selected_state; + //We must have a user to make see this action; + let user = state.steam_user.as_ref().unwrap(); + if let Some(auth_key) = &self.settings.steamgrid_db.auth_key { + let client = steamgriddb_api::Client::new(auth_key); + let search = CachedSearch::new(&client); + //TODO make this multithreaded + state.grid_id = self + .rt + .block_on(search.search(shortcut.app_id, &shortcut.app_name)) + .ok() + .flatten(); + } + state.selected_shortcut = Some(shortcut.clone()); + let folder = Path::new(&user.steam_user_data_folder) + .join("config") + .join("grid"); + //TODO put this in seperate thread + state.hero_image = get_image(ui, &shortcut, &folder, &ImageType::Hero); + state.grid_image = get_image(ui, &shortcut, &folder, &ImageType::Grid); + state.icon_image = get_image(ui, &shortcut, &folder, &ImageType::Icon); + state.logo_image = get_image(ui, &shortcut, &folder, &ImageType::Logo); + state.wide_image = get_image(ui, &shortcut, &folder, &ImageType::WideGrid); + state.selected_shortcut = Some(shortcut); + } +} + +fn render_shortcut_images(ui: &mut egui::Ui, state: &ImageSelectState) -> Option { + let mut grid_id_text = state.grid_id.map(|id| id.to_string()).unwrap_or_default(); + if ui.text_edit_singleline(&mut grid_id_text).changed() { + if let Ok(grid_id) = grid_id_text.parse::() { + return Some(UserAction::GridIdChanged(grid_id)); + } + }; + for image_type in ImageType::all() { + ui.label(image_type.name()); + let image_ref = get_image_ref(image_type, state); + if render_thumbnail(ui, image_ref) { + return Some(UserAction::ImageTypeSelected(*image_type)); + } + } + None +} + +fn render_user_select(state: &ImageSelectState, ui: &mut egui::Ui) -> UserAction { + let users = state.steam_users.as_ref().unwrap(); + if users.len() == 1 { + return UserAction::UserSelected(users[0].clone()); + } + for user in users { + if ui.button(&user.user_id).clicked() { + return UserAction::UserSelected(user.clone()); + } + } + UserAction::NoAction +} + +fn handle_back_button_action(state: &mut ImageSelectState) { + if state.image_type_selected.is_some() { + state.image_type_selected = None; + } else if state.selected_shortcut.is_some() { + state.selected_shortcut = None; + } else { + state.steam_user = None; } } -const MAX_WIDTH:f32 = 300.; +const MAX_WIDTH: f32 = 300.; -fn render_image(ui: &mut egui::Ui, image: &mut Option) -> bool { +fn render_thumbnail(ui: &mut egui::Ui, image: &Option) -> bool { match image { Some(texture) => { let mut size = texture.size_vec2(); - clamp_to_width(&mut size,MAX_WIDTH); + clamp_to_width(&mut size, MAX_WIDTH); let image_button = ImageButton::new(texture, size); ui.add(image_button) .on_hover_text("Click to change image") @@ -381,10 +441,10 @@ fn render_image(ui: &mut egui::Ui, image: &mut Option) -> b } } -fn clamp_to_width(size: &mut egui::Vec2, max_width :f32) { +fn clamp_to_width(size: &mut egui::Vec2, max_width: f32) { let mut x = size.x; let mut y = size.y; - if size.x > max_width{ + if size.x > max_width { let ratio = size.y / size.x; x = max_width; y = x * ratio; @@ -407,3 +467,17 @@ fn get_image( }); image } + +fn get_image_ref<'a>( + image_type: &ImageType, + state: &'a ImageSelectState, +) -> &'a Option { + match image_type { + ImageType::Hero => &state.hero_image, + ImageType::Grid => &state.grid_image, + ImageType::WideGrid => &state.wide_image, + ImageType::Logo => &state.logo_image, + ImageType::BigPicture => &state.wide_image, + ImageType::Icon => &state.icon_image, + } +} diff --git a/src/ui/ui_import_games.rs b/src/ui/ui_import_games.rs index 1cb873d..ae26b65 100644 --- a/src/ui/ui_import_games.rs +++ b/src/ui/ui_import_games.rs @@ -83,6 +83,7 @@ impl MyEguiApp { ui.label("Check the settings if BoilR didn't find the game you where looking for"); }, _=> { + ui.ctx().request_repaint(); ui.label("Finding installed games"); }, }; diff --git a/src/ui/uiapp.rs b/src/ui/uiapp.rs index 2e1ccce..22cf3e0 100644 --- a/src/ui/uiapp.rs +++ b/src/ui/uiapp.rs @@ -130,6 +130,9 @@ impl epi::App for MyEguiApp { } SyncProgress::Done => ("Done importing games".to_string(), false), }; + if syncing { + ui.ctx().request_repaint(); + } if !status_string.is_empty() { ui.label(status_string); }