daxvena/elemeld - Change VIQIN5MFAFMCSCHE2IQX3VNXUYNQ5OMGE7HTN356B6UQM4AXSMWQC

Handle grabs through events

Created by daxvena on September 21, 2020

VIQIN5MFAFMCSCHE2IQX3VNXUYNQ5OMGE7HTN356B6UQM4AXSMWQC

Dependencies

In channels

main

Change contents

Deletion in src/cluster.rs at line 8 [8.13]
B:BD[7.7680] → [5.0:19]
```
use std::pin::Pin;
```

Replacement in src/cluster.rs at line 55 [8.13]

B:BD[8.472] → [5.20:121]

∅:D[5.121] → [9.169:200]

B:BD[9.169] → [9.169:200]

∅:D[9.200] → [8.584:590]

B:BD[8.584] → [8.584:590]

    pub fn process_host_event<H>(&mut self, host: Pin<&mut H>, event: HostEvent) -> Option<NetEvent>
        where H: HostInterface
    {

[8.472]

[10.123]

    pub fn process_host_output_event(&mut self, event: HostOutputEvent) -> Vec<InputEvent> {

Replacement in src/cluster.rs at line 57 [8.13]

B:BD[10.145] → [9.201:243]

            HostEvent::Motion(event) => {

[10.145]

[8.676]

            HostOutputEvent::Motion(event) => {

Replacement in src/cluster.rs at line 66 [8.13]

∅:D[11.589] → [12.236:257]

B:BD[12.236] → [12.236:257]

B:BD[12.257] → [5.122:169]

∅:D[5.169] → [9.244:293]

∅:D[13.4003] → [9.244:293]

B:BD[11.637] → [9.244:293]

∅:D[9.293] → [10.192:224]

B:BD[11.690] → [10.192:224]

                    
                    self.refocus(host, focus);
                    Some(NetEvent::Focus(focus))
                } else { None }

[11.589]

[10.224]


                    let mut events = vec![];
                    if let Some(grab) = self.refocus(focus) {
                        events.push(InputEvent::Host(HostInputEvent::Grab(grab)));
                    }
                    events.push(InputEvent::Net(NetEvent::Focus(focus)));
                    events
                } else {
                    vec![]
                }

Replacement in src/cluster.rs at line 78 [8.13]

B:BD[10.239] → [14.123:168]

            HostEvent::Selection(event) => {

[10.239]

[14.168]

            HostOutputEvent::Selection(event) => {

Replacement in src/cluster.rs at line 80 [8.13]
B:BD[14.209] → [14.209:230]
```
                None
```
[14.209]
[14.230]
```
                vec![]
```

Replacement in src/cluster.rs at line 85 [8.13]

B:BD[8.1227] → [9.294:454]

∅:D[9.454] → [8.1403:1438]

B:BD[8.1403] → [8.1403:1438]

                        HostEvent::Button(event) => Some(NetEvent::Button(event)),
                        HostEvent::Key(event) => Some(NetEvent::Key(event)),
                        _ => None,

[8.1227]

[8.1438]

                        HostOutputEvent::Button(event) => vec![InputEvent::Net(NetEvent::Button(event))],
                        HostOutputEvent::Key(event) => vec![InputEvent::Net(NetEvent::Key(event))],
                        _ => vec![],

Replacement in src/cluster.rs at line 89 [8.13]

B:BD[8.1460] → [10.263:295]

                } else { None }

[8.1460]

[10.295]

                } else {
                    vec![]
                }

Replacement in src/cluster.rs at line 96 [8.13]

B:BD[8.1585] → [9.455:535]

    pub fn process_net_event(&mut self, event: NetEvent) -> Option<HostEvent> {

[8.1585]

[8.1672]

    pub fn process_net_output_event(&mut self, event: NetEvent) -> Vec<InputEvent> {

Replacement in src/cluster.rs at line 99 [8.13]

B:BD[8.1734] → [9.536:680]

∅:D[9.680] → [8.1894:1921]

B:BD[8.1894] → [8.1894:1921]

                NetEvent::Button(event) => Some(HostEvent::Button(event)),
                NetEvent::Key(event) => Some(HostEvent::Key(event)),
                _ => None,

[8.1734]

[8.1921]

                NetEvent::Button(event) => vec![InputEvent::Host(HostInputEvent::Button(event))],
                NetEvent::Key(event) => vec![InputEvent::Host(HostInputEvent::Key(event))],
                _ => vec![],

Replacement in src/cluster.rs at line 103 [8.13]

B:BD[8.1935] → [15.222:246]

        } else { None }

[8.1935]

[8.1986]

        } else {
            vec![]
        }

Replacement in src/cluster.rs at line 131 [8.13]

B:BD[11.883] → [5.170:273]

    pub fn refocus<H>(&mut self, host: Pin<&mut H>, focus: Focus) where
        H: HostInterface
    {

[11.883]

[5.273]

    pub fn refocus(&mut self, focus: Focus) -> Option<GrabEvent> {

Deletion in src/cluster.rs at line 133 [8.13]

B:BD[5.323] → [5.323:385]

∅:D[5.385] → [8.2092:2097]

∅:D[13.4228] → [8.2092:2097]

B:BD[8.2092] → [8.2092:2097]

B:BD[8.2097] → [5.386:512]

        self.private_refocus(host, focus, was_focused);
    }
    
    fn private_refocus<H>(&mut self, host: Pin<&mut H>, focus: Focus, was_focused: bool) where
        H: HostInterface
    {

Replacement in src/cluster.rs at line 134 [8.13]

B:BD[5.562] → [5.562:720]

∅:D[5.720] → [15.281:294]

∅:D[13.4581] → [15.281:294]

B:BD[8.2724] → [15.281:294]

B:BD[15.294] → [5.721:869]

        if self.locally_focused() {
            if !was_focused {
                host.ungrab_cursor();
                host.ungrab_keyboard();
            }
            
            host.start_send(HostEvent::Position(PositionEvent {
                x: self.focus.pos.x, y: self.focus.pos.y,
            })).unwrap();

[5.562]

[5.869]

        let focused = self.locally_focused();
        if focused != was_focused {
            Some(GrabEvent { grab: focused })

Replacement in src/cluster.rs at line 138 [8.13]

B:BD[5.886] → [5.886:1003]

            if was_focused {
                host.grab_cursor();
                host.grab_keyboard();
            }

[5.886]

[5.1003]

            None

Replacement in src/cluster.rs at line 290 [8.13]
B:BD[16.373] → [5.1020:1095]
∅:D[5.1095] → [9.798:823]
B:BD[17.697] → [9.798:823]
∅:D[9.823] → [12.858:864]
B:BD[12.858] → [12.858:864]
```
    pub fn replace<H>(&mut self, host: Pin<&mut H>, mut other: Self) where
        H: HostInterface
    {
```
[16.373]
[11.2387]
```
    pub fn replace(&mut self, mut other: Self) -> Option<GrabEvent> {
```
Replacement in src/cluster.rs at line 292 [8.13]
B:BD[11.2423] → [11.2423:2515]
B:BD[11.2515] → [5.1096:1153]
∅:D[17.777] → [12.1019:1028]
∅:D[5.1153] → [12.1019:1028]
∅:D[11.2572] → [12.1019:1028]
∅:D[13.4962] → [12.1019:1028]
B:BD[12.1019] → [12.1019:1028]
```
        
        let focus = other.focus;
        let was_focused = self.locally_focused();
        other.private_refocus(host, focus, was_focused);
        
```
[11.2423]
[17.873]
```
        let event = other.refocus(other.focus);
```
Insertion in src/cluster.rs at line 294 [8.13]
[17.896]
[8.6409]
```
        event
```

Replacement in src/io.rs at line 9 [18.11]

B:BD[4.428] → [4.428:508]

    : Stream<Item=io::Result<HostEvent>>
    + Sink<HostEvent, Error=io::Error>

[4.428]

[4.508]

    : Stream<Item=io::Result<HostOutputEvent>>
    + Sink<HostInputEvent, Error=io::Error>

Deletion in src/io.rs at line 14 [18.11]

B:BD[19.115] → [19.115:231]

    fn grab_cursor(&self);
    fn ungrab_cursor(&self);
    fn grab_keyboard(&self);
    fn ungrab_keyboard(&self);

Insertion in src/io.rs at line 24 [18.11]

[19.400]

[8.11254]

pub enum InputEvent {
    Host(HostInputEvent),
    Net(NetEvent),
}
#[derive(Serialize, Deserialize, Debug)]

Insertion in src/io.rs at line 31 [18.11]

[8.11275]

[19.417]

    Input(HostInputEvent),
    Output(HostOutputEvent),
}
#[derive(Serialize, Deserialize, Debug)]
pub enum HostInputEvent {

Insertion in src/io.rs at line 38 [18.11]

[19.446]

    Grab(GrabEvent),
    Button(ButtonEvent),
    Key(KeyEvent),
    Selection(SelectionEvent),
}
#[derive(Serialize, Deserialize, Debug)]
pub enum HostOutputEvent {

Replacement in src/io.rs at line 49 [18.11]
B:BD[19.515] → [14.352:378]
```
    Selection(Selection),
```
[19.515]
[18.588]
```
    Selection(SelectionEvent),
```

Insertion in src/io.rs at line 76 [18.11]

[19.764]

pub struct GrabEvent {
    pub grab: bool,
}
#[derive(Serialize, Deserialize, Debug)]

Replacement in src/io.rs at line 93 [18.11]
B:BD[14.434] → [14.434:455]
```
pub enum Selection {
```
[14.434]
[14.455]
```
pub enum SelectionEvent {
```
Replacement in src/x11.rs at line 37 [21.308]
∅:D[20.127] → [19.4677:4709]
B:BD[19.4677] → [19.4677:4709]
```
    cursor_grabbed: Cell<bool>,
```
[20.127]
[21.2135]
```
    grabbed: Cell<bool>,
```

Replacement in src/x11.rs at line 142 [21.308]

B:BD[13.8228] → [13.8228:8278]

                cursor_grabbed: Cell::new(false),

[13.8228]

[13.8278]

                grabbed: Cell::new(false),

Replacement in src/x11.rs at line 168 [21.308]

B:BD[14.2646] → [13.8792:8882]

    fn map_generic_event(&self, cookie: xlib::XGenericEventCookie) -> Option<HostEvent> {

[14.2646]

[20.695]

    fn map_generic_event(&self, cookie: xlib::XGenericEventCookie) -> Option<HostOutputEvent> {

Replacement in src/x11.rs at line 171 [21.308]

B:BD[20.787] → [20.787:876]

                xinput2::XI_RawMotion => Some(HostEvent::Motion(self.map_raw_motion())),

[20.787]

[20.876]

                xinput2::XI_RawMotion => Some(HostOutputEvent::Motion(self.map_raw_motion())),

Replacement in src/x11.rs at line 186 [21.308]
B:BD[19.6399] → [19.6399:6438]
```
        if self.cursor_grabbed.get() {
```
[19.6399]
[19.6438]
```
        if self.grabbed.get() {
```

Replacement in src/x11.rs at line 195 [21.308]

B:BD[22.1808] → [13.9172:9272]

    fn map_selection_event(&self, event: xfixes::XFixesSelectionNotifyEvent) -> Option<HostEvent> {

[22.1808]

[14.2871]

    fn map_selection_event(&self, event: xfixes::XFixesSelectionNotifyEvent) -> Option<SelectionEvent> {

Replacement in src/x11.rs at line 199 [21.308]

B:BD[14.3013] → [14.3013:3080]

                    Some(HostEvent::Selection(Selection::Primary))

[14.3013]

[14.3080]

                    Some(SelectionEvent::Primary)

Replacement in src/x11.rs at line 201 [21.308]

B:BD[14.3142] → [14.3142:3211]

                    Some(HostEvent::Selection(Selection::Clipboard))

[14.3142]

[14.3211]

                    Some(SelectionEvent::Clipboard)

Replacement in src/x11.rs at line 221 [21.308]

B:BD[22.1932] → [2.134:194]

∅:D[2.194] → [13.9332:9451]

B:BD[9.7465] → [13.9332:9451]

∅:D[9.7465] → [19.10390:10407]

∅:D[8.16575] → [19.10390:10407]

∅:D[13.9451] → [19.10390:10407]

B:BD[19.10390] → [19.10390:10407]

B:BD[19.10534] → [19.10534:10624]

    fn start_send_motion_event(&self, event: MotionEvent) {
        let (last_x, last_y) = self.last_pos.get();
        self.last_pos.set((last_x + event.dx, last_y + event.dy));
        unsafe {
            (self.xlib.XWarpPointer)(self.display, 0, 0, 0, 0, 0, 0, event.dx, event.dy);

[22.1932]

[13.9452]

    fn start_send_grab_event(&self, event: GrabEvent) {
        if event.grab {
            if self.grabbed.get() {
                return;
            }
            let mask = (xlib::ButtonPressMask | xlib::ButtonReleaseMask) as c_uint;
            unsafe {
                (self.xlib.XGrabPointer)(
                    self.display,
                    self.root,
                    xlib::True,
                    mask,
                    xlib::GrabModeAsync,
                    xlib::GrabModeAsync,
                    0,
                    0,
                    xlib::CurrentTime,
                );
                (self.xlib.XGrabKeyboard)(
                    self.display,
                    self.root,
                    xlib::True,
                    xlib::GrabModeAsync,
                    xlib::GrabModeAsync,
                    xlib::CurrentTime,
                );
                (self.xfixes.XFixesHideCursor)(self.display, self.root);
            }
            self.grabbed.set(true);
        } else {
            if !self.grabbed.get() {
                return;
            }
            unsafe {
                (self.xlib.XUngrabPointer)(self.display, xlib::CurrentTime);
                (self.xlib.XUngrabKeyboard)(self.display, xlib::CurrentTime);
                (self.xfixes.XFixesShowCursor)(self.display, self.root);
            }
            self.grabbed.set(false);

Insertion in src/x11.rs at line 295 [21.308]

[13.9697]

            // TODO: Test if flushes output buffer

Deletion in src/x11.rs at line 322 [21.308]

∅:D[23.2478] → [18.3278:3295]

B:BD[18.3278] → [18.3278:3295]

B:BD[18.3295] → [19.13946:14043]

B:BD[19.14043] → [13.10141:10142]

B:BD[13.10142] → [24.926:1006]

∅:D[19.14043] → [25.5200:5201]

∅:D[24.1006] → [25.5200:5201]

∅:D[13.10219] → [25.5200:5201]

B:BD[25.5200] → [25.5200:5201]

B:BD[25.5249] → [25.5249:5266]

B:BD[25.5266] → [6.72:152]

∅:D[6.152] → [19.14116:14154]

B:BD[19.14116] → [19.14116:14154]

B:BD[19.14154] → [13.10220:10473]

∅:D[13.10473] → [19.14302:14317]

B:BD[19.14302] → [19.14302:14317]

B:BD[19.14317] → [13.10474:10475]

∅:D[13.10475] → [19.14317:14386]

B:BD[19.14317] → [19.14317:14386]

B:BD[19.14386] → [13.10476:10486]

∅:D[13.10486] → [19.14387:14427]

B:BD[25.5395] → [19.14387:14427]

∅:D[19.14427] → [18.3460:3467]

∅:D[25.5395] → [18.3460:3467]

B:BD[18.3460] → [18.3460:3467]

B:BD[18.3467] → [19.14428:14528]

∅:D[19.14528] → [25.5697:5698]

B:BD[25.5697] → [25.5697:5698]

∅:D[25.5698] → [18.3525:3542]

B:BD[18.3525] → [18.3525:3542]

B:BD[18.3542] → [6.153:233]

∅:D[6.233] → [19.14529:14722]

B:BD[18.3542] → [19.14529:14722]

∅:D[19.14722] → [25.5846:5853]

B:BD[25.5846] → [25.5846:5853]

B:BD[25.5853] → [19.14723:14753]

B:BD[19.14753] → [13.10487:10504]

B:BD[13.10504] → [6.234:314]

∅:D[6.314] → [13.10504:10596]

B:BD[13.10504] → [13.10504:10596]

B:BD[13.10596] → [26.135:226]

        }
    }
    fn grab_cursor(&self) {
        if self.cursor_grabbed.get() {
            return;
        }
        let mask = (xlib::ButtonPressMask | xlib::ButtonReleaseMask) as c_uint;
        unsafe {
            // NOTE: Won't immediately be sent, requires X output to be flushed
            (self.xlib.XGrabPointer)(
                self.display,
                self.root,
                xlib::True,
                mask,
                xlib::GrabModeAsync,
                xlib::GrabModeAsync,
                0,
                0,
                xlib::CurrentTime
            );
            (self.xfixes.XFixesHideCursor)(self.display, self.root);
        }
        self.cursor_grabbed.set(true);
    }
    fn ungrab_cursor(&self) {
        if !self.cursor_grabbed.get() {
            return;
        }
        unsafe {
            // NOTE: Won't immediately be sent, requires X output to be flushed
            (self.xlib.XUngrabPointer)(self.display, xlib::CurrentTime);
            (self.xfixes.XFixesShowCursor)(self.display, self.root);
        }
        self.cursor_grabbed.set(false);
    }
    fn grab_keyboard(&self) {
        unsafe {
            // NOTE: Won't immediately be sent, requires X output to be flushed
            (self.xlib.XGrabKeyboard)(
                self.display, self.root, xlib::True,
                xlib::GrabModeAsync, xlib::GrabModeAsync, xlib::CurrentTime
            );

Deletion in src/x11.rs at line 324 [21.308]
∅:D[19.14937] → [18.5788:5789]
∅:D[25.7894] → [18.5788:5789]
B:BD[18.5788] → [18.5788:5789]
B:BD[18.5789] → [19.14938:14970]
B:BD[19.14970] → [13.10685:10702]
B:BD[13.10702] → [6.315:395]
∅:D[6.395] → [13.10702:10786]
B:BD[13.10702] → [13.10702:10786]
∅:D[13.10786] → [19.15051:15057]
B:BD[19.15051] → [19.15051:15057]
```
    fn ungrab_keyboard(&self) {
        unsafe {
            // NOTE: Won't immediately be sent, requires X output to be flushed
            (self.xlib.XUngrabKeyboard)(self.display, xlib::CurrentTime);
        }
    }
```
Replacement in src/x11.rs at line 327 [21.308]
B:BD[13.10813] → [26.227:266]
```
    type Item = io::Result<HostEvent>;
```
[13.10813]
[13.10840]
```
    type Item = io::Result<HostOutputEvent>;
```

Replacement in src/x11.rs at line 354 [21.308]

B:BD[3.757] → [3.757:1167]

                xlib::ButtonPress => Some(HostEvent::Button(Self::map_button_event(event.into(), true))),
                xlib::ButtonRelease => Some(HostEvent::Button(Self::map_button_event(event.into(), false))),
                xlib::KeyPress => Some(HostEvent::Key(self.map_key_event(event.into(), true))),
                xlib::KeyRelease => Some(HostEvent::Key(self.map_key_event(event.into(), false))),

[3.757]

[3.1167]

                xlib::ButtonPress => Some(HostOutputEvent::Button(Self::map_button_event(event.into(), true))),
                xlib::ButtonRelease => Some(HostOutputEvent::Button(Self::map_button_event(event.into(), false))),
                xlib::KeyPress => Some(HostOutputEvent::Key(self.map_key_event(event.into(), true))),
                xlib::KeyRelease => Some(HostOutputEvent::Key(self.map_key_event(event.into(), false))),

Replacement in src/x11.rs at line 363 [21.308]

B:BD[3.1434] → [3.1434:1494]

                    self.map_selection_event(event.into()),

[3.1434]

[13.11993]

                    self.map_selection_event(event.into()).map(HostOutputEvent::Selection),

Replacement in src/x11.rs at line 378 [21.308]
B:BD[13.12465] → [13.12465:12497]
```
impl Sink<HostEvent> for Host {
```
[13.12465]
[13.12497]
```
impl Sink<HostInputEvent> for Host {
```

Replacement in src/x11.rs at line 386 [21.308]

B:BD[19.15893] → [13.12787:12874]

    fn start_send(self: Pin<&mut Self>, event: HostEvent) -> Result<(), Self::Error> {

[19.15893]

[19.15938]

    fn start_send(self: Pin<&mut Self>, event: HostInputEvent) -> Result<(), Self::Error> {

Replacement in src/x11.rs at line 388 [21.308]

B:BD[19.15960] → [2.311:617]

∅:D[2.617] → [13.12875:12928]

B:BD[9.7947] → [13.12875:12928]

            HostEvent::Position(event) => self.start_send_position_event(event),
            HostEvent::Motion(event) => self.start_send_motion_event(event),
            HostEvent::Button(event) => self.start_send_button_event(event),
            HostEvent::Key(event) => self.start_send_key_event(event),
            HostEvent::Selection(_event) => todo!(),

[19.15960]

[13.12928]

            HostInputEvent::Position(event) => self.start_send_position_event(event),
            HostInputEvent::Grab(event) => self.start_send_grab_event(event),
            HostInputEvent::Button(event) => self.start_send_button_event(event),
            HostInputEvent::Key(event) => self.start_send_key_event(event),
            HostInputEvent::Selection(_event) => todo!(),