daxvena/elemeld - Change BQFOYJRTLAFIBZ3SOERSUB2ZXMXJUAROXOGMGWHJW4CVBRT4R5QAC

Refactored focus into it's own struct

Created by daxvena on March 6, 2016

BQFOYJRTLAFIBZ3SOERSUB2ZXMXJUAROXOGMGWHJW4CVBRT4R5QAC

Dependencies

In channels

main

Change contents

Replacement in src/cluster.rs at line 13 [3.13]

B:BD[3.188] → [4.34:52]

∅:D[4.52] → [3.188:206]

B:BD[3.188] → [3.188:206]

    local: Index,
    focus: Index,

[3.188]

[3.206]

    local_screen: Index,
    focus: Focus,
}
#[derive(Clone, Copy, Serialize, Deserialize, Debug)]
pub struct Focus {
    screen: Index,

Replacement in src/cluster.rs at line 27 [3.13]

B:BD[3.384] → [4.53:75]

∅:D[4.75] → [3.384:451]

B:BD[3.384] → [3.384:451]

            local: 0,
            focus: 0,
            pos: Dimensions { x: x , y: y },

[3.384]

[3.451]

            local_screen: 0,
            focus: Focus {
                screen: 0,
                pos: Dimensions { x: x , y: y },
            },

Replacement in src/cluster.rs at line 41 [3.13]

B:BD[3.728] → [5.0:236]

                    let (focus, x, y, was_focused) =
                        (self.focus,
                         self.pos.x + event.dx,
                         self.pos.y + event.dy,
                         self.locally_focused());

[3.728]

[5.236]

                    let focus = Focus {
                        screen: self.focus.screen,
                        pos: Dimensions {
                            x: self.focus.pos.x + event.dx,
                            y: self.focus.pos.y + event.dy,
                        }
                    };

Replacement in src/cluster.rs at line 49 [3.13]

B:BD[5.257] → [5.257:323]

∅:D[5.323] → [3.881:1036]

B:BD[3.881] → [3.881:1036]

                    self.refocus(host, focus, x, y, was_focused);
                    Some(io::NetEvent::Focus(self.focus, io::PositionEvent {
                        x: self.pos.x, y: self.pos.y,
                    }))

[5.257]

[4.127]

                    self.refocus(host, focus);
                    Some(io::NetEvent::Focus(focus))

Replacement in src/cluster.rs at line 74 [3.13]

B:BD[3.1993] → [5.324:368]

B:BD[5.368] → [4.247:280]

