zoodex/src/ui/collatable_container/collated_grid.rs

use gtk4 :: * ;
use gtk4 :: Align :: * ;
use gtk4 :: Orientation :: * ;
use gtk4 :: gdk :: * ;
use gtk4 :: gio :: * ;
use gtk4 :: glib :: * ;
use gtk4 :: pango :: * ;
use gtk4 :: pango :: Weight :: * ;
use gtk4 :: prelude :: * ;
use std :: cell :: * ;
use std :: env :: * ;
use std :: iter :: * ;

use crate :: ui :: collatable_container :: * ;
use crate :: ui :: component :: * ;



pub struct CollatedMediaGrid < A : MediaAdapter > {
	media_widget_pairs : RefCell < Vec < ( A :: Overview , Button ) > > ,
	grid_widget : FlowBox ,
	on_media_selected : & 'static dyn Fn ( A :: Overview ) ,
}

impl < A : MediaAdapter > CollatedMediaGrid <A> {
	pub fn new ( on_media_selected : impl Fn ( A :: Overview ) + 'static ) -> Self {
		let grid_widget = flow_box ! (
			@ orientation : Horizontal ;
			@ homogeneous : true ;
			@ css_classes : & [ "collatable-container" ] ;
			@ selection_mode : SelectionMode :: None ;
		) ;
		let media_widget_pairs = RefCell :: new ( Vec :: new () ) ;
		let on_media_selected = leak (on_media_selected) ;

		Self { media_widget_pairs , grid_widget , on_media_selected }
	}

	pub async fn set_media ( & self , media : Vec < A :: Overview > , sorting : A :: Sorting ) {
		// TODO: Check if we should use `MainContext :: invoke_local` here

		let mut widgets = Vec :: new () ;
		for media in media . as_slice () {
			widgets . push ( self . create_media_entry (media) . await ) ;
		}
		self . media_widget_pairs . replace ( zip ( media , widgets ) . collect () ) ;

		for ( _ , widget ) in self . sort_media_widget_pairs (sorting) {
			self . grid_widget . append ( & widget ) ;
		}
	}

	async fn create_media_entry ( & self , media : & A :: Overview ) -> Button {
		button ! (
			@ css_classes : & [ "flat" , "open-collection-item-button" ] ;
			@ connect_clicked : clone ! (
				# [strong] media ,
				# [ strong ( rename_to = on_media_selected ) ] self . on_media_selected ,
				move |_| on_media_selected ( media . clone () ) ,
			) ;
			& g_box ! (
				@ option_children ;
				@ orientation : Vertical ;
				@ valign : Center ;  // I.e. do not fill parent vertically
				@ margin_top : 20 ;
				@ margin_bottom : 20 ;

				{
					let home_directory = var_os ("HOME") . unwrap () ;
					let xdg_data_home = var_os ("XDG_DATA_HOME") ;

					let data_dir = match xdg_data_home {
						Some (xdg_data_home) => concat_os_str ! ( xdg_data_home , "/zoodex" ) ,
						None => concat_os_str ! ( home_directory , "/.local/share/zoodex" ) ,
					} ;

					let poster_file_path = concat_os_str ! ( data_dir , "/posters/" , media . get_uuid () ) ;

					let poster_texture = spawn_blocking (
						move || Texture :: from_filename (poster_file_path) ,
					) . await . unwrap () ;

					match poster_texture {
						Ok (poster_texture) => Some ( image ! (
							@ margin_bottom : 10 ;
							@ pixel_size : 300 ;
							@ paintable : & poster_texture ;
						) ) ,
						Err (error) => {
							if error . matches ( IOErrorEnum :: NotFound ) {
								None  // The file not existing simply means there is no poster for this piece of media
							} else {
								panic ! ( "{}" , error )  // Any other error means something unexpected went wrong
							}
						} ,
					}
				} . as_ref () ,

				Some ( & label ! (
					@ justify : Justification :: Center ;
					@ wrap : true ;
					@ max_width_chars : 1 ;  // Not the actual limit, used instead to wrap more aggressively
					@ attributes : & pango_attributes ! ( @ scale : SCALE_LARGE ; @ weight : Bold ; ) ;
					media . get_name () . as_str () ,
				) ) ,

				media . get_original_name () . map ( |original_name| label ! (
					@ justify : Justification :: Center ;
					@ wrap : true ;
					@ max_width_chars : 1 ;  // Not the actual limit, used instead to wrap more aggressively
					original_name . as_str () ,
				) ) . as_ref () ,

				Some ( & g_box ! (
					@ option_children ;
					@ orientation : Horizontal ;
					@ halign : Center ;
					@ spacing : 20 ;

					Some ( & label ! (
						media . get_release_date () . split ('-') . next () . unwrap () ,
					) ) ,

					media . get_runtime_minutes () . map (
						|runtime_minutes| label ! ( format ! ( "{}m" , runtime_minutes ) . as_str () ) ,
					) . as_ref () ,
				) ) ,
			) ,
		)
	}

	pub fn set_sorting ( & self , sorting : A :: Sorting ) {
		self . grid_widget . remove_all () ;

		for ( _ , widget ) in self . sort_media_widget_pairs (sorting) {
			self . grid_widget . append ( & widget ) ;
		}
	}

	fn sort_media_widget_pairs ( & self , sorting : A :: Sorting ) -> Vec < ( A :: Overview , Button ) > {
		let mut sorted = Vec :: from (
			self . media_widget_pairs . borrow () . as_slice () ,
		) ;

		sorted . sort_by (
			| ( media_1 , _ ) , ( media_2 , _ ) | A :: compare_by ( media_1 , media_2 , sorting ) ,
		) ;

		// See it, say it, ...
		sorted
	}
}

impl < A : MediaAdapter > Component for CollatedMediaGrid <A> {
	fn get_widget ( & self ) -> & FlowBox { & self . grid_widget }
}