ktrl 0.1.8

A Supercharged Keyboard Programming Daemon
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

pub mod perform;
pub use perform::perform_effect;

mod sticky;
pub use sticky::StickyState;

#[cfg(feature = "sound")]
mod dj;
#[cfg(feature = "sound")]
pub use dj::Dj;
#[cfg(feature = "sound")]
pub use dj::KSnd;

use crate::actions::Action;
use crate::keys::KeyCode;
use crate::keys::KeyEvent;
use crate::keys::KeyValue;
use crate::layers::LayerIndex;
use crate::layers::LayersManager;
use inner::inner;
use serde::Deserialize;

#[derive(Clone, Debug, PartialEq, Eq, Deserialize)]
pub enum Effect {
    NoOp,

    Key(KeyCode),
    KeySticky(KeyCode),
    KeySeq(Vec<KeyCode>),

    Meh,   // Ctrl+Alt+Shift
    Hyper, // Ctrl+Alt+Shift+Win

    ActivateProfile(String),
    DeactivateProfile(String),
    DeactivateAllProfiles,

    TurnOnLayer(LayerIndex),
    TurnOffLayer(LayerIndex),
    ToggleLayer(LayerIndex),

    TurnOnLayerAlias(String),
    TurnOffLayerAlias(String),
    ToggleLayerAlias(String),

    MomentaryLayer(LayerIndex),

    #[cfg(feature = "sound")]
    Sound(KSnd),
    #[cfg(feature = "sound")]
    SoundEx(String),

    Multi(Vec<Effect>),
    // Not Implemented Yet
    // ---------------------
    // OneShotLayer(LayerIndex),
    // OneShotModifier(KeyCode)
    // ToggleModifier(KeyCode)
}

pub fn key_event_to_fx_val(l_mgr: &LayersManager, event: &KeyEvent) -> EffectValue {
    let merged = l_mgr.get(event.code);
    let effect = inner!(&merged.action, if Action::Tap).clone();

    EffectValue {
        fx: effect,
        val: event.value.into(),
    }
}

// ------------------- Output Effects -----------------

// These are returned by action handlers.
// E.g TapHoldMgr::process

#[derive(Clone, Debug, Deserialize, PartialEq, Eq)]
pub struct EffectValue {
    pub fx: Effect,
    pub val: KeyValue,
}

impl EffectValue {
    pub fn new(fx: Effect, val: KeyValue) -> Self {
        Self { fx, val }
    }
}

pub const STOP: bool = true;
pub const CONTINUE: bool = false;

#[derive(Clone, Debug, PartialEq, Eq)]
pub struct OutEffects {
    pub stop_processing: bool,
    pub effects: Option<Vec<EffectValue>>,
}

impl OutEffects {
    pub fn new(stop_processing: bool, effect: Effect, value: KeyValue) -> Self {
        OutEffects {
            stop_processing,
            effects: Some(vec![EffectValue::new(effect, value)]),
        }
    }

    pub fn new_multiple(stop_processing: bool, effects: Vec<EffectValue>) -> Self {
        OutEffects {
            stop_processing,
            effects: Some(effects),
        }
    }

    pub fn empty(stop_processing: bool) -> Self {
        OutEffects {
            stop_processing,
            effects: None,
        }
    }

    pub fn insert(&mut self, effect: Effect, value: KeyValue) {
        if let Some(effects) = &mut self.effects {
            effects.push(EffectValue::new(effect, value));
        } else {
            self.effects = Some(vec![EffectValue::new(effect, value)]);
        }
    }
}