TastyPancakes
/
rot8
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge pull request #11 from deadly-platypus/algo-update 

adding keyboard deactivation, improve rotation algorithm and introduce threshold
This commit is contained in:
Esra Fernau 2020-01-04 23:21:29 +01:00 committed by GitHub
parent 41fb696fb0 0b3b48967f
commit a30f3233e8
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
3 changed files with 160 additions and 67 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Cargo.toml
View File

@ -1,7 +1,7 @@
[package]
name = "rot8"
version = "0.1.2"
authors = ["efernau <e.fernau@efero.de>"]
authors = ["efernau <e.fernau@efero.de>", "deadly_platypus <mail@geth.systems>"]
license = "MIT"
description = "automatic display rotation using built-in accelerometer"
homepage = "https://github.com/efernau/rot8"

1
README.md
View File

@ -55,5 +55,6 @@ there are the following args.
--sleep // Set sleep millis (500)
--display // Set Display Device (eDP-1)
--touchscreen // Set Touchscreen Device X11 (ELAN0732:00 04F3:22E1)
--keyboard // Set keyboard to deactivate upon rotation
```

178
src/main.rs
View File

@ -2,14 +2,16 @@ extern crate clap;
extern crate glob;
extern crate regex;
use clap::{App, Arg};
use glob::glob;
use serde::Deserialize;
use std::fs;
use std::process::Command;
use std::thread;
use std::time::Duration;
use clap::{App, Arg};
use glob::glob;
use serde::Deserialize;
use serde_json::Value;
enum Backend {
Sway,
Xorg,
@ -21,6 +23,38 @@ struct SwayOutput {
transform: String,
}
fn get_keyboards(backend: &Backend) -> Result<Vec<String>, String> {
match backend {
Backend::Sway => {
let raw_inputs = String::from_utf8(
Command::new("swaymsg")
.arg("-t")
.arg("get_inputs")
.arg("--raw")
.output()
.expect("Swaymsg get inputs command failed")
.stdout,
)
.unwrap();
let mut keyboards = vec![];
let deserialized: Vec<Value> = serde_json::from_str(&raw_inputs)
.expect("Unable to deserialize swaymsg JSON output");
for output in deserialized {
let input_type = output["type"].as_str().unwrap();
if input_type == "keyboard" {
keyboards.push(output["identifier"].to_string());
}
}
return Ok(keyboards);
}
Backend::Xorg => {
return Ok(vec![]);
}
}
}
fn get_window_server_rotation_state(display: &str, backend: &Backend) -> Result<String, String> {
match backend {
Backend::Sway => {
@ -83,6 +117,13 @@ fn get_window_server_rotation_state(display: &str, backend: &Backend) -> Result<
}
}
struct Orientation {
vector: (f32, f32),
new_state: &'static str,
x_state: &'static str,
matrix: [&'static str; 9]
}
fn main() -> Result<(), String> {
let mut new_state: &str;
let mut path_x: String = "".to_string();
@ -106,39 +147,62 @@ fn main() -> Result<(), String> {
return Err("Unable to find Sway or Xorg procceses".to_owned());
};
let matches = App::new("rot8")
.version("0.1.1")
.arg(
let mut args = vec![
Arg::with_name("sleep")
.default_value("500")
.long("sleep")
.value_name("SLEEP")
.help("Set sleep millis")
.takes_value(true),
)
.arg(
Arg::with_name("display")
.default_value("eDP-1")
.long("display")
.value_name("DISPLAY")
.help("Set Display Device")
.takes_value(true),
)
.arg(
Arg::with_name("touchscreen")
.default_value("ELAN0732:00 04F3:22E1")
.long("touchscreen")
.value_name("TOUCHSCREEN")
.help("Set Touchscreen Device (X11)")
.takes_value(true),
)
.get_matches();
Arg::with_name("threshold")
.default_value("0.5")
.long("threshold")
.value_name("THRESHOLD")
.help("Set a rotation threshold between 0 and 1")
.takes_value(true)
];
match backend {
Backend::Sway => {
args.push(
Arg::with_name("keyboard")
.long("disable-keyboard")
.short("k")
.help("Disable keyboard for tablet modes (Sway only)")
.takes_value(false)
);
}
Backend::Xorg => { /* Keyboard disabling in Xorg is not supported yet */ }
}
let cmd_lines = App::new("rot8")
.version("0.1.1")
.args(&args);
let matches = cmd_lines.get_matches();
let sleep = matches.value_of("sleep").unwrap_or("default.conf");
let display = matches.value_of("display").unwrap_or("default.conf");
let touchscreen = matches.value_of("touchscreen").unwrap_or("default.conf");
let disable_keyboard = matches.is_present("keyboard");
let threshold = matches.value_of("threshold").unwrap_or("default.conf");
let old_state_owned = get_window_server_rotation_state(display, &backend)?;
let mut old_state = old_state_owned.as_str();
let keyboards = get_keyboards(&backend)?;
for entry in glob("/sys/bus/iio/devices/iio:device*/in_accel_*_raw").unwrap() {
match entry {
Ok(path) => {
@ -156,45 +220,59 @@ fn main() -> Result<(), String> {
}
}
let orientations = [
Orientation {
vector: (0.0, -1.0),
new_state: "normal",
x_state: "normal",
matrix: ["1", "0", "0", "0", "1", "0", "0", "0", "1"]
},
Orientation {
vector: (0.0, 1.0),
new_state: "180",
x_state: "inverted",
matrix: ["-1", "0", "1", "0", "-1", "1", "0", "0", "1"]
},
Orientation {
vector: (-1.0, 0.0),
new_state: "90",
x_state: "right",
matrix: ["0", "-1", "1", "1", "0", "0", "0", "0", "1"]
},
Orientation {
vector: (1.0, 0.0),
new_state: "270",
x_state: "left",
matrix: ["0", "1", "0", "-1", "0", "1", "0", "0", "1"]
}
];
let mut current_orient: &Orientation = &orientations[0];
loop {
let x_raw = fs::read_to_string(path_x.as_str()).unwrap();
let y_raw = fs::read_to_string(path_y.as_str()).unwrap();
let x = x_raw.trim_end_matches('\n').parse::<i32>().unwrap_or(0);
let y = y_raw.trim_end_matches('\n').parse::<i32>().unwrap_or(0);
let x_clean = x_raw.trim_end_matches('\n').parse::<i32>().unwrap_or(0);
let y_clean = y_raw.trim_end_matches('\n').parse::<i32>().unwrap_or(0);
if x < -500000 {
if y > 500000 {
new_state = "180";
x_state = "normal";
matrix = ["-1", "0", "1", "0", "-1", "1", "0", "0", "1"];
} else {
new_state = "90";
x_state = "right";
matrix = ["0", "-1", "1", "1", "0", "0", "0", "0", "1"];
}
} else if x > 500000 {
if y > 500000 {
new_state = "180";
x_state = "inverted";
matrix = ["-1", "0", "1", "0", "-1", "1", "0", "0", "1"];
} else {
new_state = "270";
x_state = "left";
matrix = ["0", "1", "0", "-1", "0", "1", "0", "0", "1"];
}
} else {
if y > 500000 {
new_state = "180";
x_state = "inverted";
matrix = ["-1", "0", "1", "0", "-1", "1", "0", "0", "1"];
} else {
new_state = "normal";
x_state = "normal";
matrix = ["1", "0", "0", "0", "1", "0", "0", "0", "1"];
// Normalize vectors
let x: f32 = (x_clean as f32)/1e6;
let y: f32 = (y_clean as f32)/1e6;
for (_i, orient) in orientations.iter().enumerate() {
let d = (x-orient.vector.0).powf(2.0) + (y-orient.vector.1).powf(2.0);
if d < threshold.parse::<f32>().unwrap_or(0.5) {
current_orient = &orient;
break;
}
}
new_state = current_orient.new_state;
x_state = current_orient.x_state;
matrix = current_orient.matrix;
if new_state != old_state {
let keyboard_state = if new_state == "normal" { "enabled" } else { "disabled" };
match backend {
Backend::Sway => {
Command::new("swaymsg")
@ -206,6 +284,20 @@ fn main() -> Result<(), String> {
.expect("Swaymsg rotate command failed to start")
.wait()
.expect("Swaymsg rotate command wait failed");
if disable_keyboard {
for keyboard in &keyboards {
// println!("swaymsg input {} events {}", keyboard, keyboard_state);
Command::new("swaymsg")
.arg("input")
.arg(keyboard)
.arg("events")
.arg(keyboard_state)
.spawn()
.expect("Swaymsg keyboard command failed to start")
.wait()
.expect("Swaymsg keyboard command wait failed");
}
}
}
Backend::Xorg => {
Command::new("xrandr")