stephen/swayout
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Add support for --automatic.

Browse Source
This commit is contained in:
Stephen Byrne
2024-12-31 02:41:22 +00:00
parent 3c9324b63a
commit 2ce2631bbc
6 changed files with 106 additions and 55 deletions
Download Patch File Download Diff File Expand all files Collapse all files

91
src/lib.rs
View File

@@ -1,10 +1,10 @@
use std::collections::HashMap;
mod config;
use crate::config::{get_config,OutputConfig};
use crate::config::{get_config, Config, Layout, OutputConfig};
mod sway;
use crate::sway::{apply_outputs,get_outputs};
use crate::sway::{apply_outputs, get_outputs, Output};
/// Determine the available layout names.
/// Return one layout for each layout defined in the configuration file
@@ -15,41 +15,27 @@ fn get_layouts() -> Vec<String> {
let available_outputs = get_outputs();
let config = get_config();
// Get the names of monitors that are available (that match an available output)
let available_monitor_names:Vec<&String> = config.monitors.iter()
.filter(|(_monitor_name,monitor)|
available_outputs.iter().any(|output|
monitor.make == output.make
&& monitor.model == output.model
&& output.serial == monitor.serial
)
)
.map(|(monitor_name,_monitor)| monitor_name)
.collect();
let mut layout_names: Vec<String> = Vec::new();
// Add each layout defined in the config file for which all outputs are available
config.layouts.iter().for_each(|(layout_name, layout)| {
if layout
.iter()
.all(|(output_name, _output)| available_monitor_names.contains(&output_name))
{
layout_names.push(String::from(layout_name))
}
});
get_available_layouts(&config, &available_outputs)
.iter()
.for_each(|layout| {
layout_names.push(String::from(&layout.name));
});
// add each individual output (by monitor name if the monitor is defined, else by output name)
available_outputs.iter().for_each(|output| {
// if there is a monitor for the output, use the monitor name, else use the output name
let monitor_opt = config.monitors.iter()
.find(|(_monitor_name, monitor)| {
.find(|monitor| {
monitor.make == output.make
&& monitor.model == output.model
&& monitor.serial == output.serial
});
if let Some((monitor_name, _monitor)) = monitor_opt {
layout_names.push(String::from(monitor_name));
if let Some(monitor) = monitor_opt {
layout_names.push(String::from(&monitor.name));
} else {
layout_names.push(String::from(&output.name));
}
@@ -58,6 +44,38 @@ fn get_layouts() -> Vec<String> {
layout_names
}
/// Get the names of monitors that are available (that match an available output)
fn get_available_monitor_names<'a,'b>(config:&'a Config, available_outputs:&'b Vec<Output>) -> Vec<&'a String> {
config.monitors.iter()
.filter(|monitor|
available_outputs.iter().any(|output|
monitor.make == output.make
&& monitor.model == output.model
&& output.serial == monitor.serial
)
)
.map(|monitor| &monitor.name)
.collect()
}
/// Get the layouts for which all monitors are available.
fn get_available_layouts<'a,'b>(config:&'a Config, available_outputs:&'b Vec<Output>) -> Vec<&'a Layout> {
let available_monitor_names:Vec<&String> = get_available_monitor_names(&config, available_outputs);
let mut layouts: Vec<&'a Layout> = Vec::new();
// Add each layout defined in the config file for which all outputs are available
config.layouts.iter().for_each(|layout| {
if layout.outputs.iter()
.all(|(output_name, _output)| available_monitor_names.contains(&output_name))
{
layouts.push(&layout);
}
});
layouts
}
/// Print the name of each layout to standard out, one per line
pub fn print_layout_names() {
get_layouts().iter().for_each(|layout| println!("{layout}"))
@@ -75,11 +93,10 @@ pub fn apply_layout(layout_name: &String) {
let mut output_config_map: HashMap<&String, &OutputConfig> = HashMap::new();
// First check if the layout is defined in the rules
let opt_layout = rules.layouts.get(layout_name);
if let Some(layout) = opt_layout {
if let Some(layout) = rules.layouts.iter().find(|layout| &layout.name == layout_name) {
// The layout is defined in the rules.
layout.iter().for_each(|(monitor_name, output_config)| {
let monitor = &rules.monitors[monitor_name];
layout.outputs.iter().for_each(|(monitor_name, output_config)| {
let monitor = &rules.monitors.iter().find(|monitor| &monitor.name == monitor_name).unwrap();
// find the output for the monitor to get the output name.
let output_opt = outputs.iter().find(|output| {
@@ -96,7 +113,7 @@ pub fn apply_layout(layout_name: &String) {
} else {
// The layout is not defined in the rules.
// See if it is a monitor name...
if let Some(monitor) = rules.monitors.get(layout_name) {
if let Some(monitor) = rules.monitors.iter().find(|monitor| &monitor.name == layout_name) {
// It is a monitor name. Find the matching output...
if let Some(output) = outputs.iter().find(|output| {
output.make == monitor.make && output.model == monitor.model
@@ -119,3 +136,19 @@ pub fn apply_layout(layout_name: &String) {
apply_outputs(&outputs, &output_config_map);
}
/// Apply the first automatic layout for which all outputs are available.
/// Return the name of the layout applied or None if no automatic layout was available.
pub fn apply_automatic() -> Option<String> {
let config = get_config();
let outputs = get_outputs();
if let Some(layout) = get_available_layouts(&config, &outputs)
.iter()
.find(|layout| layout.automatic) {
apply_layout(&layout.name);
Some(String::from(&layout.name))
} else {
None
}
}