daxvena/elemeld - Change K3I54HXNNCTEA7L6UGWIVBFB5TPZVZZXDBRSR2YZDIKREXQVWRIQC

Generalized the X11 interface some more

Created by daxvena on February 10, 2016

K3I54HXNNCTEA7L6UGWIVBFB5TPZVZZXDBRSR2YZDIKREXQVWRIQC

Dependencies

In channels

main

Change contents

File addition: event.rs (-rw-r--r--)

[3.6]

// pub trait InputInterface {
//     fn move_cursor(&mut self, x: i32, y: i32);
//     fn set_key(&mut self, key: Key, is_press: bool);
// }
#[allow(dead_code)]
#[derive(Debug, Clone, Copy)]
pub enum Key {
    ControlL, ControlR,
    AltL, AltR,
    ShiftL, ShiftR,
    SuperL, SuperR,
    CapsLock,
    Space, Enter, Tab,
    Backspace, Delete,
    Num0, Num1, Num2, Num3, Num4,
    Num5, Num6, Num7, Num8, Num9,
    A, B, C, D, E, F, G, H,
    I, J, K, L, M, N, O, P,
    Q, R, S, T, U, V, W, X,
    Y, Z,
    F1, F2, F3, F4,
    F5, F6, F7, F8,
    F9, F10, F11, F12,
}

Replacement in src/main.rs at line 1 [3.10002]

B:BD[3.10002] → [3.10003:10058]

#![allow(dead_code, unused_variables, unused_imports)]

[3.10002]

[3.10058]

#![allow(dead_code, unused_variables, unused_imports, non_upper_case_globals)]

Insertion in src/main.rs at line 7 [3.10002]
[3.10119]
[3.10119]
```
mod event;
mod x11;
```
Deletion in src/main.rs at line 11 [3.10002]
B:BD[3.10154] → [3.10154:10163]
```
mod x11;
```
Insertion in src/main.rs at line 12 [3.10002]
[3.10164]
[3.10164]
```
use event::Key;
```
Insertion in src/main.rs at line 14 [3.10002]
[3.10176]
[3.10176]

Replacement in src/main.rs at line 60 [3.10002]

B:BD[4.47] → [2.0:77]

        display.grab_key(display.keysym_to_keycode(XK_Escape as KeySym), 0);

[4.47]

[3.11396]

        display.grab_key(display.keysym_to_keycode(XK_Escape as KeySym), AltLMask);

Replacement in src/main.rs at line 82 [3.10002]

B:BD[3.12266] → [4.48:148]

        let (x, y) = display.query_pointer();
        let (width, height) = display.query_screen();

[3.12266]

[3.12327]

        let (x, y) = display.cursor_pos();
        let (width, height) = display.screen_size();

Replacement in src/main.rs at line 127 [3.10002]

B:BD[4.324] → [4.324:420]

            self.display.grab_pointer(PointerMotionMask | ButtonPressMask | ButtonReleaseMask);

[3.13284]

[2.78]

            self.display.grab_cursor(PointerMotionMask | ButtonPressMask | ButtonReleaseMask);

Replacement in src/main.rs at line 138 [3.10002]

B:BD[3.13755] → [2.161:204]

            self.display.ungrab_pointer();

[3.13755]

[2.204]

            self.display.ungrab_cursor();

Replacement in src/main.rs at line 149 [3.10002]

B:BD[5.435] → [4.505:566]

∅:D[4.566] → [3.14283:14318]

B:BD[3.14283] → [3.14283:14318]

        self.display.warp_pointer(self.real_x, self.real_y);
        self.display.next_event();

[5.435]

[3.14318]

        self.display.move_cursor(self.real_x, self.real_y);
        self.display.next_event(); // consume mouse event

Replacement in src/main.rs at line 156 [3.10002]

B:BD[3.14475] → [4.567:628]

∅:D[4.628] → [3.14557:14592]

B:BD[3.14557] → [3.14557:14592]

        self.display.warp_pointer(self.real_x, self.real_y);
        self.display.next_event();

[3.14475]

[3.14592]

        self.display.move_cursor(self.real_x, self.real_y);
        self.display.next_event(); // consume mouse event

Replacement in src/main.rs at line 175 [3.10002]

B:BD[2.338] → [2.338:417]

                        println!("{}", self.display.keysym_to_string(keysym));

[2.338]

[3.15211]

                        match keysym as u32 {
                            XK_Escape => { if e.state == AltLMask {
                                println!("Alt-Escape");
                            } },
                            _ => println!("{}", self.display.keysym_to_string(keysym)),
                        }

Deletion in src/main.rs at line 186 [3.10002]

B:BD[2.661] → [2.661:718]

                    Some(Event::MappingNotify(e)) => (),

