display_list, add_display views (wip)

[skip ci]

dash-frontend/src/frontend.rs

@@ -18,8 +18,8 @@ use wlx_common::{dash_interface, timestep::Timestep};
 use crate::{
 	assets, settings,
 	tab::{
-		Tab, TabParams, TabType, apps::TabApps, games::TabGames, home::TabHome, monado::TabMonado, processes::TabProcesses,
-		settings::TabSettings,
+		Tab, TabParams, TabType, TabUpdateParams, apps::TabApps, games::TabGames, home::TabHome, monado::TabMonado,
+		processes::TabProcesses, settings::TabSettings,
 	},
 	task::Tasks,
 	util::{
@@ -166,6 +166,17 @@ impl Frontend {
 			self.process_task(rc_this, task)?;
 		}
 
+		if let Some(tab) = &mut self.current_tab {
+			let mut layout = self.layout.borrow_mut();
+
+			tab.update(TabUpdateParams {
+				globals: &self.globals,
+				frontend_tasks: &self.tasks,
+				layout: &mut layout,
+				interface: &mut self.interface,
+			})?;
+		}
+
 		self.tick(width, height, timestep_alpha)?;
 		self.ticks += 1;
 
@@ -292,6 +303,7 @@ impl Frontend {
 			frontend: rc_this,
 			//frontend_widgets: &self.widgets,
 			settings: self.settings.get_mut(),
+			frontend_tasks: &self.tasks,
 		};
 
 		let tab: Box<dyn Tab> = match tab_type {
@@ -308,15 +320,6 @@ impl Frontend {
 		Ok(())
 	}
 
-	pub fn register_button_task(this_rc: RcFrontend, btn: &Rc<ComponentButton>, task: FrontendTask) {
-		btn.on_click({
-			Box::new(move |_common, _evt| {
-				this_rc.borrow_mut().tasks.push(task.clone());
-				Ok(())
-			})
-		});
-	}
-
 	fn register_widgets(rc_this: &RcFrontend) -> anyhow::Result<()> {
 		let this = rc_this.borrow_mut();
 
@@ -325,44 +328,38 @@ impl Frontend {
 		// ################################
 
 		// "Home" side button
-		Frontend::register_button_task(
-			rc_this.clone(),
-			&this.state.fetch_component_as::<ComponentButton>("btn_side_home")?,
+		this.tasks.handle_button(
+			this.state.fetch_component_as::<ComponentButton>("btn_side_home")?,
 			FrontendTask::SetTab(TabType::Home),
 		);
 
 		// "Apps" side button
-		Frontend::register_button_task(
-			rc_this.clone(),
-			&this.state.fetch_component_as::<ComponentButton>("btn_side_apps")?,
+		this.tasks.handle_button(
+			this.state.fetch_component_as::<ComponentButton>("btn_side_apps")?,
 			FrontendTask::SetTab(TabType::Apps),
 		);
 
 		// "Games" side button
-		Frontend::register_button_task(
-			rc_this.clone(),
-			&this.state.fetch_component_as::<ComponentButton>("btn_side_games")?,
+		this.tasks.handle_button(
+			this.state.fetch_component_as::<ComponentButton>("btn_side_games")?,
 			FrontendTask::SetTab(TabType::Games),
 		);
 
 		// "Monado side button"
-		Frontend::register_button_task(
-			rc_this.clone(),
-			&this.state.fetch_component_as::<ComponentButton>("btn_side_monado")?,
+		this.tasks.handle_button(
+			this.state.fetch_component_as::<ComponentButton>("btn_side_monado")?,
 			FrontendTask::SetTab(TabType::Monado),
 		);
 
 		// "Processes" side button
-		Frontend::register_button_task(
-			rc_this.clone(),
-			&this.state.fetch_component_as::<ComponentButton>("btn_side_processes")?,
+		this.tasks.handle_button(
+			this.state.fetch_component_as::<ComponentButton>("btn_side_processes")?,
 			FrontendTask::SetTab(TabType::Processes),
 		);
 
 		// "Settings" side button
-		Frontend::register_button_task(
-			rc_this.clone(),
-			&this.state.fetch_component_as::<ComponentButton>("btn_side_settings")?,
+		this.tasks.handle_button(
+			this.state.fetch_component_as::<ComponentButton>("btn_side_settings")?,
 			FrontendTask::SetTab(TabType::Settings),
 		);
 
@@ -371,16 +368,14 @@ impl Frontend {
 		// ################################
 
 		// "Audio" bottom bar button
-		Frontend::register_button_task(
-			rc_this.clone(),
-			&this.state.fetch_component_as::<ComponentButton>("btn_audio")?,
+		this.tasks.handle_button(
+			this.state.fetch_component_as::<ComponentButton>("btn_audio")?,
 			FrontendTask::ShowAudioSettings,
 		);
 
 		// "Recenter playspace" bottom bar button
-		Frontend::register_button_task(
-			rc_this.clone(),
-			&this.state.fetch_component_as::<ComponentButton>("btn_recenter")?,
+		this.tasks.handle_button(
+			this.state.fetch_component_as::<ComponentButton>("btn_recenter")?,
 			FrontendTask::RecenterPlayspace,
 		);
 

dash-frontend/src/tab/home.rs

@@ -66,16 +66,12 @@ impl TabHome {
 		let btn_processes = state.fetch_component_as::<ComponentButton>("btn_processes")?;
 		let btn_settings = state.fetch_component_as::<ComponentButton>("btn_settings")?;
 
-		let frontend = params.frontend;
-		Frontend::register_button_task(frontend.clone(), &btn_apps, FrontendTask::SetTab(TabType::Apps));
-		Frontend::register_button_task(frontend.clone(), &btn_games, FrontendTask::SetTab(TabType::Games));
-		Frontend::register_button_task(frontend.clone(), &btn_monado, FrontendTask::SetTab(TabType::Monado));
-		Frontend::register_button_task(
-			frontend.clone(),
-			&btn_processes,
-			FrontendTask::SetTab(TabType::Processes),
-		);
-		Frontend::register_button_task(frontend.clone(), &btn_settings, FrontendTask::SetTab(TabType::Settings));
+		let tasks = params.frontend_tasks;
+		tasks.handle_button(btn_apps, FrontendTask::SetTab(TabType::Apps));
+		tasks.handle_button(btn_games, FrontendTask::SetTab(TabType::Games));
+		tasks.handle_button(btn_monado, FrontendTask::SetTab(TabType::Monado));
+		tasks.handle_button(btn_processes, FrontendTask::SetTab(TabType::Processes));
+		tasks.handle_button(btn_settings, FrontendTask::SetTab(TabType::Settings));
 
 		Ok(Self { state })
 	}

dash-frontend/src/tab/mod.rs

@@ -2,8 +2,9 @@ use wgui::{
 	globals::WguiGlobals,
 	layout::{Layout, WidgetID},
 };
+use wlx_common::dash_interface;
 
-use crate::frontend::RcFrontend;
+use crate::frontend::{FrontendTasks, RcFrontend};
 
 pub mod apps;
 pub mod games;
@@ -28,9 +29,21 @@ pub struct TabParams<'a> {
 	pub parent_id: WidgetID,
 	pub frontend: &'a RcFrontend,
 	pub settings: &'a mut crate::settings::Settings,
+	pub frontend_tasks: &'a FrontendTasks,
+}
+
+pub struct TabUpdateParams<'a> {
+	pub globals: &'a WguiGlobals,
+	pub frontend_tasks: &'a FrontendTasks,
+	pub layout: &'a mut Layout,
+	pub interface: &'a mut Box<dyn dash_interface::DashInterface>,
 }
 
 pub trait Tab {
 	#[allow(dead_code)]
 	fn get_type(&self) -> TabType;
+
+	fn update(&mut self, _params: TabUpdateParams) -> anyhow::Result<()> {
+		Ok(())
+	}
 }

dash-frontend/src/tab/processes.rs

@@ -1,19 +1,29 @@
 use wgui::{
 	assets::AssetPath,
-	parser::{ParseDocumentParams, ParserState},
+	parser::{Fetchable, ParseDocumentParams, ParserState},
 };
 
-use crate::tab::{Tab, TabParams, TabType};
+use crate::{
+	tab::{Tab, TabParams, TabType, TabUpdateParams},
+	views::display_list,
+};
 
 pub struct TabProcesses {
 	#[allow(dead_code)]
 	pub state: ParserState,
+
+	view_display_list: display_list::View,
 }
 
 impl Tab for TabProcesses {
 	fn get_type(&self) -> TabType {
 		TabType::Games
 	}
+
+	fn update(&mut self, params: TabUpdateParams) -> anyhow::Result<()> {
+		self.view_display_list.update(params.layout, params.interface)?;
+		Ok(())
+	}
 }
 
 impl TabProcesses {
@@ -28,6 +38,14 @@ impl TabProcesses {
 			params.parent_id,
 		)?;
 
-		Ok(Self { state })
+		Ok(Self {
+			view_display_list: display_list::View::new(display_list::Params {
+				layout: params.layout,
+				parent_id: state.get_widget_id("display_list_parent")?,
+				globals: params.globals.clone(),
+				frontend_tasks: params.frontend_tasks.clone(),
+			})?,
+			state,
+		})
 	}
 }

dash-frontend/src/task.rs

@@ -1,11 +1,16 @@
 use std::{cell::RefCell, collections::VecDeque, rc::Rc};
 
-#[derive(Clone)]
-pub struct Tasks<TaskType>(Rc<RefCell<VecDeque<TaskType>>>)
-where
-	TaskType: Clone;
+use wgui::components::button::ComponentButton;
 
-impl<TaskType: Clone + 'static> Tasks<TaskType> {
+pub struct Tasks<TaskType>(Rc<RefCell<VecDeque<TaskType>>>);
+
+impl<T> Clone for Tasks<T> {
+	fn clone(&self) -> Self {
+		Self(self.0.clone())
+	}
+}
+
+impl<TaskType: 'static> Tasks<TaskType> {
 	pub fn new() -> Self {
 		Self(Rc::new(RefCell::new(VecDeque::new())))
 	}
@@ -20,8 +25,27 @@ impl<TaskType: Clone + 'static> Tasks<TaskType> {
 	}
 }
 
-impl<TaskType: Clone + 'static> Default for Tasks<TaskType> {
+impl<TaskType: 'static> Default for Tasks<TaskType> {
 	fn default() -> Self {
 		Self::new()
 	}
 }
+
+impl<TaskType: Clone + 'static> Tasks<TaskType> {
+	pub fn handle_button(&self, button: Rc<ComponentButton>, task: TaskType) {
+		button.on_click({
+			let this = self.clone();
+			Box::new(move |_, _| {
+				this.push(task.clone());
+				Ok(())
+			})
+		});
+	}
+
+	pub fn make_callback(&self, task: TaskType) -> Rc<dyn Fn()> {
+		let this = self.clone();
+		Rc::new(move || {
+			this.push(task.clone());
+		})
+	}
+}

dash-frontend/src/views/add_display.rs

@@ -0,0 +1,79 @@
+use std::{collections::HashMap, rc::Rc};
+
+use wgui::{
+	assets::AssetPath,
+	components::{button::ComponentButton, slider::ComponentSlider},
+	globals::WguiGlobals,
+	layout::{Layout, WidgetID},
+	parser::{Fetchable, ParseDocumentParams, ParserState},
+	widget::{label::WidgetLabel, rectangle::WidgetRectangle},
+};
+
+use crate::{frontend::FrontendTasks, tab::TabUpdateParams, task::Tasks};
+
+#[derive(Clone)]
+enum Task {
+	Confirm,
+}
+
+pub struct View {
+	#[allow(dead_code)]
+	pub state: ParserState,
+	tasks: Tasks<Task>,
+	frontend_tasks: FrontendTasks,
+	on_submit: Rc<dyn Fn()>,
+}
+
+pub struct Params<'a> {
+	pub globals: WguiGlobals,
+	pub frontend_tasks: FrontendTasks,
+	pub layout: &'a mut Layout,
+	pub parent_id: WidgetID,
+	pub on_submit: Rc<dyn Fn()>,
+}
+
+impl View {
+	pub fn new(params: Params) -> anyhow::Result<Self> {
+		let doc_params = &ParseDocumentParams {
+			globals: params.globals.clone(),
+			path: AssetPath::BuiltIn("gui/view/add_display.xml"),
+			extra: Default::default(),
+		};
+
+		let state = wgui::parser::parse_from_assets(doc_params, params.layout, params.parent_id)?;
+
+		let tasks = Tasks::new();
+
+		let slider_width = state.fetch_component_as::<ComponentSlider>("slider_width")?;
+		let slider_height = state.fetch_component_as::<ComponentSlider>("slider_height")?;
+		let label_display_name = state.fetch_widget_as::<WidgetLabel>(&params.layout.state, "label_display_name")?;
+		let rect_display = state.fetch_widget_as::<WidgetRectangle>(&params.layout.state, "rect_display");
+		let label_display = state.fetch_widget_as::<WidgetLabel>(&params.layout.state, "label_display");
+		let btn_confirm = state.fetch_component_as::<ComponentButton>("btn_confirm")?;
+
+		tasks.handle_button(btn_confirm, Task::Confirm);
+
+		Ok(Self {
+			state,
+			tasks,
+			frontend_tasks: params.frontend_tasks,
+			on_submit: params.on_submit,
+		})
+	}
+
+	pub fn update(&mut self) -> anyhow::Result<()> {
+		for task in self.tasks.drain() {
+			match task {
+				Task::Confirm => self.confirm(),
+			}
+		}
+		Ok(())
+	}
+}
+
+impl View {
+	fn confirm(&mut self) {
+		log::info!("confirm");
+		(*self.on_submit)();
+	}
+}

dash-frontend/src/views/display_list.rs

@@ -0,0 +1,224 @@
+use std::{cell::RefCell, collections::HashMap, rc::Rc};
+
+use wayvr_ipc::packet_server::WvrDisplay;
+use wgui::{
+	assets::AssetPath,
+	components::button::ComponentButton,
+	globals::WguiGlobals,
+	i18n::Translation,
+	layout::{Layout, WidgetID},
+	parser::{Fetchable, ParseDocumentParams, ParserState},
+	renderer_vk::text::{FontWeight, TextStyle},
+	taffy,
+	widget::{
+		label::{WidgetLabel, WidgetLabelParams},
+		rectangle::{WidgetRectangle, WidgetRectangleParams},
+	},
+};
+use wlx_common::dash_interface;
+
+use crate::{
+	frontend::{FrontendTask, FrontendTasks},
+	tab::TabUpdateParams,
+	task::Tasks,
+	util::popup_manager::{MountPopupParams, PopupHandle},
+	views::add_display,
+};
+
+#[derive(Clone)]
+enum Task {
+	AddDisplay,
+	AddDisplayFinish,
+	Refresh,
+}
+
+pub struct Params<'a> {
+	pub globals: WguiGlobals,
+	pub frontend_tasks: FrontendTasks,
+	pub layout: &'a mut Layout,
+	pub parent_id: WidgetID,
+}
+
+struct State {
+	view_add_display: Option<(PopupHandle, add_display::View)>,
+}
+
+pub struct View {
+	#[allow(dead_code)]
+	pub parser_state: ParserState,
+	tasks: Tasks<Task>,
+	frontend_tasks: FrontendTasks,
+	globals: WguiGlobals,
+	state: Rc<RefCell<State>>,
+	id_list_parent: WidgetID,
+}
+
+impl View {
+	pub fn new(params: Params) -> anyhow::Result<Self> {
+		let doc_params = &ParseDocumentParams {
+			globals: params.globals.clone(),
+			path: AssetPath::BuiltIn("gui/view/display_list.xml"),
+			extra: Default::default(),
+		};
+
+		let parser_state = wgui::parser::parse_from_assets(doc_params, params.layout, params.parent_id)?;
+		let list_parent = parser_state.fetch_widget(&params.layout.state, "list_parent")?;
+
+		let tasks = Tasks::new();
+
+		let btn_add = parser_state.fetch_component_as::<ComponentButton>("btn_add")?;
+		tasks.handle_button(btn_add, Task::AddDisplay);
+
+		tasks.push(Task::Refresh);
+
+		let state = Rc::new(RefCell::new(State { view_add_display: None }));
+
+		Ok(Self {
+			parser_state,
+			tasks,
+			frontend_tasks: params.frontend_tasks,
+			globals: params.globals,
+			state,
+			id_list_parent: list_parent.id,
+		})
+	}
+
+	pub fn update(
+		&mut self,
+		layout: &mut Layout,
+		interface: &mut Box<dyn dash_interface::DashInterface>,
+	) -> anyhow::Result<()> {
+		loop {
+			let tasks = self.tasks.drain();
+			if tasks.is_empty() {
+				break;
+			}
+			for task in tasks {
+				match task {
+					Task::AddDisplay => self.add_display(),
+					Task::AddDisplayFinish => self.add_display_finish()?,
+					Task::Refresh => self.refresh(layout, interface)?,
+				}
+			}
+		}
+
+		let mut state = self.state.borrow_mut();
+		if let Some((_, view)) = &mut state.view_add_display {
+			view.update()?;
+		}
+
+		Ok(())
+	}
+}
+
+fn fill_display_list(
+	globals: &WguiGlobals,
+	parent: WidgetID,
+	layout: &mut Layout,
+	list: Vec<WvrDisplay>,
+) -> anyhow::Result<()> {
+	for entry in list {
+		let (rect, _) = layout.add_child(
+			parent,
+			WidgetRectangle::create(WidgetRectangleParams { ..Default::default() }),
+			taffy::Style {
+				align_items: Some(taffy::AlignItems::Center),
+				justify_content: Some(taffy::JustifyContent::Center),
+				..Default::default()
+			},
+		)?;
+
+		let label_name = WidgetLabel::create(
+			&mut globals.get(),
+			WidgetLabelParams {
+				content: Translation::from_raw_text(&entry.name),
+				style: TextStyle {
+					weight: Some(FontWeight::Bold),
+					..Default::default()
+				},
+			},
+		);
+
+		let label_resolution = WidgetLabel::create(
+			&mut globals.get(),
+			WidgetLabelParams {
+				content: Translation::from_raw_text(""),
+				..Default::default()
+			},
+		);
+
+		layout.add_child(rect.id, label_name, Default::default())?;
+		layout.add_child(rect.id, label_resolution, Default::default())?;
+	}
+
+	Ok(())
+}
+
+impl View {
+	fn add_display(&mut self) {
+		self.frontend_tasks.push(FrontendTask::MountPopup(MountPopupParams {
+			title: Translation::from_translation_key("ADD_DISPLAY"),
+			on_content: {
+				let frontend_tasks = self.frontend_tasks.clone();
+				let globals = self.globals.clone();
+				let state = self.state.clone();
+				let tasks = self.tasks.clone();
+
+				Rc::new(move |data| {
+					state.borrow_mut().view_add_display = Some((
+						data.handle,
+						add_display::View::new(add_display::Params {
+							frontend_tasks: frontend_tasks.clone(),
+							globals: globals.clone(),
+							layout: data.layout,
+							parent_id: data.id_content,
+							on_submit: tasks.make_callback(Task::AddDisplayFinish),
+						})?,
+					));
+					Ok(())
+				})
+			},
+		}));
+	}
+
+	fn add_display_finish(&mut self) -> anyhow::Result<()> {
+		self.state.borrow_mut().view_add_display = None;
+		Ok(())
+	}
+
+	fn refresh(
+		&mut self,
+		layout: &mut Layout,
+		interface: &mut Box<dyn dash_interface::DashInterface>,
+	) -> anyhow::Result<()> {
+		layout.remove_children(self.id_list_parent);
+
+		let mut text: Option<Translation> = None;
+		match interface.display_list() {
+			Ok(list) => {
+				if list.is_empty() {
+					text = Some(Translation::from_translation_key("NO_DISPLAYS_FOUND"))
+				} else {
+					fill_display_list(&self.globals, self.id_list_parent, layout, list)?
+				}
+			}
+			Err(e) => text = Some(Translation::from_raw_text(&format!("Error: {:?}", e))),
+		}
+
+		if let Some(text) = text.take() {
+			layout.add_child(
+				self.id_list_parent,
+				WidgetLabel::create(
+					&mut self.globals.get(),
+					WidgetLabelParams {
+						content: text,
+						..Default::default()
+					},
+				),
+				Default::default(),
+			)?;
+		}
+
+		Ok(())
+	}
+}

dash-frontend/src/views/mod.rs

@@ -1,2 +1,4 @@
+pub mod add_display;
 pub mod app_launcher;
 pub mod audio_settings;
+pub mod display_list;