ming_wm_lib/

serialize.rs

use std::fmt::Display;

use crate::themes::ThemeInfo;
use crate::messages::{ WindowMessageResponse, WindowManagerRequest, KeyPress, WindowMessage, Direction, ShortcutType, InfoType };
use crate::window_manager_types::{ KeyChar, DrawInstructions, WindowLikeType };
use crate::framebuffer_types::Dimensions;
use crate::utils::get_rest_of_split;

//serde + ron but worse! yay
//not same as ron - simplified
//very messy

//todo: bug with extra byte when copy/pasting because of this... maybe it's the newline or something?

//I can't do `impl fmt::Display for RGBColor` which is annoying

//to type \x1F, do ctrl+7, for \x1E, do ctrl+6

fn array_to_string<T: Display>(array: &[T]) -> String {
  let mut output = String::new();
  for item in array {
    output += &format!("{}{}", if output == String::new() {
      ""
    } else {
      "\x1F"
    }, item);
  }
  output
}

fn option_to_string<T: Display>(option: &Option<T>) -> String {
  if let Some(value) = option {
    format!("S{}", value)
  } else {
    "N".to_string()
  }
}

fn get_color(serialized: &str) -> Result<[u8; 3], ()> {
  let rgb = serialized.split("\x1F");
  let mut color = [0; 3];
  //won't return error if rgb is 0, 1, or 2 elements.
  //I guess that's okay, since it doesn't panic either
  //c_i is the loop counter. enumerate(), you are awesome
  for (c_i, c) in rgb.enumerate() {
    if c_i == 3 {
      return Err(());
    }
    if let Ok(c) = c.parse() {
      color[c_i] = c;
    } else {
      return Err(());
    }
  }
  Ok(color)
}

fn get_two_array(serialized: &str) -> Result<[usize; 2], ()> {
  let mut arg = serialized.split("\x1F");
  let mut a = [0; 2];
  for i in 0..2 {
    if let Some(n) = arg.next() {
      if let Ok(n) = n.parse() {
        a[i] = n;
        continue
      }
    }
    return Err(());
  }
  Ok(a)
}

pub trait Serializable {
  fn serialize(&self) -> String;
  fn deserialize(serialized: &str) -> Result<Self, ()> where Self: Sized;
}

//ripe for macros when I figure them out

impl Serializable for ThemeInfo {
  fn serialize(&self) -> String {
    format!("{}:{}:{}:{}:{}:{}:{}:{}:{}", array_to_string(&self.top), array_to_string(&self.background), array_to_string(&self.border_left_top), array_to_string(&self.border_right_bottom), array_to_string(&self.text), array_to_string(&self.top_text), array_to_string(&self.alt_background), array_to_string(&self.alt_text), array_to_string(&self.alt_secondary))
  }
  fn deserialize(serialized: &str) -> Result<Self, ()> {
    //strip newline at the end
    let serialized = if serialized.ends_with("\n") { &serialized[..serialized.len() - 1] } else { serialized };
    let mut theme_info: ThemeInfo = Default::default();
    let arrays = serialized.split(":");
    //won't error or panic if less than 9... rest will just be black by default I guess
    for (a_i, a) in arrays.enumerate() {
      if a_i == 9 {
        return Err(());
      }
      let color = get_color(a)?;
      match a_i {
        0 => {
          theme_info.top = color;
        },
        1 => {
          theme_info.background = color;
        },
        2 => {
          theme_info.border_left_top = color;
        },
        3 => {
          theme_info.border_right_bottom = color;
        },
        4 => {
          theme_info.text = color;
        },
        5 => {
          theme_info.top_text = color;
        },
        6 => {
          theme_info.alt_background = color;
        },
        7 => {
          theme_info.alt_text = color;
        },
        8 => {
          theme_info.alt_secondary = color;
        },
        _ => {},
      };
      if a_i == 8 {
        return Ok(theme_info);
      }
    }
    Err(())
  }
}

#[test]
fn theme_info_serialize_deserialize() {
  use crate::themes::get_theme_info;
  let theme_info = get_theme_info(&Default::default()).unwrap();
  let serialized = theme_info.serialize();
  assert!(serialized == ThemeInfo::deserialize(&serialized).unwrap().serialize());
}

