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

// Copyright (c) 2017, Marty Mills <daggerbot@gmail.com>
// This software is available under the terms of the zlib license.
// See COPYING.md for more information.

use dinput::{Button, ButtonState, Key, KeyState, Mods, MotionState, Text, WheelDir};
use dvec::{Rect2, Vec2};

use ::Coord;
use display::RunMode;
use id::Id;

/// Union of display events.
#[derive(Clone, Debug)]
pub enum Event {
    Button(ButtonEvent),
    Close(CloseEvent),
    Destroy(DestroyEvent),
    Expose(ExposeEvent),
    Focus(FocusEvent),
    Key(KeyEvent),
    Motion(MotionEvent),
    Resize(ResizeEvent),
    Signal(SignalEvent),
    Update(UpdateEvent),
    Wheel(WheelEvent),
}

impl Event {
    pub fn sender (&self) -> Option<Id> {
        match *self {
            Event::Button(e) => Some(e.sender),
            Event::Close(e) => Some(e.sender),
            Event::Destroy(e) => Some(e.sender),
            Event::Expose(e) => Some(e.sender),
            Event::Focus(e) => Some(e.sender),
            Event::Key(ref e) => Some(e.sender),
            Event::Motion(e) => Some(e.sender),
            Event::Resize(e) => Some(e.sender),
            Event::Signal(e) => Some(e.sender),
            Event::Update(_) => None,
            Event::Wheel(e) => Some(e.sender),
        }
    }
}

/// Pointer button event.
#[derive(Clone, Copy, Debug)]
pub struct ButtonEvent {
    pub sender: Id,
    pub button: Option<Button>,
    pub state: ButtonState,
    pub pos: Vec2<Coord>,
    pub mods: Mods,
    pub raw: u8,
}

/// Close request event.
#[derive(Clone, Copy, Debug)]
pub struct CloseEvent {
    pub sender: Id,
}

/// Destroy event.
#[derive(Clone, Copy, Debug)]
pub struct DestroyEvent {
    pub sender: Id,
}

/// Exposure event.
#[derive(Clone, Copy, Debug)]
pub struct ExposeEvent {
    pub sender: Id,
    pub rect: Rect2<Coord>,
}

/// Focus event.
#[derive(Clone, Copy, Debug)]
pub struct FocusEvent {
    pub sender: Id,
    pub focus: bool,
}

/// Keyboard event.
#[derive(Clone, Debug)]
pub struct KeyEvent {
    pub sender: Id,
    pub key: Option<Key>,
    pub state: KeyState,
    pub text: Option<Text>,
    pub pos: Vec2<Coord>,
    pub mods: Mods,
    pub raw: u8,
}

/// Pointer motion event.
#[derive(Clone, Copy, Debug)]
pub struct MotionEvent {
    pub sender: Id,
    pub state: MotionState,
    pub pos: Vec2<Coord>,
    pub mods: Mods,
}

/// Resize event.
#[derive(Clone, Copy, Debug)]
pub struct ResizeEvent {
    pub sender: Id,
    pub size: Vec2<Coord>,
}

/// Signal event.
#[derive(Clone, Copy, Debug)]
pub struct SignalEvent {
    pub sender: Id,
}

/// Update event.
#[derive(Clone, Copy, Debug)]
pub struct UpdateEvent {
    pub mode: RunMode,
}

/// Mouse wheel event.
#[derive(Clone, Copy, Debug)]
pub struct WheelEvent {
    pub sender: Id,
    pub dir: WheelDir,
    pub pos: Vec2<Coord>,
    pub mods: Mods,
}