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

#![deny(missing_docs, missing_debug_implementations)]
//! MIDI-related types, [`Element`]s and
//! [`Composition`](redact_composer_core::Composition) output converter.

/// Midi converter for [`Composition`](redact_composer_core::Composition) output.
pub mod convert;

/// General Midi Level 1 types and elements.
pub mod gm;

use redact_composer_core::derive::Element;
use redact_composer_core::render::{AdhocRenderer, RenderEngine, Renderer};
use redact_composer_core::IntoCompositionSegment;

#[cfg(feature = "serde")]
use serde::{Deserialize, Serialize};

/// Elements implementing [`Element`].
pub mod elements {
    pub use super::{DrumKit, Program};
}

/// The renderers for [`Element`]s of this
/// module.
pub fn renderers() -> RenderEngine {
    RenderEngine::new() + DrumKit::renderer() + gm::renderers()
}

/// A program number (instrument) that should play during a
/// [`Part`](redact_composer_core::elements::Part).
#[derive(Element, Debug)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
pub struct Program(pub u8);

/// A semantic wrapper for program number indicating a drum instrument.
#[derive(Element, Debug, Copy, Clone)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
pub struct DrumKit(pub u8);

impl DrumKit {
    /// Default [`DrumKit`] renderer. Simply converts it into a [`Program`].
    pub fn renderer() -> impl Renderer<Element = Self> {
        AdhocRenderer::<Self>::new(|segment, _| {
            Ok(vec![
                Program::from(segment.element).into_segment(segment.timing)
            ])
        })
    }
}

impl From<DrumKit> for Program {
    fn from(value: DrumKit) -> Self {
        Program(value.0)
    }
}

impl From<&DrumKit> for Program {
    fn from(value: &DrumKit) -> Self {
        Program(value.0)
    }
}

impl From<u8> for DrumKit {
    fn from(value: u8) -> Self {
        DrumKit(value)
    }
}

impl From<&u8> for DrumKit {
    fn from(value: &u8) -> Self {
        DrumKit(*value)
    }
}