impl Serializable for WindowMessageResponse {
  fn serialize(&self) -> String {
    match self {
      WindowMessageResponse::JustRedraw => "JustRedraw".to_string(),
      WindowMessageResponse::DoNothing => "DoNothing".to_string(),
      WindowMessageResponse::Request(req) => {
        let req = match req {
          WindowManagerRequest::OpenWindow(name) => format!("OpenWindow/{}", name),
          WindowManagerRequest::ClipboardCopy(copy_string) => format!("ClipboardCopy/{}", copy_string.replace("\n", "𐘂")), //serialised output must be 1 line
          WindowManagerRequest::CloseStartMenu => "CloseStartMenu".to_string(),
          WindowManagerRequest::Unlock => "Unlock".to_string(),
          WindowManagerRequest::Lock => "Lock".to_string(),
          WindowManagerRequest::DoKeyChar(kc) => format!("DoKeyChar/{}", match kc {
            KeyChar::Press(c) => format!("Press/{}", c),
            KeyChar::Alt(c) => format!("Alt/{}", c),
            KeyChar::Ctrl(c) => format!("Ctrl/{}", c),
          }),
        };
        format!("Request/{}", req)
      },
    }
  }
  fn deserialize(serialized: &str) -> Result<Self, ()> {
    //strip newline at the end
    let serialized = if serialized.ends_with("\n") { &serialized[..serialized.len() - 1] } else { serialized };
    let mut parts = serialized.split("/");
    match parts.next().unwrap_or("Invalid") {
      "JustRedraw" => Ok(WindowMessageResponse::JustRedraw),
      "DoNothing" => Ok(WindowMessageResponse::DoNothing),
      "Request" => {
        let req = match parts.next().unwrap_or("Invalid") {
          //do get_rest_of_split instead of .next() because it is possible for window name or copy to have "/"
          "OpenWindow" => Some(WindowManagerRequest::OpenWindow(get_rest_of_split(&mut parts, Some("/")))),
          "ClipboardCopy" => Some(WindowManagerRequest::ClipboardCopy(get_rest_of_split(&mut parts, Some("/")))),
          "CloseStartMenu" => Some(WindowManagerRequest::CloseStartMenu),
          "Unlock" => Some(WindowManagerRequest::Unlock),
          "Lock" => Some(WindowManagerRequest::Lock),
          "DoKeyChar" => Some(WindowManagerRequest::DoKeyChar(
            match parts.next().unwrap_or("Invalid") {
              "Press" => KeyChar::Press(parts.next().unwrap_or("?").chars().next().unwrap()),
              "Alt" => KeyChar::Alt(parts.next().unwrap_or("?").chars().next().unwrap()),
              "Ctrl" => KeyChar::Ctrl(parts.next().unwrap_or("?").chars().next().unwrap()),
              _ => KeyChar::Press('?'), //yeah.
            }
          )),
          _ => None, //yeah...
        };
        if let Some(req) = req {
          Ok(WindowMessageResponse::Request(req))
        } else {
          Err(())
        }
      },
      _ => Err(()),
    }
  }
}

#[test]
fn window_message_response_serialize_deserialize() {
  let resp = WindowMessageResponse::JustRedraw;
  let serialized = resp.serialize();
  assert!(resp == WindowMessageResponse::deserialize(&serialized).unwrap());
  let resp = WindowMessageResponse::Request(WindowManagerRequest::OpenWindow("a".to_string()));
  let serialized = resp.serialize();
  assert!(resp == WindowMessageResponse::deserialize(&serialized).unwrap());
  let resp = WindowMessageResponse::Request(WindowManagerRequest::Unlock);
  let serialized = resp.serialize();
  assert!(resp == WindowMessageResponse::deserialize(&serialized).unwrap());
  let resp = WindowMessageResponse::Request(WindowManagerRequest::DoKeyChar(KeyChar::Alt('e')));
  let serialized = resp.serialize();
  assert!(resp == WindowMessageResponse::deserialize(&serialized).unwrap());
}

