gled-ui 2.34.0

gled's egui interface, shared by the desktop app and the browser
Documentation 
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
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184

use gled_model::asset::midi_controller::{
    MidiEffectTarget, MidiEncoder, MidiInputAction, MidiInputActionKind, MidiSceneTarget,
};

pub(super) fn input_action_from_kind(
    kind: MidiInputActionKind,
    current: MidiInputAction,
) -> MidiInputAction {
    match kind {
        MidiInputActionKind::Tap => MidiInputAction::Tap,
        MidiInputActionKind::SetMainDimmer => MidiInputAction::SetMainDimmer,
        MidiInputActionKind::SetMainDimmerRelative => MidiInputAction::SetMainDimmerRelative {
            encoder: current_encoder_from_action(&current),
        },
        MidiInputActionKind::SetBlackout => MidiInputAction::SetBlackout,
        MidiInputActionKind::ToggleBlackout => MidiInputAction::ToggleBlackout,
        MidiInputActionKind::SetSpeedAdd => MidiInputAction::SetSpeedAdd,
        MidiInputActionKind::SetSpeedMultiply => MidiInputAction::SetSpeedMultiply,
        MidiInputActionKind::SetSpeedRelative => MidiInputAction::SetSpeedRelative {
            encoder: current_encoder_from_action(&current),
        },
        MidiInputActionKind::SelectSceneDistributed => MidiInputAction::SelectSceneDistributed,
        MidiInputActionKind::SelectSceneRelative => MidiInputAction::SelectSceneRelative {
            encoder: current_encoder_from_action(&current),
        },
        MidiInputActionKind::SelectSceneRow => MidiInputAction::SelectSceneRow {
            encoder: current_encoder_from_action(&current),
        },
        MidiInputActionKind::SelectSceneColumn => MidiInputAction::SelectSceneColumn {
            encoder: current_encoder_from_action(&current),
        },
        MidiInputActionKind::SelectSceneEffect => MidiInputAction::SelectSceneEffect {
            index: match current {
                MidiInputAction::SelectSceneEffect { index } => index,
                _ => 0,
            },
        },
        MidiInputActionKind::SelectSceneEffectRelative => {
            MidiInputAction::SelectSceneEffectRelative {
                encoder: current_encoder_from_action(&current),
            }
        }
        MidiInputActionKind::SelectSceneEffectDistributed => {
            MidiInputAction::SelectSceneEffectDistributed
        }
        MidiInputActionKind::SelectMode => MidiInputAction::SelectMode {
            mode: match current {
                MidiInputAction::SelectMode { mode } => mode,
                _ => 0,
            },
        },
        MidiInputActionKind::SelectScene => MidiInputAction::SelectScene {
            target: current_target_from_action(&current),
        },
        MidiInputActionKind::ToggleSceneActive => MidiInputAction::ToggleSceneActive {
            target: current_target_from_action(&current),
        },
        MidiInputActionKind::SetSceneActive => MidiInputAction::SetSceneActive {
            target: current_target_from_action(&current),
        },
        MidiInputActionKind::FlashScene => MidiInputAction::FlashScene {
            target: current_target_from_action(&current),
        },
        MidiInputActionKind::SetSceneOpacity => MidiInputAction::SetSceneOpacity {
            target: current_target_from_action(&current),
        },
        MidiInputActionKind::SetSceneInputDimmer => MidiInputAction::SetSceneInputDimmer {
            target: current_target_from_action(&current),
        },
        MidiInputActionKind::SetSceneBeatOffset => MidiInputAction::SetSceneBeatOffset {
            target: current_target_from_action(&current),
        },
        MidiInputActionKind::SetSceneIgnoreMainDimmer => {
            MidiInputAction::SetSceneIgnoreMainDimmer {
                target: current_target_from_action(&current),
            }
        }
        MidiInputActionKind::SetSceneSetOffsetOnFlash => {
            MidiInputAction::SetSceneSetOffsetOnFlash {
                target: current_target_from_action(&current),
            }
        }
        MidiInputActionKind::SetSceneEffectSettingF32 => {
            let setting_index = match &current {
                MidiInputAction::SetSceneEffectSettingF32 { setting_index, .. } => *setting_index,
                _ => 0,
            };
            MidiInputAction::SetSceneEffectSettingF32 {
                target: current_target_from_action(&current),
                effect: current_effect_from_action(&current),
                setting_index,
            }
        }
        MidiInputActionKind::SetSceneEffectOpacity => {
            let effect = current_effect_from_action(&current);
            MidiInputAction::SetSceneEffectOpacity {
                target: current_target_from_action(&current),
                effect,
            }
        }
        MidiInputActionKind::SetSceneEffectColorShift => {
            let effect = current_effect_from_action(&current);
            MidiInputAction::SetSceneEffectColorShift {
                target: current_target_from_action(&current),
                effect,
            }
        }
        MidiInputActionKind::SetSceneEffectBeatProgression => {
            let effect = current_effect_from_action(&current);
            MidiInputAction::SetSceneEffectBeatProgression {
                target: current_target_from_action(&current),
                effect,
            }
        }
        MidiInputActionKind::SetSceneEffectBeatOffset => {
            let effect = current_effect_from_action(&current);
            MidiInputAction::SetSceneEffectBeatOffset {
                target: current_target_from_action(&current),
                effect,
            }
        }
        MidiInputActionKind::SetSceneEffectSpeedExponent => {
            let effect = current_effect_from_action(&current);
            MidiInputAction::SetSceneEffectSpeedExponent {
                target: current_target_from_action(&current),
                effect,
            }
        }
        MidiInputActionKind::SetSceneEffectLayout => {
            let effect = current_effect_from_action(&current);
            MidiInputAction::SetSceneEffectLayout {
                target: current_target_from_action(&current),
                effect,
            }
        }
    }
}

