iced_audio 0.13.0

mod style;
mod util;

use iced::widget::{checkbox, column, container, row, text};
use iced::{Alignment, Element, Length, Result, Size, application};

use iced_audio::{
    FloatRange, HSlider, Knob, ModRangeInput, ModulationRange, Normal, NormalParam, VSlider,
};
use util::info_text;

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

/// Unique identifier for each parameter. Note you may also use u32, i32, or
/// Strings if you wish.
#[derive(Debug, Copy, Clone)]
pub enum ModRangesID {}

#[derive(Debug, Clone)]
pub enum Message {
    RangeStart(Normal),
    RangeEnd(Normal),
    Knob1(Normal),
    HSlider1(Normal),
    VSlider1(Normal),
    ModKnob1(Normal),
    ModKnob2(Normal),
    ModRangeInput1(Normal),
    ModRangeInput2(Normal),
    ToggleModRange(bool),
}

pub struct ModRangeExample {
    float_range: FloatRange,
    float_range_bipolar: FloatRange,

    knob_start_param: NormalParam,
    knob_end_param: NormalParam,

    knob1_param: NormalParam,
    h_slider1_param: NormalParam,
    v_slider1_param: NormalParam,
    mod_range_1: ModulationRange,

    auto_input1_param: NormalParam,
    knob_auto1_param: NormalParam,
    knob_auto1_mod_range: ModulationRange,

    auto_input2_param: NormalParam,
    knob_auto2_param: NormalParam,
    knob_auto2_mod_range: ModulationRange,

    show_modulation: bool,

    output_text: String,
}

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

        let float_range = FloatRange::default();
        let float_range_bipolar = FloatRange::default_bipolar();

        // create application

        Self {
            float_range,
            float_range_bipolar,

            // initialize the state of the Knob widget
            knob_start_param: float_range.default_normal_param(),
            knob_end_param: float_range.default_normal_param(),

            mod_range_1: ModulationRange::default(),

            knob1_param: float_range.default_normal_param(),

            h_slider1_param: float_range.default_normal_param(),

            v_slider1_param: float_range.default_normal_param(),

            auto_input1_param: float_range_bipolar.default_normal_param(),

            knob_auto1_param: float_range.default_normal_param(),
            auto_input2_param: float_range_bipolar.default_normal_param(),
            knob_auto1_mod_range: ModulationRange::default(),

            knob_auto2_param: float_range.default_normal_param(),
            output_text: String::from("Move a widget"),
            knob_auto2_mod_range: ModulationRange::default(),

            show_modulation: true,
        }
    }
}

impl ModRangeExample {
    pub fn title(&self) -> &str {
        "Modulation Ranges"
    }

    pub fn update(&mut self, message: Message) {
        match message {
            Message::RangeStart(normal) => {
                self.knob_start_param.update(normal);

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

                self.mod_range_1.start = normal;
            }
            Message::RangeEnd(normal) => {
                self.knob_end_param.update(normal);

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

                self.mod_range_1.end = normal;
            }
            Message::Knob1(normal) => {
                self.knob1_param.update(normal);

                self.output_text =
                    info_text::info_text_f32("Knob1", self.float_range.unmap_to_value(normal));
            }
            Message::HSlider1(normal) => {
                self.h_slider1_param.update(normal);

                self.output_text =
                    info_text::info_text_f32("HSlider1", self.float_range.unmap_to_value(normal));
            }
            Message::VSlider1(normal) => {
                self.v_slider1_param.value = normal;

                self.output_text =
                    info_text::info_text_f32("VSlider1", self.float_range.unmap_to_value(normal));
            }
            Message::ModKnob1(normal) => {
                self.knob_auto1_param.update(normal);

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

                let mod_value = self
                    .float_range_bipolar
                    .unmap_to_value(self.auto_input1_param.value);

                self.knob_auto1_mod_range.start = normal;
                self.knob_auto1_mod_range
                    .end
                    .set_clipped(self.knob_auto1_mod_range.start.as_f32() + mod_value);
            }
            Message::ModRangeInput1(normal) => {
                self.auto_input1_param.update(normal);

                let value = self.float_range_bipolar.unmap_to_value(normal);

                self.output_text = info_text::info_text_f32("ModRangeInput1", value);

                self.knob_auto1_mod_range
                    .end
                    .set_clipped(self.knob_auto1_param.value.as_f32() + value);
            }
            Message::ModKnob2(normal) => {
                self.knob_auto2_param.update(normal);

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

                let mod_value = self
                    .float_range_bipolar
                    .unmap_to_value(self.auto_input2_param.value);

                self.knob_auto2_mod_range.start = normal;
                self.knob_auto2_mod_range
                    .end
                    .set_clipped(self.knob_auto2_mod_range.start.as_f32() + mod_value);
            }
            Message::ModRangeInput2(normal) => {
                self.auto_input2_param.update(normal);

                let value = self.float_range_bipolar.unmap_to_value(normal);

                self.output_text = info_text::info_text_f32("ModRangeInput1", value);

                self.knob_auto2_mod_range
                    .end
                    .set_clipped(self.knob_auto2_param.value.as_f32() + value);
            }
            Message::ToggleModRange(toggle) => {
                self.show_modulation = toggle;

                self.mod_range_1.filled_visible = toggle;
                self.knob_auto1_mod_range.filled_visible = toggle;
                self.knob_auto2_mod_range.filled_visible = toggle;
            }
        }
    }

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