impl Serializable for DrawInstructions {
  fn serialize(&self) -> String {
    match self {
      //use \x1E (record separator) because it won't be in strings. it better fucking not be at least
      DrawInstructions::Rect(p, d, c) => format!("Rect/{}\x1E{}\x1E{}", array_to_string(p), array_to_string(d), array_to_string(c)),
      DrawInstructions::Text(p, vs, s, c1, c2, ou1, ou2) => format!("Text/{}\x1E{}\x1E{}\x1E{}\x1E{}\x1E{}\x1E{}", array_to_string(p), array_to_string(vs), s, array_to_string(c1), array_to_string(c2), option_to_string(ou1), option_to_string(ou2)),
      DrawInstructions::Gradient(p, d, c1, c2, u) => format!("Gradient/{}\x1E{}\x1E{}\x1E{}\x1E{}", array_to_string(p), array_to_string(d), array_to_string(c1), array_to_string(c2), u),
      DrawInstructions::Bmp(p, s, b) => format!("Bmp/{}\x1E{}\x1E{}", array_to_string(p), s, b),
      DrawInstructions::Circle(p, u, c) => format!("Circle/{}\x1E{}\x1E{}", array_to_string(p), u, array_to_string(c)),
      DrawInstructions::Line(s, e, w, c) => format!("Line/{}\x1E{}\x1E{}\x1E{}", array_to_string(s), array_to_string(e), w, array_to_string(c)),
    }
  }
  fn deserialize(serialized: &str) -> Result<Self, ()> {
    //no need to strip newlines cause the impl for Vec<DrawInstructions> does that for us
    let mut parts = serialized.split("/");
    match parts.next().unwrap_or("Invalid") {
      "Rect" => {
        let rest = get_rest_of_split(&mut parts, Some("/"));
        let mut args = rest.split("\x1E");
        let arg = args.next();
        if arg.is_none() {
          return Err(());
        }
        let p = get_two_array(arg.unwrap())?;
        let arg = args.next();
        if arg.is_none() {
          return Err(());
        }
        let d = get_two_array(arg.unwrap())?;
        let arg = args.next();
        if arg.is_none() {
          return Err(());
        }
        let c = get_color(arg.unwrap())?;
        Ok(DrawInstructions::Rect(p, d, c))
      },
      "Text" => {
        let rest = get_rest_of_split(&mut parts, Some("/"));
        //(p, vs, s, c1, c2, ou1, ou2)
        let mut args = rest.split("\x1E");
        let arg = args.next();
        if arg.is_none() {
          return Err(());
        }
        let p = get_two_array(arg.unwrap())?;
        let arg = args.next();
        if arg.is_none() {
          return Err(());
        }
        let mut vs = Vec::new();
        for s in arg.unwrap().split("\x1F") {
          vs.push(s.to_string());
        }
        let arg = args.next();
        if arg.is_none() {
          return Err(());
        }
        let s = arg.unwrap();
        let arg = args.next();
        if arg.is_none() {
          return Err(());
        }
        let c1 = get_color(arg.unwrap())?;
        let arg = args.next();
        if arg.is_none() {
          return Err(());
        }
        let c2 = get_color(arg.unwrap())?;
        let arg = args.next();
        if arg.is_none() {
          return Err(());
        }
        let arg = arg.unwrap();
        let o1 = match arg {
          "N" => None,
          _ => {
            if arg.len() > 1 {
              if let Ok(n) = arg[1..].parse() {
                Some(n)
              } else {
                None
              }
            } else {
              None
            }
          },
        };
        let arg = args.next();
        if arg.is_none() {
          return Err(());
        }
        let arg = arg.unwrap();
        let o2 = match arg {
          "N" => None,
          _ => {
            if arg.len() > 1 {
              if let Ok(n) = arg[1..].parse() {
                Some(n)
              } else {
                None
              }
            } else {
              None
            }
          },
        };
        Ok(DrawInstructions::Text(p, vs, s.to_string(), c1, c2, o1, o2))
      },
      "Gradient" => {
        let rest = get_rest_of_split(&mut parts, Some("/"));
        //(p, d, c1, c2, u)
        let mut args = rest.split("\x1E");
        let arg = args.next();
        if arg.is_none() {
          return Err(());
        }
        let p = get_two_array(arg.unwrap())?;
        let arg = args.next();
        if arg.is_none() {
          return Err(());
        }
        let d = get_two_array(arg.unwrap())?;
        let arg = args.next();
        if arg.is_none() {
          return Err(());
        }
        let c1 = get_color(arg.unwrap())?;
        let arg = args.next();
        if arg.is_none() {
          return Err(());
        }
        let c2 = get_color(arg.unwrap())?;
        let arg = args.next();
        if arg.is_none() {
          return Err(());
        }
        let u = arg.unwrap().parse();
        if u.is_err() {
          return Err(());
        }
        Ok(DrawInstructions::Gradient(p, d, c1, c2, u.unwrap()))
      },
      "Bmp" => {
        let rest = get_rest_of_split(&mut parts, Some("/"));
        //(p, s, b)
        let mut args = rest.split("\x1E");
        let arg = args.next();
        if arg.is_none() {
          return Err(());
        }
        let p = get_two_array(arg.unwrap())?;
        let arg = args.next();
        if arg.is_none() {
          return Err(());
        }
        let s = arg.unwrap();
        let arg = args.next();
        if arg.is_none() {
          return Err(());
        }
        let arg = arg.unwrap();
        if arg != "true" && arg != "false" {
          return Err(());
        }
        let b = arg == "true";
        Ok(DrawInstructions::Bmp(p, s.to_string(), b))
      },
      "Circle" => {
        let rest = get_rest_of_split(&mut parts, Some("/"));
        //(p, u, c)
        let mut args = rest.split("\x1E");
        let arg = args.next();
        if arg.is_none() {
          return Err(());
        }
        let p = get_two_array(arg.unwrap())?;
        let arg = args.next();
        if arg.is_none() {
          return Err(());
        }
        let u = arg.unwrap().parse();
        if u.is_err() {
          return Err(());
        }
        let arg = args.next();
        if arg.is_none() {
          return Err(());
        }
        let c = get_color(arg.unwrap())?;
        Ok(DrawInstructions::Circle(p, u.unwrap(), c))
      },
      "Line" => {
        let rest = get_rest_of_split(&mut parts, Some("/"));
        //(s, e, w, c)
        let mut args = rest.split("\x1E");
        let arg = args.next();
        if arg.is_none() {
          return Err(());
        }
        let s = get_two_array(arg.unwrap())?;
        let arg = args.next();
        if arg.is_none() {
          return Err(());
        }
        let e = get_two_array(arg.unwrap())?;
        let arg = args.next();
        if arg.is_none() {
          return Err(());
        }
        let w = arg.unwrap().parse();
        if w.is_err() {
          return Err(());
        }
        let arg = args.next();
        if arg.is_none() {
          return Err(());
        }
        let c = get_color(arg.unwrap())?;
        Ok(DrawInstructions::Line(s, e, w.unwrap(), c))
      },
      _ => Err(()),
    }
  }
}