Replacement in src/main.rs at line 194 [3.10002]

B:BD[3.15746] → [4.1013:1134]

                    Some(Event::GenericEvent(e)) => {
                        let (x, y) = self.display.query_pointer();

[3.15746]

[3.15876]

                    Some(Event::GenericEvent(e)) => { if e.evtype == XI_RawMotion {
                        let (x, y) = self.display.cursor_pos();

Replacement in src/main.rs at line 197 [3.10002]

B:BD[3.15926] → [3.15926:15949]

},

[3.15926]

[4.1135]

                    } },
                    Some(Event::MappingNotify(e)) => (),

Replacement in src/x11.rs at line 1 [3.308]
B:BD[3.308] → [3.309:330]
```
use std::{ptr, mem};
```
[3.308]
[2.719]
```
use event::Key;
use std::{ptr, mem, str};
```

Replacement in src/x11.rs at line 77 [3.308]

B:BD[2.810] → [2.810:926]

    ShiftMask,
    LockMask,
    ControlMask,
    Mod1Mask,
    Mod2Mask,
    Mod3Mask,
    Mod4Mask,
    Mod5Mask,

[2.810]

[2.926]

    ShiftMask,   // Left?
    LockMask,    // Left?
    ControlMask, // Left?
    Mod1Mask as AltLMask,
    Mod2Mask,    // ?
    Mod3Mask,    // ?
    Mod4Mask as SuperLMask,
    Mod5Mask,    // ?

Insertion in src/x11.rs at line 135 [3.308]
[3.1999]
[3.1999]
```
use x11_dl::xtest;
```
Insertion in src/x11.rs at line 144 [3.308]
[3.2074]
[3.2074]
```
    xtest: xtest::Xf86vmode,
```

Insertion in src/x11.rs at line 154 [3.308]

[3.2286]

        let xtest = xtest::Xf86vmode::open().unwrap();

Insertion in src/x11.rs at line 166 [3.308]
[3.2568]
[3.2568]
```
            xtest: xtest,
```

Replacement in src/x11.rs at line 178 [3.308]