        let knob_start = Knob::new(self.knob_start_param, Message::RangeStart);
        let knob_end = Knob::new(self.knob_end_param, Message::RangeEnd);

        let mod_range_1 = self.show_modulation.then_some(&self.mod_range_1);

        let knob1 = Knob::new(self.knob1_param, Message::Knob1)
            .mod_range(mod_range_1)
            .style(style::knob::CustomArc);

        let h_slider1 = HSlider::new(self.h_slider1_param, Message::HSlider1)
            .mod_range(mod_range_1)
            .style(style::h_slider::RectStyle);

        let v_slider1 = VSlider::new(self.v_slider1_param, Message::VSlider1)
            .width(Length::Fixed(30.0))
            .mod_range(mod_range_1)
            .style(style::v_slider::RectStyle);

        let auto_input1 = ModRangeInput::new(self.auto_input1_param, Message::ModRangeInput1)
            .size(Length::from(10))
            .style(style::mod_range_input::CustomStyle)
            .enabled(self.show_modulation);

        let knob_auto1 = Knob::new(self.knob_auto1_param, Message::ModKnob1)
            .mod_range(self.show_modulation.then_some(&self.knob_auto1_mod_range))
            .style(style::knob::CustomStyleCircle);

        let auto_input2 = ModRangeInput::new(self.auto_input2_param, Message::ModRangeInput2)
            .size(Length::from(15))
            .style(iced_audio::mod_range_input::InvisibleStyle)
            .enabled(self.show_modulation);

        let knob_auto2 = Knob::new(self.knob_auto2_param, Message::ModKnob2)
            .mod_range(self.show_modulation.then_some(&self.knob_auto2_mod_range))
            .style(style::knob::CustomStyleCircle);

        // push the widgets into rows
        let knob_row = row![
            column![
                column![text("Range Start"), knob_start].spacing(8),
                column![text("Range End"), knob_end].spacing(8),
                checkbox(self.show_modulation)
                    .label("Show Modulation")
                    .on_toggle(Message::ToggleModRange),
            ]
            .max_width(130)
            .spacing(16),
            container(
                column![knob1, h_slider1, v_slider1]
                    .max_width(130)
                    .align_x(Alignment::Center)
                    .spacing(20)
            )
            .max_height(250),
            column![
                column![
                    text("Custom Style with ModRangeInput"),
                    column![auto_input1, knob_auto1]
                        .spacing(12)
                        .align_x(Alignment::Center)
                ]
                .width(Length::Fill)
                .spacing(8)
                .align_x(Alignment::Center),
                column![
                    text("Custom Style with invisible ModRangeInput"),
                    column![auto_input2, knob_auto2]
                        .spacing(0)
                        .align_x(Alignment::Center)
                ]
                .width(Length::Fill)
                .spacing(8)
                .align_x(Alignment::Center)
            ]
            .width(Length::Fill)
            .spacing(16),
        ]
        .spacing(16);

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