pub type DrawInstructionsVec = Vec<DrawInstructions>;

impl Serializable for DrawInstructionsVec {
  fn serialize(&self) -> String {
    if self.len() == 0 {
      return "empty".to_string();
    }
    let collected: Vec<_> = self.into_iter().map(|ins| ins.serialize()).collect();
    collected.join("\x1D")
  }
  fn deserialize(serialized: &str) -> Result<Self, ()> {
    //strip newline at the end
    let serialized = if serialized.ends_with("\n") { &serialized[..serialized.len() - 1] } else { serialized };
    if serialized == "empty" {
      return Ok(Vec::new());
    }
    let mut instructions = Vec::new();
    for ser_ins in serialized.split("\x1D") {
      if let Ok(ser_ins) = DrawInstructions::deserialize(ser_ins) {
        instructions.push(ser_ins);
      } else {
        return Err(());
      }
    }
    Ok(instructions)
  }
}

#[test]
fn draw_instructions_serialize_deserialize() {
  use std::vec;
  let instructions = vec![
    DrawInstructions::Rect([15, 24], [100, 320], [255, 0, 128]),
    DrawInstructions::Text([0, 158], vec!["nimbus-roman".to_string(), "shippori-mincho".to_string()], "Test test 1234 testing\nmictest / mictest is this thing\non?".to_string(), [12, 36, 108], [128, 128, 128], Some(1), None),
    DrawInstructions::Gradient([0, 500], [750, 125], [255, 255, 255], [0, 0, 0], 12),
    DrawInstructions::Text([123, 999], vec!["nimbus-romono".to_string()], "print!(\"{}\", variable_name);".to_string(), [12, 36, 108], [128, 128, 128], Some(44), Some(200)),
    DrawInstructions::Bmp([55, 98], "mingde".to_string(), true),
    DrawInstructions::Bmp([55, 98], "wooooo".to_string(), false),
    DrawInstructions::Circle([0, 1], 19, [128, 128, 128]),
  ];
  let serialized = instructions.serialize();
  assert!(serialized == DrawInstructionsVec::deserialize(&serialized).unwrap().serialize());
  let instructions = vec![
    DrawInstructions::Rect([0, 0], [410, 410], [0, 0, 0]),
    DrawInstructions::Text([4, 4], vec!["nimbus-romono".to_string()], "Mingde Terminal".to_string(), [255, 255, 255], [0, 0, 0], Some(0), Some(10)),
    DrawInstructions::Text([4, 34], vec!["nimbus-romono".to_string()], "$ a".to_string(), [255, 255, 255], [0, 0, 0], Some(0), Some(10)),
  ];
  let serialized = instructions.serialize() + "\n";
  assert!(serialized[..serialized.len() - 1] == DrawInstructionsVec::deserialize(&serialized).unwrap().serialize());
  let instructions = Vec::new();
  let serialized = instructions.serialize() + "\n";
  assert!(DrawInstructionsVec::deserialize(&serialized).unwrap().len() == 0);
}

