daxvena/elemeld - Change CN2CI25XYZMVKYBKTSIVKO5GNDFXQ3CE2ZKS623D5EULTPTKFHDQC

Focus normalization now scales with screen size

Created by daxvena on March 6, 2016

CN2CI25XYZMVKYBKTSIVKO5GNDFXQ3CE2ZKS623D5EULTPTKFHDQC

Dependencies

In channels

main

Change contents

Replacement in src/cluster.rs at line 19 [4.13]
B:BD[3.119] → [3.119:138]
```
    screen: Index,
```
[3.119]
[4.206]
```
    index: Index,
```
Replacement in src/cluster.rs at line 29 [4.13]
B:BD[3.195] → [3.195:222]
```
                screen: 0,
```
[3.195]
[3.222]
```
                index: 0,
```

Replacement in src/cluster.rs at line 42 [4.13]

B:BD[3.327] → [3.327:378]

                        screen: self.focus.screen,

[3.327]

[3.378]

                        index: self.focus.index,

Replacement in src/cluster.rs at line 75 [4.13]

B:BD[2.46] → [2.46:96]

        &self.screens[self.focus.screen as usize]

[2.46]

[2.96]

        &self.screens[self.focus.index as usize]

Replacement in src/cluster.rs at line 79 [4.13]

B:BD[3.731] → [3.731:778]

        self.focus.screen == self.local_screen

[3.731]

[5.0]

        self.focus.index == self.local_screen

Insertion in src/cluster.rs at line 127 [4.13]

[4.2963]

     * TODO: Use macros to avoid the insane amount of repetition

Replacement in src/cluster.rs at line 130 [4.13]

B:BD[3.1340] → [3.1340:1628]

        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 },
        }

[3.1340]

[4.3182]

        self.normalize_y(self.normalize_x(focus))

Replacement in src/cluster.rs at line 133 [4.13]

B:BD[4.3189] → [4.3189:3255]

B:BD[4.3255] → [6.430:482]

B:BD[6.482] → [3.1629:1649]

    fn normalize_x(&self, focus: Index, x: i32) -> (Index, i32) {
        let screen = &self.screens[focus as usize];
        if x < 20 {

[4.3189]

[4.3335]

    fn normalize_x(&self, focus: Focus) -> Focus {
        let screen = &self.screens[focus.index as usize];
        if focus.pos.x <= 0 {

Replacement in src/cluster.rs at line 137 [4.13]

B:BD[4.3373] → [3.1650:1788]

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

[4.3373]

[4.3488]

                Some(index) => {
                    let new_screen = &self.screens[index as usize];
                    return self.normalize_x(Focus {
                        index: index,
                        pos: Dimensions {
                            x: focus.pos.x + new_screen.size.x - 2,
                            y: focus.pos.y * new_screen.size.y / screen.size.y,
                        }
                    })
                },
                None => if focus.pos.x < 0 {
                    return Focus {
                        index: focus.index,
                        pos: Dimensions {
                            x: 0,
                            y: focus.pos.y,
                        }
                    }
                },

Replacement in src/cluster.rs at line 157 [4.13]

B:BD[4.3502] → [3.1789:1833]

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

[4.3502]

[4.3555]

        } else if focus.pos.x >= screen.size.x - 1 {

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

B:BD[4.3594] → [3.1834:1966]

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

[4.3594]

[4.3709]

                Some(index) => {
                    let new_screen = &self.screens[index as usize];
                    return self.normalize_x(Focus {
                        index: index,
                        pos: Dimensions {
                            x: focus.pos.x - screen.size.x + 2,
                            y: focus.pos.y * new_screen.size.y / screen.size.y,
                        }
                    })
                },
                None => if focus.pos.x > screen.size.x - 1 {
                    return Focus {
                        index: focus.index,
                        pos: Dimensions {
                            x: screen.size.x - 1,
                            y: focus.pos.y,
                        }
                    }
                },

Deletion in src/cluster.rs at line 179 [4.13]
B:BD[4.3723] → [3.1967:2007]
```
        } else {
            (focus, x)
```
Insertion in src/cluster.rs at line 180 [4.13]
[4.3733]
[4.3753]
```
            
        focus
```

Replacement in src/cluster.rs at line 184 [4.13]

B:BD[4.3760] → [4.3760:3826]

B:BD[4.3826] → [6.483:535]

B:BD[6.535] → [3.2008:2028]

    fn normalize_y(&self, focus: Index, y: i32) -> (Index, i32) {
        let screen = &self.screens[focus as usize];
        if y < 20 {

[4.3760]

[7.578]

    fn normalize_y(&self, focus: Focus) -> Focus {
        let screen = &self.screens[focus.index as usize];
        if focus.pos.y <= 0 {

Replacement in src/cluster.rs at line 188 [4.13]

B:BD[7.615] → [3.2029:2167]

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

[7.615]

[4.4059]

                Some(index) => {
                    let new_screen = &self.screens[index as usize];
                    return self.normalize_y(Focus {
                        index: index,
                        pos: Dimensions {
                            x: focus.pos.x * new_screen.size.y / screen.size.x,
                            y: focus.pos.y + new_screen.size.y - 2,
                        }
                    })
                },
                None => if focus.pos.y < 0 {
                    return Focus {
                        index: focus.index,
                        pos: Dimensions {
                            x: focus.pos.x,
                            y: 0,
                        }
                    }
                },

Replacement in src/cluster.rs at line 208 [4.13]

B:BD[4.4073] → [3.2168:2212]

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

[4.4073]

[7.725]

        } else if focus.pos.y >= screen.size.y - 1 {

Replacement in src/cluster.rs at line 210 [4.13]

B:BD[7.765] → [3.2213:2345]

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

[7.765]

[4.4280]

                Some(index) => {
                    let new_screen = &self.screens[index as usize];
                    return self.normalize_y(Focus {
                        index: index,
                        pos: Dimensions {
                            x: focus.pos.x * new_screen.size.y / screen.size.x,
                            y: focus.pos.y - screen.size.y + 2,
                        }
                    })
                },
                None => if focus.pos.y > screen.size.y - 1 {
                    return Focus {
                        index: focus.index,
                        pos: Dimensions {
                            x: focus.pos.x,
                            y: screen.size.y - 1,
                        }
                    }
                },

Deletion in src/cluster.rs at line 230 [4.13]
B:BD[4.4294] → [3.2346:2386]
```
        } else {
            (focus, y)
```
Insertion in src/cluster.rs at line 231 [4.13]
[4.4304]
[4.4324]
```
            
        focus
```