    pub fn locally_focused(&self) -> bool {
        self.focus == self.local

[3.1993]

[2.0]

    fn locally_focused(&self) -> bool {
        self.focus.screen == self.local_screen

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

B:BD[2.7] → [2.7:43]

    pub fn reset_local(&mut self) {

[2.7]

[2.43]

    fn reset_local_screen(&mut self) {

Replacement in src/cluster.rs at line 83 [3.13]

B:BD[2.239] → [2.239:347]

                        println!("Local screen at {}", i);
                        self.local = i as Index;

[2.239]

[2.347]

                        self.local_screen = i as Index;

Insertion in src/cluster.rs at line 91 [3.13]

[2.497]

[3.2086]

    }
    pub fn refocus<H>(&mut self, host: &H, focus: Focus) where
        H: io::HostInterface
    {
        let was_focused = self.locally_focused();
        self.private_refocus(host, focus, was_focused);

Replacement in src/cluster.rs at line 100 [3.13]

B:BD[3.2097] → [5.369:467]

    pub fn refocus<H>(&mut self, host: &H, focus: Index, x: i32, y: i32, was_focused: bool) where

[3.2097]

[3.2176]

    fn private_refocus<H>(&mut self, host: &H, focus: Focus, was_focused: bool) where

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

B:BD[3.2211] → [3.2211:2274]

B:BD[3.2333] → [3.2333:2418]

        let (focus, x, y) = self.normalize_focus(focus, x, y);
        self.focus = focus;
        self.pos.x = x;
        self.pos.y = y;

[3.2211]

[3.2418]

        self.focus = self.normalize_focus(focus);

Replacement in src/cluster.rs at line 111 [3.13]

B:BD[4.366] → [4.366:412]

                x: self.pos.x, y: self.pos.y,

[4.366]

[4.412]

                x: self.focus.pos.x, y: self.focus.pos.y,

Replacement in src/cluster.rs at line 124 [3.13]

B:BD[3.2971] → [3.2971:3182]

    fn normalize_focus(&self, focus: Index, x: i32, y: i32) -> (Index, i32, i32) {
        let (focus, x) = self.normalize_x(focus, x);
        let (focus, y) = self.normalize_y(focus, y);
        (focus, x, y)

[3.2971]

[3.3182]

    fn normalize_focus(&self, focus: Focus) -> Focus {
        let (screen, x, y) = (focus.screen, focus.pos.x, focus.pos.y);
        let (screen, x) = self.normalize_x(screen, x);
        let (screen, y) = self.normalize_y(screen, y);
        
        Focus {
            screen: screen,
            pos: Dimensions { x: x, y: y },
        }

Replacement in src/cluster.rs at line 137 [3.13]
∅:D[4.482] → [3.3306:3335]
B:BD[3.3306] → [3.3306:3335]
```
        if self.pos.x < 20 {
```
[4.482]
[3.3335]
```
        if x < 20 {
```

Replacement in src/cluster.rs at line 139 [3.13]

B:BD[3.3373] → [5.468:577]

∅:D[5.577] → [3.3460:3488]

B:BD[3.3460] → [3.3460:3488]

                Some(focus) => return self.normalize_x(focus, x + self.screens[focus as usize].size.x - 40),
                None => (),

[3.3373]

[3.3488]

                Some(focus) => self.normalize_x(focus, x + self.screens[focus as usize].size.x - 40),
                None => (focus, 0),

Replacement in src/cluster.rs at line 142 [3.13]

B:BD[3.3502] → [3.3502:3555]

        } else if self.pos.x >= screen.size.x - 20 {

[3.3502]

[3.3555]

        } else if x >= screen.size.x - 20 {

Replacement in src/cluster.rs at line 144 [3.13]

B:BD[3.3594] → [3.3594:3709]

                Some(focus) => return self.normalize_x(focus, x - screen.size.x + 40),
                None => (),

[3.3594]

[3.3709]

                Some(focus) => self.normalize_x(focus, x - screen.size.x + 40),
                None => (focus, screen.size.x - 1),

Insertion in src/cluster.rs at line 147 [3.13]
[3.3723]
[3.3723]
```
        } else {
            (focus, x)
```
Deletion in src/cluster.rs at line 150 [3.13]
B:BD[3.3733] → [3.3733:3753]
```
        (focus, x)
```
Replacement in src/cluster.rs at line 154 [3.13]
∅:D[4.535] → [3.3877:3906]
B:BD[3.3877] → [3.3877:3906]
```
        if self.pos.y < 20 {
```
[4.535]
[5.578]
```
        if y < 20 {
```

Replacement in src/cluster.rs at line 156 [3.13]

B:BD[5.615] → [5.615:724]

∅:D[5.724] → [3.4031:4059]

B:BD[3.4031] → [3.4031:4059]

                Some(focus) => return self.normalize_y(focus, y + self.screens[focus as usize].size.y - 40),
                None => (),

[5.615]

[3.4059]

                Some(focus) => self.normalize_y(focus, y + self.screens[focus as usize].size.y - 40),
                None => (focus, 0),

Replacement in src/cluster.rs at line 159 [3.13]

B:BD[3.4073] → [3.4073:4126]

        } else if self.pos.y >= screen.size.y - 20 {

[3.4073]

[5.725]

        } else if y >= screen.size.y - 20 {

Replacement in src/cluster.rs at line 161 [3.13]

∅:D[5.765] → [3.4165:4280]

B:BD[3.4165] → [3.4165:4280]

                Some(focus) => return self.normalize_y(focus, y - screen.size.y + 40),
                None => (),

[5.765]

[3.4280]

                Some(focus) => self.normalize_y(focus, y - screen.size.y + 40),
                None => (focus, screen.size.y - 1),

Insertion in src/cluster.rs at line 164 [3.13]
[3.4294]
[3.4294]
```
        } else {
            (focus, y)
```
Deletion in src/cluster.rs at line 167 [3.13]
B:BD[3.4304] → [3.4304:4324]
```
        (focus, y)
```

Replacement in src/cluster.rs at line 218 [3.13]

∅:D[4.1016] → [5.915:943]

B:BD[3.6409] → [5.915:943]

B:BD[5.943] → [2.698:777]

        let (focus, x, y) =
            (other.focus,
             other.pos.x,
             other.pos.y);

[5.864]

[5.1019]

        other.reset_local_screen();
        
        let focus = other.focus;
        let was_focused = self.locally_focused();
        other.private_refocus(host, focus, was_focused);

Deletion in src/cluster.rs at line 224 [3.13]

B:BD[5.1028] → [2.778:873]

        other.reset_local();
        other.refocus(host, focus, x, y, self.locally_focused());

Replacement in src/cluster.rs at line 297 [3.13]

B:BD[3.8006] → [2.943:991]

#[derive(Clone, Serialize, Deserialize, Debug)]

[3.8006]

[3.8060]

#[derive(Clone, Copy, Serialize, Deserialize, Debug)]

Replacement in src/cluster.rs at line 303 [3.13]

B:BD[3.8107] → [2.992:1040]

#[derive(Clone, Serialize, Deserialize, Debug)]

[3.8107]

[3.8161]

#[derive(Clone, Copy, Serialize, Deserialize, Debug)]

Replacement in src/elemeld.rs at line 63 [3.8294]

B:BD[3.9972] → [3.9972:10029]

B:BD[3.10029] → [5.1152:1318]

                    io::NetEvent::Focus(focus, pos) => {
                        let was_focused = self.cluster.locally_focused();
                        self.cluster.refocus(&self.host, focus, pos.x, pos.y, was_focused);

[3.9972]

[3.10302]

                    io::NetEvent::Focus(focus) => {
                        self.cluster.refocus(&self.host, focus);

Replacement in src/io.rs at line 33 [6.11]
B:BD[3.11358] → [3.11358:11400]
```
    Focus(cluster::Index, PositionEvent),
```
[3.11358]
[3.11400]
```
    Focus(cluster::Focus),
```

Insertion in src/main.rs at line 10 [7.10002]

[4.2842]

[7.10058]


// Hacky work around for Xfixes
extern crate dylib;
#[macro_use] mod link;
mod xfixes;

Deletion in src/main.rs at line 20 [7.10002]
B:BD[7.10098] → [7.10098:10118]
```
extern crate dylib;
```
Deletion in src/main.rs at line 28 [7.10002]
B:BD[3.14964] → [3.14964:14996]
∅:D[6.691] → [7.10119:10154]
∅:D[3.14996] → [7.10119:10154]
B:BD[7.10119] → [7.10119:10154]
B:BD[7.10163] → [7.10163:10164]
```
// Hacky work around for Xfixes
#[macro_use] mod link;
mod xfixes;
```