impl Serializable for WindowLikeType {
  fn serialize(&self) -> String {
    match self {
      WindowLikeType::LockScreen => "LockScreen".to_string(),
      WindowLikeType::Window => "Window".to_string(),
      WindowLikeType::DesktopBackground => "DesktopBackground".to_string(),
      WindowLikeType::Taskbar => "Taskbar".to_string(),
      WindowLikeType::StartMenu => "StartMenu".to_string(),
      WindowLikeType::WorkspaceIndicator => "WorkspaceIndicator".to_string(),
      WindowLikeType::OnscreenKeyboard => "OnscreenKeyboard".to_string(),
    }
  }
  fn deserialize(serialized: &str) -> Result<Self, ()> {
    let serialized = if serialized.ends_with("\n") { &serialized[..serialized.len() - 1] } else { serialized };
    match serialized {
      "LockScreen" => Ok(WindowLikeType::LockScreen),
      "Window" => Ok(WindowLikeType::Window),
      "DesktopBackground" => Ok(WindowLikeType::DesktopBackground),
      "Taskbar" => Ok(WindowLikeType::Taskbar),
      "StartMenu" => Ok(WindowLikeType::StartMenu),
      "WorkspaceIndicator" => Ok(WindowLikeType::WorkspaceIndicator),
      "OnscreenKeyboard" => Ok(WindowLikeType::OnscreenKeyboard),
      _ => Err(()),
    }
  }
}

#[test]
fn window_like_type_serialize_deserialize() {
  let wl_type = WindowLikeType::Window;
  let serialized = wl_type.serialize();
  assert!(serialized == WindowLikeType::deserialize(&serialized).unwrap().serialize());
}

impl Serializable for Dimensions {
  fn serialize(&self) -> String {
    array_to_string(self)
  }
  fn deserialize(serialized: &str) -> Result<Self, ()> {
    //strip newline at the end
    let serialized = if serialized.ends_with("\n") { &serialized[..serialized.len() - 1] } else { serialized };
    let d = get_two_array(serialized)?;
    Ok(d)
  }
}

