mouse-codes 0.1.0

Cross-platform mouse button code mapping and conversion
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

//! Platform enumeration for cross-platform support

use std::fmt;

use crate::types::Button;

/// Supported operating systems/platforms
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum Platform {
    /// Microsoft Windows
    Windows,
    /// Linux (including X11 and Wayland)
    Linux,
    /// Apple macOS
    MacOS,
}

impl Platform {
    /// Get the current platform based on compilation target
    pub fn current() -> Self {
        #[cfg(target_os = "windows")]
        return Platform::Windows;

        #[cfg(target_os = "linux")]
        return Platform::Linux;

        #[cfg(target_os = "macos")]
        return Platform::MacOS;

        #[cfg(not(any(target_os = "windows", target_os = "linux", target_os = "macos")))]
        panic!("Unsupported platform");
    }

    /// Get code for button on this platform
    pub fn button_code(&self, button: Button) -> usize {
        button.to_code(*self)
    }

    /// Get button from code on this platform  
    pub fn button_from_code(&self, code: usize) -> Option<Button> {
        Button::from_code(code, *self)
    }

    /// Check if the given code matches the specified button on this platform
    pub fn code_matches_button(&self, code: usize, button: Button) -> bool {
        button.matches_code(code, *self)
    }
}

impl fmt::Display for Platform {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Platform::Windows => write!(f, "Windows"),
            Platform::Linux => write!(f, "Linux"),
            Platform::MacOS => write!(f, "macOS"),
        }
    }
}

impl std::str::FromStr for Platform {
    type Err = crate::error::MouseParseError;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        match s.to_lowercase().as_str() {
            "windows" => Ok(Platform::Windows),
            "linux" => Ok(Platform::Linux),
            "macos" | "osx" => Ok(Platform::MacOS),
            _ => Err(crate::error::MouseParseError::UnknownPlatform),
        }
    }
}