iced_audio 0.13.2

An extension to the Iced GUI library with useful widgets for audio applications
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

mod style;
mod util;

use iced::{
    Element, Length, Result, Size, application,
    widget::{column, row, text},
};
use iced_audio::{FloatRange, Normal, NormalParam, Ramp, ramp::RampDirection};
use util::info_text;

fn main() -> Result {
    application(RampExample::default, RampExample::update, RampExample::view)
        .window_size(Size::new(600.0, 400.0))
        .run()
}

#[derive(Debug, Clone)]
enum Message {
    DefaultUp(Normal),
    DefaultDown(Normal),
    CustomUp(Normal),
    CustomDown(Normal),
}

pub struct RampExample {
    float_range: FloatRange,

    ramp_default_up_param: NormalParam,
    ramp_default_down_param: NormalParam,
    ramp_custom_up_param: NormalParam,
    ramp_custom_down_param: NormalParam,

    output_text: String,
}

impl Default for RampExample {
    fn default() -> Self {
        // initalize parameters

        let float_range = FloatRange::default_bipolar();

        // create application

        Self {
            float_range,

            // initialize the state of the ramp widget
            ramp_default_up_param: float_range.default_normal_param(),
            ramp_default_down_param: float_range.default_normal_param(),
            ramp_custom_up_param: float_range.default_normal_param(),
            ramp_custom_down_param: float_range.default_normal_param(),

            output_text: String::new(),
        }
    }
}

impl RampExample {
    fn update(&mut self, message: Message) {
        match message {
            Message::DefaultUp(normal) => {
                self.ramp_default_up_param.update(normal);

                self.output_text =
                    info_text::info_text_f32("DefaultUp", self.float_range.unmap_to_value(normal));
            }
            Message::DefaultDown(normal) => {
                self.ramp_default_down_param.update(normal);

                self.output_text = info_text::info_text_f32(
                    "DefaultDown",
                    self.float_range.unmap_to_value(normal),
                );
            }
            Message::CustomUp(normal) => {
                self.ramp_custom_up_param.update(normal);

                self.output_text =
                    info_text::info_text_f32("CutomUp", self.float_range.unmap_to_value(normal));
            }
            Message::CustomDown(normal) => {
                self.ramp_custom_down_param.update(normal);

                self.output_text =
                    info_text::info_text_f32("CustomDown", self.float_range.unmap_to_value(normal));
            }
        }
    }

    fn view(&self) -> Element<'_, Message> {
        // create each of the Ramp widgets, passing in the value of
        // the corresponding parameter

        let ramp_default_up = Ramp::new(
            self.ramp_default_up_param,
            Message::DefaultUp,
            RampDirection::Up,
        );

        let ramp_default_down = Ramp::new(
            self.ramp_default_down_param,
            Message::DefaultDown,
            RampDirection::Down,
        );

        let ramp_custom_up = Ramp::new(
            self.ramp_custom_up_param,
            Message::CustomUp,
            RampDirection::Up,
        )
        .style(style::ramp::CustomStyle);

        let ramp_custom_down = Ramp::new(
            self.ramp_custom_down_param,
            Message::CustomDown,
            RampDirection::Down,
        )
        .style(style::ramp::CustomStyle);

        // push the widgets into rows
        let ramp_row = row![
            column![
                text("Default Style Up"),
                ramp_default_up,
                text("Default Style Down"),
                ramp_default_down,
            ]
            .width(Length::Fill)
            .spacing(10),
            column![
                text("Custom Style Up"),
                ramp_custom_up,
                text("Custom Style Down"),
                ramp_custom_down,
            ]
            .width(Length::Fill)
            .spacing(10),
        ]
        .spacing(20);

        column![ramp_row, text(&self.output_text).size(16),]
            .spacing(20)
            .padding(20)
            .into()
    }
}