impl Serializable for WindowMessage {
  fn serialize(&self) -> String {
    match self {
      WindowMessage::Init(d) => format!("Init/{}", array_to_string(d)),
      WindowMessage::KeyPress(kp) => format!("KeyPress/{}", kp.key),
      WindowMessage::CtrlKeyPress(kp) => format!("CtrlKeyPress/{}", kp.key),
      WindowMessage::Shortcut(st) => format!("Shortcut/{}", match st {
        ShortcutType::StartMenu => "StartMenu".to_string(),
        ShortcutType::SwitchWorkspace(u) => format!("SwitchWorkspace/{}", u),
        ShortcutType::MoveWindowToWorkspace(u) => format!("MoveWindowToWorkspace/{}", u),
        ShortcutType::FocusPrevWindow => "FocusPrevWindow".to_string(),
        ShortcutType::FocusNextWindow => "FocusNextWindow".to_string(),
        ShortcutType::QuitWindow => "QuitWindow".to_string(),
        ShortcutType::MoveWindow(d) => format!("MoveWindow/{}", match d {
          Direction::Left => "Left",
          Direction::Down => "Down",
          Direction::Up => "Up",
          Direction::Right => "Right",
        }),
        ShortcutType::MoveWindowToEdge(d) => format!("MoveWindowToEdge/{}", match d {
          Direction::Left => "Left",
          Direction::Down => "Down",
          Direction::Up => "Up",
          Direction::Right => "Right",
        }),
        ShortcutType::ChangeWindowSize(d) => format!("ChangeWindowSize/{}", match d {
          Direction::Left => "Left",
          Direction::Down => "Down",
          Direction::Up => "Up",
          Direction::Right => "Right",
        }),
        ShortcutType::CenterWindow => "CenterWindow".to_string(),
        ShortcutType::FullscreenWindow => "FullscreenWindow".to_string(),
        ShortcutType::HalfWidthWindow => "HalfWidthWindow".to_string(),
        ShortcutType::ClipboardCopy => "ClipboardCopy".to_string(),
        ShortcutType::ClipboardPaste(s) => format!("ClipboardPaste/{}", s),
      }),
      WindowMessage::Info(i) => format!("Info/{}", match i {
        InfoType::WindowsInWorkspace(wv, u) => {
          let mut wv_string = String::new();
          for w in wv {
            wv_string += &format!("{}\x1F{}\x1F", w.0, w.1);
          }
          wv_string = wv_string[..wv_string.len() - 1].to_string();
          format!("WindowsInWorkspace/{}\x1E{}", wv_string, u)
        },
      }),
      WindowMessage::Focus => "Focus".to_string(),
      WindowMessage::Unfocus => "Unfocus".to_string(),
      WindowMessage::FocusClick => "FocusClick".to_string(),
      WindowMessage::ChangeDimensions(d) => format!("ChangeDimensions/{}", array_to_string(d)),
      WindowMessage::Touch(u1, u2) => format!("Touch/{}\x1E{}", u1, u2),
    }
  }
  fn deserialize(serialized: &str) -> Result<Self, ()> {
    let serialized = if serialized.ends_with("\n") { &serialized[..serialized.len() - 1] } else { serialized };
    let mut parts = serialized.split("/");
    match parts.next().unwrap_or("Invalid") {
      "Init" => {
        let arg = parts.next();
        if arg.is_none() {
          return Err(());
        }
        let d = get_two_array(arg.unwrap())?;
        Ok(WindowMessage::Init(d))
      },
      "KeyPress" => {
        let charg = get_rest_of_split(&mut parts, Some("/")).chars().next();
        if let Some(charg) = charg {
          Ok(WindowMessage::KeyPress(KeyPress { key: charg }))
        } else {
          Err(())
        }
      },
      "CtrlKeyPress" => {
        let charg = get_rest_of_split(&mut parts, Some("/")).chars().next();
        if let Some(charg) = charg {
          Ok(WindowMessage::CtrlKeyPress(KeyPress { key: charg }))
        } else {
          Err(())
        }
      },
      "Shortcut" => {
        let arg = parts.next();
        if arg.is_none() {
          return Err(());
        }
        let arg = arg.unwrap();
        let shortcut = match arg {
          "StartMenu" => Some(ShortcutType::StartMenu),
          "SwitchWorkspace" | "MoveWindowToWorkspace" => {
            let narg = parts.next();
            if narg.is_none() {
              None
            } else {
              let narg = narg.unwrap();
              if let Ok(n) = narg.parse() {
                if arg == "SwitchWorkspace" {
                  Some(ShortcutType::SwitchWorkspace(n))
                } else {
                  Some(ShortcutType::MoveWindowToWorkspace(n))
                }
              } else {
                None
              }
            }
          },
          "FocusPrevWindow" => Some(ShortcutType::FocusPrevWindow),
          "FocusNextWindow" => Some(ShortcutType::FocusNextWindow),
          "QuitWindow" => Some(ShortcutType::QuitWindow),
          "MoveWindow" | "MoveWindowToEdge" | "ChangeWindowSize" => {
            let darg = parts.next();
            if let Some(darg) = darg {
              let direction = match darg {
                "Left" => Some(Direction::Left),
                "Up" => Some(Direction::Up),
                "Down" => Some(Direction::Down),
                "Right" => Some(Direction::Right),
                _ => None,
              };
              if let Some(direction) = direction {
                if arg == "MoveWindow" {
                  Some(ShortcutType::MoveWindow(direction))
                } else if arg == "MoveWindowToEdge" {
                  Some(ShortcutType::MoveWindowToEdge(direction))
                } else {
                  Some(ShortcutType::ChangeWindowSize(direction))
                }
              } else {
                None
              }
            } else {
              None
            }
          },
          "CenterWindow" => Some(ShortcutType::CenterWindow),
          "FullscreenWindow" => Some(ShortcutType::FullscreenWindow),
          "HalfWidthWindow" => Some(ShortcutType::HalfWidthWindow),
          "ClipboardCopy" => Some(ShortcutType::ClipboardCopy),
          "ClipboardPaste" => Some(ShortcutType::ClipboardPaste(get_rest_of_split(&mut parts, Some("/")).replace("𐘂", "\n"))),
          _ => None,
        };
        if let Some(shortcut) = shortcut {
          Ok(WindowMessage::Shortcut(shortcut))
        } else {
          Err(())
        }
      },
      "Info" => {
        //skip WindowsInWorkspace cause that's the only possible InfoType atm
        if parts.next().is_none() {
          return Err(());
        }
        let arg = parts.next();
        if arg.is_none() {
          return Err(());
        }
        let mut parts2 = arg.unwrap().split("\x1E");
        let arg2 = parts2.next();
        if arg2.is_none() {
          return Err(());
        }
        let mut w_tuple: (usize, String) = Default::default();
        let mut w_vec = Vec::new();
        for (i, a) in arg2.unwrap().split("\x1F").enumerate() {
          if i % 2 == 0 {
            if let Ok(n) = a.parse() {
              w_tuple.0 = n;
            }
          } else {
            w_tuple.1 = a.to_string();
            w_vec.push(w_tuple.clone());
          }
        }
        let arg2 = parts2.next();
        if arg2.is_none() {
          return Err(());
        }
        if let Ok(n) = arg2.unwrap().parse() {
          return Ok(WindowMessage::Info(InfoType::WindowsInWorkspace(w_vec, n)));
        } else {
          return Err(());
        }
      },
      "Focus" => Ok(WindowMessage::Focus),
      "Unfocus" => Ok(WindowMessage::Unfocus),
      "FocusClick" => Ok(WindowMessage::FocusClick),
      "ChangeDimensions" => {
        let arg = parts.next();
        if arg.is_none() {
          return Err(());
        }
        let d = get_two_array(arg.unwrap())?;
        Ok(WindowMessage::ChangeDimensions(d))
      },
      "Touch" => {
        let arg = parts.next();
        if arg.is_none() {
          return Err(());
        }
        let mut parts2 = arg.unwrap().split("\x1E");
        let arg2 = parts2.next();
        if arg2.is_none() {
          return Err(());
        }
        let u1 = arg2.unwrap().parse();
        let arg2 = parts2.next();
        if u1.is_err() || arg2.is_none() {
          return Err(());
        }
        let u2 = arg2.unwrap().parse();
        if u2.is_err() {
          return Err(());
        }
        Ok(WindowMessage::Touch(u1.unwrap(), u2.unwrap()))
      },
      _ => Err(()),
    }
  }
}

#[test]
fn window_message_serialize_deserialize() {
  for wm in [
    WindowMessage::Init([1000, 1001]),
    WindowMessage::KeyPress(KeyPress { key: 'a' }),
    WindowMessage::KeyPress(KeyPress { key: '/' }),
    WindowMessage::KeyPress(KeyPress { key: '𐘂' }),
    WindowMessage::CtrlKeyPress(KeyPress { key: ';' }),
    WindowMessage::Shortcut(ShortcutType::StartMenu),
    WindowMessage::Shortcut(ShortcutType::MoveWindowToWorkspace(7)),
    WindowMessage::Shortcut(ShortcutType::ClipboardPaste("105/20 Azumanga".to_string())),
    WindowMessage::Info(InfoType::WindowsInWorkspace(vec![(1, "Terminal".to_string()), (2, "Minesweeper".to_string()), (12, "Test Test".to_string())], 5)),
    WindowMessage::Focus,
    WindowMessage::Unfocus,
    WindowMessage::FocusClick,
    WindowMessage::ChangeDimensions([999, 250]),
    WindowMessage::Touch(12, 247),
  ] {
    let serialized = wm.serialize();
    assert!(serialized == WindowMessage::deserialize(&serialized).unwrap().serialize());
  }
}