vjoy 0.7.1

Idiomatic and safe wrapper for vjoy-sys
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
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171

#[cfg(test)]

mod tests {
    // The process by which devices are acquired from the C API is not compatible with Rust's test harness and only works within the same test.
    // The tests can be monitored via the vJoyMonitor and vJoyList executables bundled with vJoy.
    use vjoy::{ButtonState, FourWayHat, HatState, VJoy};

    #[test]
    fn test() {
        let mut vjoy = VJoy::from_default_dll_location().unwrap();
        let mut device_1 = vjoy.get_device_state(1).unwrap();

        let (hat_set, hat_reset) = match device_1.hat_type() {
            HatState::Discrete(_) => (
                HatState::Discrete(FourWayHat::East),
                HatState::Discrete(FourWayHat::Centered),
            ),
            HatState::Continuous(_) => (
                HatState::Continuous(90 * 100),
                HatState::Continuous(u32::MAX),
            ),
        };

        // Simple test for 1 device
        println!("Setting button 1 of device 1");
        device_1.set_button(1, ButtonState::Pressed).unwrap();
        vjoy.update_device_state(&device_1).unwrap();
        std::thread::sleep(std::time::Duration::from_millis(100));

        println!("Resetting button 1 of device 1");
        device_1.set_button(1, ButtonState::Released).unwrap();
        vjoy.update_device_state(&device_1).unwrap();
        std::thread::sleep(std::time::Duration::from_millis(100));

        println!("Setting hat 1 of device 1");
        device_1.set_hat(1, hat_set).unwrap();
        vjoy.update_device_state(&device_1).unwrap();
        std::thread::sleep(std::time::Duration::from_millis(100));

        println!("Resetting hat 1 of device 1");
        device_1.set_hat(1, hat_reset).unwrap();
        vjoy.update_device_state(&device_1).unwrap();
        std::thread::sleep(std::time::Duration::from_millis(100));

        println!("Setting axis 1 of device 1 to i32::MAX");
        device_1.set_axis(1, i32::MAX).unwrap();
        vjoy.update_device_state(&device_1).unwrap();
        std::thread::sleep(std::time::Duration::from_millis(100));

        println!("Setting axis 1 of device 1 to i32::MIN");
        device_1.set_axis(1, i32::MIN).unwrap();
        vjoy.update_device_state(&device_1).unwrap();
        std::thread::sleep(std::time::Duration::from_millis(100));
        // Simple test for 1 device

        // Simple test for 1 ref mut device
        println!("Setting button 1 of device 1");
        let device_1_mut = vjoy.get_device_state_mut(1).unwrap();
        device_1_mut.set_button(1, ButtonState::Pressed).unwrap();

        println!("Resetting button 1 of device 1");
        device_1_mut.set_button(1, ButtonState::Released).unwrap();

        println!("Setting hat 1 of device 1");
        device_1_mut.set_hat(1, hat_set).unwrap();
        vjoy.update_all_devices().unwrap();
        std::thread::sleep(std::time::Duration::from_millis(100));

        let device_1_mut = vjoy.get_device_state_mut(1).unwrap();
        println!("Resetting hat 1 of device 1");
        device_1_mut.set_hat(1, hat_reset).unwrap();

        println!("Setting axis 1 of device 1 to i32::MAX");
        device_1_mut.set_axis(1, i32::MAX).unwrap();

        println!("Setting axis 1 of device 1 to i32::MIN");
        device_1_mut.set_axis(1, i32::MIN).unwrap();
        vjoy.update_all_devices().unwrap();
        // Simple test for 1 ref mut device

        // Test all buttons/axes/hats for 1 device
        println!("Setting all buttons for device 1");
        for button in device_1.buttons_mut() {
            button.set(ButtonState::Pressed);
        }
        println!("Setting all hats for device 1");
        for hat in device_1.hats_mut() {
            hat.set(hat_set);
        }
        println!("Setting all axes to MAX");
        for axis in device_1.axes_mut() {
            axis.set(i32::MAX);
        }
        std::thread::sleep(std::time::Duration::from_millis(100));
        vjoy.update_device_state(&device_1).unwrap();

        println!("Resetting all buttons");
        for button in device_1.buttons_mut() {
            button.set(ButtonState::Released);
        }
        println!("Resetting all hats for device 1");
        for hat in device_1.hats_mut() {
            hat.set(hat_reset);
        }
        println!("Setting all axes to MIN");
        for axis in device_1.axes_mut() {
            axis.set(i32::MIN);
        }
        std::thread::sleep(std::time::Duration::from_millis(100));
        vjoy.update_device_state(&device_1).unwrap();
        // Test all buttons/axes/hats for 1 device

        // Test all buttons/axes/hats for all devices
        println!("Test all buttons/axes for all devices");
        for device in &mut vjoy.devices_cloned() {
            for button in device.buttons_mut() {
                button.set(ButtonState::Pressed);
            }
            for hat in device_1.hats_mut() {
                hat.set(hat_set);
            }
            for axis in device.axes_mut() {
                axis.set(i32::MAX);
            }
            std::thread::sleep(std::time::Duration::from_millis(100));
            vjoy.update_device_state(&device).unwrap();

            for button in device.buttons_mut() {
                button.set(ButtonState::Released);
            }
            for hat in device_1.hats_mut() {
                hat.set(hat_reset);
            }
            for axis in device.axes_mut() {
                axis.set(i32::MIN);
            }
            std::thread::sleep(std::time::Duration::from_millis(100));
            vjoy.update_device_state(&device).unwrap();
        }
        // Test all buttons/axes/hats for all devices

        // Rapid test all buttons/axes/hats for all devices
        println!("Rapid test all buttons/axes for all devices");
        for _ in 0..1000 {
            for device in &mut vjoy.devices_cloned() {
                for button in device.buttons_mut() {
                    button.set(ButtonState::Pressed);
                }
                for hat in device_1.hats_mut() {
                    hat.set(hat_set);
                }
                for axis in device.axes_mut() {
                    axis.set(i32::MAX);
                }
                vjoy.update_device_state(&device).unwrap();

                for button in device.buttons_mut() {
                    button.set(ButtonState::Released);
                }
                for hat in device_1.hats_mut() {
                    hat.set(hat_reset);
                }
                for axis in device.axes_mut() {
                    axis.set(i32::MIN);
                }
                vjoy.update_device_state(&device).unwrap();
            }
        }
        // Rapid test all buttons/axes/hats for all devices
    }
}