fn current_target_from_action(action: &MidiInputAction) -> MidiSceneTarget {
    match action {
        MidiInputAction::SelectScene { target }
        | MidiInputAction::ToggleSceneActive { target }
        | MidiInputAction::SetSceneActive { target }
        | MidiInputAction::FlashScene { target }
        | MidiInputAction::SetSceneOpacity { target }
        | MidiInputAction::SetSceneInputDimmer { target }
        | MidiInputAction::SetSceneBeatOffset { target }
        | MidiInputAction::SetSceneIgnoreMainDimmer { target }
        | MidiInputAction::SetSceneSetOffsetOnFlash { target }
        | MidiInputAction::SetSceneEffectSettingF32 { target, .. }
        | MidiInputAction::SetSceneEffectOpacity { target, .. }
        | MidiInputAction::SetSceneEffectColorShift { target, .. }
        | MidiInputAction::SetSceneEffectBeatProgression { target, .. }
        | MidiInputAction::SetSceneEffectBeatOffset { target, .. }
        | MidiInputAction::SetSceneEffectSpeedExponent { target, .. }
        | MidiInputAction::SetSceneEffectLayout { target, .. } => target.clone(),
        _ => MidiSceneTarget::Selected,
    }
}

fn current_effect_from_action(action: &MidiInputAction) -> MidiEffectTarget {
    match action {
        MidiInputAction::SetSceneEffectSettingF32 { effect, .. }
        | MidiInputAction::SetSceneEffectOpacity { effect, .. }
        | MidiInputAction::SetSceneEffectColorShift { effect, .. }
        | MidiInputAction::SetSceneEffectBeatProgression { effect, .. }
        | MidiInputAction::SetSceneEffectBeatOffset { effect, .. }
        | MidiInputAction::SetSceneEffectSpeedExponent { effect, .. }
        | MidiInputAction::SetSceneEffectLayout { effect, .. } => *effect,
        _ => MidiEffectTarget::Selected,
    }
}

fn current_encoder_from_action(action: &MidiInputAction) -> MidiEncoder {
    match action {
        MidiInputAction::SetMainDimmerRelative { encoder }
        | MidiInputAction::SetSpeedRelative { encoder }
        | MidiInputAction::SelectSceneRelative { encoder }
        | MidiInputAction::SelectSceneRow { encoder }
        | MidiInputAction::SelectSceneColumn { encoder }
        | MidiInputAction::SelectSceneEffectRelative { encoder } => *encoder,
        _ => MidiEncoder::default(),
    }
}