app launcher res & orientation functionality

dash-frontend/src/views/app_launcher.rs

@@ -53,7 +53,9 @@ enum Task {
 
 struct LaunchParams<'a, T> {
 	application: &'a DesktopEntry,
-	run_mode: CompositorMode,
+	compositor_mode: CompositorMode,
+	res_mode: ResMode,
+	orientation_mode: OrientationMode,
 	globals: &'a WguiGlobals,
 	frontend_tasks: &'a FrontendTasks,
 	interface: &'a mut BoxDashInterface<T>,
@@ -265,7 +267,9 @@ impl View {
 			application: &self.entry,
 			frontend_tasks: &self.frontend_tasks,
 			globals: &self.globals,
-			run_mode: self.compositor_mode.clone(),
+			compositor_mode: self.compositor_mode,
+			res_mode: self.res_mode,
+			orientation_mode: self.orientation_mode,
 			interface,
 			data,
 			on_launched: &self.on_launched,
@@ -289,7 +293,7 @@ impl View {
 	fn launch<T>(params: LaunchParams<T>) -> anyhow::Result<()> {
 		let mut env = Vec::<String>::new();
 
-		if params.run_mode == CompositorMode::Native {
+		if params.compositor_mode == CompositorMode::Native {
 			// This list could be larger, feel free to expand it
 			env.push("QT_QPA_PLATFORM=wayland".into());
 			env.push("GDK_BACKEND=wayland".into());
@@ -298,12 +302,12 @@ impl View {
 			env.push("ELECTRON_OZONE_PLATFORM_HINT=wayland".into());
 		}
 
-		let args = match params.run_mode {
+		let args = match params.compositor_mode {
 			CompositorMode::Cage => format!("-- {} {}", params.application.exec_path, params.application.exec_args),
 			CompositorMode::Native => params.application.exec_args.to_string(),
 		};
 
-		let exec = match params.run_mode {
+		let exec = match params.compositor_mode {
 			CompositorMode::Cage => "cage".to_string(),
 			CompositorMode::Native => params.application.exec_path.to_string(),
 		};
@@ -311,6 +315,8 @@ impl View {
 		let mut userdata = HashMap::new();
 		userdata.insert("desktop-entry".to_string(), serde_json::to_string(params.application)?);
 
+		let resolution = Self::calculate_resolution(params.res_mode, params.orientation_mode);
+
 		params.interface.process_launch(
 			params.data,
 			WvrProcessLaunchParams {
@@ -318,6 +324,7 @@ impl View {
 				exec,
 				name: params.application.app_name.to_string(),
 				args,
+				resolution,
 				userdata,
 			},
 		)?;
@@ -333,4 +340,28 @@ impl View {
 		// we're done!
 		Ok(())
 	}
+
+	fn calculate_resolution(res_mode: ResMode, orientation_mode: OrientationMode) -> [u32; 2] {
+		let total_pixels = match res_mode {
+			ResMode::Res1440 => 2560 * 1440,
+			ResMode::Res1080 => 1920 * 1080,
+			ResMode::Res720 => 1280 * 720,
+			ResMode::Res480 => 854 * 480,
+		};
+
+		let (ratio_w, ratio_h) = match orientation_mode {
+			OrientationMode::Wide => (16, 9),
+			OrientationMode::SemiWide => (3, 2),
+			OrientationMode::Square => (1, 1),
+			OrientationMode::SemiTall => (2, 3),
+			OrientationMode::Tall => (9, 16),
+		};
+
+		let k = ((total_pixels as f64) / (ratio_w * ratio_h) as f64).sqrt();
+
+		let width = (ratio_w as f64 * k).round() as u64;
+		let height = (ratio_h as f64 * k).round() as u64;
+
+		[width as u32, height as u32]
+	}
 }

wayvr-ipc/src/packet_client.rs

@@ -28,6 +28,7 @@ pub struct WvrProcessLaunchParams {
 	pub exec: String,
 	pub env: Vec<String>,
 	pub args: String,
+	pub resolution: [u32; 2],
 	pub userdata: HashMap<String, String>,
 }
 

wlx-overlay-s/src/backend/wayvr/mod.rs

@@ -36,13 +36,13 @@ use xkbcommon::xkb;
 use crate::{
     backend::{
         task::{OverlayTask, TaskType},
-        wayvr::{image_importer::ImageImporter, window::Window},
+        wayvr::{image_importer::ImageImporter, process::{Process, WayVRProcess}, window::Window},
     },
     graphics::WGfxExtras,
     ipc::{event_queue::SyncEventQueue, ipc_server, signal::WayVRSignal},
     overlays::wayvr::create_wl_window_overlay,
     state::AppState,
-    subsystem::hid::{MODS_TO_KEYS, WheelDelta},
+    subsystem::hid::{WheelDelta, MODS_TO_KEYS},
     windowing::{OverlayID, OverlaySelector},
 };
 
@@ -146,8 +146,8 @@ impl WvrServerState {
         let data_device = DataDeviceState::new::<Application>(&dh);
         let mut seat = seat_state.new_wl_seat(&dh, "wayvr");
 
-        let dummy_width = 1920;
-        let dummy_height = 1080;
+        let dummy_width = 2560;
+        let dummy_height = 1440;
         let dummy_milli_hz = 60000; /* refresh rate in millihertz */
 
         let output = Output::new(
@@ -302,9 +302,14 @@ impl WvrServerState {
                             continue;
                         };
 
+                        let [size_x, size_y] = match wvr_server.processes.get(&process_handle) {
+                            Some(Process::Managed(p)) => p.resolution,
+                            _ => [1920, 1080],
+                        };
+
                         let window_handle = wvr_server
                             .wm
-                            .create_window(toplevel.clone(), process_handle);
+                            .create_window(toplevel.clone(), process_handle, size_x, size_y);
 
                         let title: Arc<str> = with_states(toplevel.wl_surface(), |states| {
                             states
@@ -474,6 +479,7 @@ impl WvrServerState {
         exec_path: &str,
         args: &[&str],
         env: &[(&str, &str)],
+        resolution: [u32; 2],
         working_dir: Option<&str>,
         userdata: HashMap<String, String>,
     ) -> anyhow::Result<process::ProcessHandle> {
@@ -505,6 +511,7 @@ impl WvrServerState {
                     .iter()
                     .map(|(a, b)| (String::from(*a), String::from(*b)))
                     .collect(),
+                resolution,
             }));
 
         self.signals.send(WayVRSignal::BroadcastStateChanged(

wlx-overlay-s/src/backend/wayvr/process.rs

@@ -14,6 +14,7 @@ pub struct WayVRProcess {
     pub args: Vec<String>,
     pub env: Vec<(String, String)>,
     pub working_dir: Option<String>,
+    pub resolution: [u32; 2],
 
     pub userdata: HashMap<String, String>,
 }

wlx-overlay-s/src/backend/wayvr/window.rs

@@ -166,8 +166,12 @@ impl WindowManager {
         &mut self,
         toplevel: Rc<ToplevelSurface>,
         process: process::ProcessHandle,
+        size_x: u32,
+        size_y: u32,
     ) -> WindowHandle {
-        self.windows.add(Window::new(toplevel, process))
+        let mut window = Window::new(toplevel, process);
+        window.set_size(size_x, size_y);
+        self.windows.add(window)
     }
 
     pub fn remove_window(&mut self, window_handle: WindowHandle) {

wlx-overlay-s/src/ipc/ipc_server.rs

@@ -242,6 +242,7 @@ impl Connection {
             &packet_params.exec,
             &args_vec,
             &env_vec,
+            packet_params.resolution,
             None,
             packet_params.userdata,
         );

wlx-overlay-s/src/overlays/dashboard.rs

@@ -369,7 +369,14 @@ impl DashInterface<AppState> for DashInterfaceLive {
         let env_vec = gen_env_vec(&params.env);
 
         wvr_server
-            .spawn_process(&params.exec, &args_vec, &env_vec, None, params.userdata)
+            .spawn_process(
+                &params.exec,
+                &args_vec,
+                &env_vec,
+                params.resolution,
+                None,
+                params.userdata,
+            )
             .map(|x| x.as_packet())
     }