B:BD[3.2897] → [4.2923:2973]

    pub fn grab_pointer(&self, event_mask: i64) {

[3.2897]

[4.2973]

    pub fn grab_cursor(&self, event_mask: i64) {

Replacement in src/x11.rs at line 211 [3.308]

B:BD[2.1682] → [2.1682:1793]

        unsafe { CStr::from_ptr(
            (self.xlib.XKeysymToString)(keysym)
        ).to_str().unwrap() }

[2.1682]

[2.1793]

        unsafe { str::from_utf8_unchecked(
            CStr::from_ptr((self.xlib.XKeysymToString)(keysym)).to_bytes()
        )}

Deletion in src/x11.rs at line 217 [3.308]

B:BD[4.3670] → [4.3670:3743]

        // TODO: Would XEventsQueued with QueuedAlready make more sense?

Deletion in src/x11.rs at line 267 [3.308]

B:BD[3.6446] → [4.4102:4150]

∅:D[4.4150] → [3.6525:6542]

B:BD[3.6525] → [3.6525:6542]

B:BD[3.6542] → [4.4151:4505]

∅:D[4.4505] → [3.7002:7003]

B:BD[3.7002] → [3.7002:7003]

B:BD[3.7003] → [4.4506:4634]

∅:D[4.4634] → [3.7140:7210]

B:BD[3.7140] → [3.7140:7210]

B:BD[3.7210] → [4.4635:4664]

∅:D[4.4664] → [3.7290:7307]

B:BD[3.7290] → [3.7290:7307]

B:BD[3.7307] → [4.4665:4862]

    pub fn query_pointer(&self) -> (i32, i32) {
        unsafe {
            let mut root = mem::uninitialized();
            let mut child = mem::uninitialized();
            let mut root_x = mem::uninitialized();
            let mut root_y = mem::uninitialized();
            let mut child_x = mem::uninitialized();
            let mut child_y = mem::uninitialized();
            let mut mask = mem::uninitialized();
            (self.xlib.XQueryPointer)(self.display, self.root,
                &mut root, &mut child, &mut root_x, &mut root_y,
                &mut child_x, &mut child_y, &mut mask
            );
            (root_x, root_y)
        }
    }
    pub fn query_screen(&self) -> (i32, i32) {
        let screen = unsafe {
            &*(self.xlib.XDefaultScreenOfDisplay)(self.display)
        };
        (screen.width, screen.height)
    }

Replacement in src/x11.rs at line 271 [3.308]
B:BD[3.7449] → [4.4995:5030]
```
    pub fn ungrab_pointer(&self) {
```
[3.7449]
[4.5030]
```
    pub fn ungrab_cursor(&self) {
```
Deletion in src/x11.rs at line 285 [3.308]
B:BD[3.7570] → [4.5111:5160]
∅:D[4.5160] → [3.7765:7808]
B:BD[3.7765] → [3.7765:7808]
B:BD[3.7808] → [4.5161:5218]
∅:D[4.5218] → [3.7913:7933]
B:BD[3.7913] → [3.7913:7933]
```
    pub fn warp_pointer(&self, x: i32, y: i32) {
        unsafe { (self.xlib.XWarpPointer)(
            self.display, 0, self.root, 0, 0, 0, 0, x, y
        ) };
    }
```

Insertion in src/x11.rs at line 301 [3.308]

[3.8412]


    // general interface
    pub fn screen_size(&self) -> (i32, i32) {
        let screen = unsafe {
            &*(self.xlib.XDefaultScreenOfDisplay)(self.display)
        };
        (screen.width, screen.height)
    }
    pub fn cursor_pos(&self) -> (i32, i32) {
        unsafe {
            let mut root = mem::uninitialized();
            let mut child = mem::uninitialized();
            let mut root_x = mem::uninitialized();
            let mut root_y = mem::uninitialized();
            let mut child_x = mem::uninitialized();
            let mut child_y = mem::uninitialized();
            let mut mask = mem::uninitialized();
            (self.xlib.XQueryPointer)(self.display, self.root,
                &mut root, &mut child, &mut root_x, &mut root_y,
                &mut child_x, &mut child_y, &mut mask
            );
            (root_x, root_y)
        }
    }
    pub fn move_cursor(&mut self, x: i32, y: i32) {
        unsafe { (self.xlib.XWarpPointer)(
            self.display, 0, self.root, 0, 0, 0, 0, x, y
        ) };
    }
    pub fn set_key(&mut self, key: Key, is_press: bool) {
        unsafe {
            let keysym = match key {
                Key::ControlL => XK_Control_L,
                Key::ControlR => XK_Control_R,
                Key::AltL => XK_Alt_L,
                Key::AltR => XK_Alt_R,
                Key::ShiftL => XK_Shift_L,
                Key::ShiftR => XK_Shift_R,
                Key::SuperL => XK_Super_L,
                Key::SuperR => XK_Super_L,
                Key::CapsLock => XK_Caps_Lock,
                Key::Space => XK_space,
                Key::Enter => XK_Return,
                Key::Tab => XK_Tab,
                Key::Backspace => XK_BackSpace,
                Key::Delete => XK_Delete,
                Key::Num0 => XK_0,
                Key::Num1 => XK_1,
                Key::Num2 => XK_2,
                Key::Num3 => XK_3,
                Key::Num4 => XK_4,
                Key::Num5 => XK_5,
                Key::Num6 => XK_6,
                Key::Num7 => XK_7,
                Key::Num8 => XK_8,
                Key::Num9 => XK_9,
                Key::A => XK_A,
                Key::B => XK_B,
                Key::C => XK_C,
                Key::D => XK_D,
                Key::E => XK_E,
                Key::F => XK_F,
                Key::G => XK_G,
                Key::H => XK_H,
                Key::I => XK_I,
                Key::J => XK_J,
                Key::K => XK_K,
                Key::L => XK_L,
                Key::M => XK_M,
                Key::N => XK_N,
                Key::O => XK_O,
                Key::P => XK_P,
                Key::Q => XK_Q,
                Key::R => XK_R,
                Key::S => XK_S,
                Key::T => XK_T,
                Key::U => XK_U,
                Key::V => XK_V,
                Key::W => XK_W,
                Key::Y => XK_Y,
                Key::X => XK_X,
                Key::Z => XK_Z,
                Key::F1 => XK_F1,
                Key::F2 => XK_F2,
                Key::F3 => XK_F3,
                Key::F4 => XK_F4,
                Key::F5 => XK_F5,
                Key::F6 => XK_F6,
                Key::F7 => XK_F7,
                Key::F8 => XK_F8,
                Key::F9 => XK_F9,
                Key::F10 => XK_F10,
                Key::F11 => XK_F11,
                Key::F12 => XK_F12,
            };
            let keycode = (self.xlib.XKeysymToKeycode)(self.display, keysym as u64);
            (self.xtest.XTestFakeKeyEvent)(self.display, keycode as u32, is_press as i32, 0);
        }
    }

Generalized the X11 interface some more

Dependencies

In channels

Change contents

File addition: event.rs (-rw-r--r--)

Replacement in src/main.rs at line 1 [3.10002]

Insertion in src/main.rs at line 7 [3.10002]

Deletion in src/main.rs at line 11 [3.10002]

Insertion in src/main.rs at line 12 [3.10002]

Insertion in src/main.rs at line 14 [3.10002]