Struct conrod::EnvelopeEditor

pub struct EnvelopeEditor<'a, E: 'a, F> where E: EnvelopePoint {
    // some fields omitted
}

Used for editing a series of 2D Points on a cartesian (X, Y) plane within some given range. Useful for things such as oscillator/automation envelopes or any value series represented periodically.

Methods

impl<'a, E, F> EnvelopeEditor<'a, E, F> where E: EnvelopePoint

fn point_radius(self, radius: f64) -> EnvelopeEditor<'a, E, F>

Set the radius of the envelope point circle.

fn line_width(self, width: f64) -> EnvelopeEditor<'a, E, F>

Set the width of the envelope lines.

fn value_font_size(self, size: FontSize) -> EnvelopeEditor<'a, E, F>

Set the font size for the displayed values.

fn skew_y(self, skew: f32) -> EnvelopeEditor<'a, E, F>

Set the value skewing for the envelope's y-axis. This is useful for displaying exponential ranges such as frequency.

fn new(env: &'a mut Vec<E>, min_x: E::X, max_x: E::X, min_y: E::Y, max_y: E::Y) -> EnvelopeEditor<'a, E, F>

Construct an EnvelopeEditor widget.

fn react(self, reaction: F) -> EnvelopeEditor<'a, E, F>

Set the reaction for the EnvelopeEditor.

fn enabled(self, flag: bool) -> Self

If true, will allow user inputs. If false, will disallow user inputs.

Trait Implementations

impl<'a, E, F> Widget for EnvelopeEditor<'a, E, F> where E: EnvelopePoint, E::X: Any, E::Y: Any, F: FnMut(&mut Vec<E>, usize)

type State = State<E>

State to be stored within the Uis widget cache. Take advantage of this type for any large allocations that you would like to avoid repeating between updates, or any calculations that you'd like to avoid repeating between calls to update and draw. Conrod will never clone the state, it will only ever be moved.

type Style = Style

Styling used by the widget to construct an Element. Styling is useful to have in its own abstraction in order to making Theme serializing easier. Conrod doesn't yet support serializing non-internal widget styling with the Theme type, but we hope to soon.

fn common(&self) -> &CommonBuilder

Return a reference to a CommonBuilder struct owned by the Widget. This method allows us to do a blanket impl of Positionable and Sizeable for T: Widget.

fn common_mut(&mut self) -> &mut CommonBuilder

Return a mutable reference to a CommonBuilder struct owned by the Widget. This method allows us to do a blanket impl of Positionable and Sizeable for T: Widget.

fn unique_kind(&self) -> &'static str

Return the kind of the widget as a &'static str. Note that this must be unique from all other widgets' "unique kinds". This is used by conrod to help avoid WidgetId errors and to provide better messages for those that do occur.

fn init_state(&self) -> State<E>

Return the initial State of the Widget. The Ui will only call this once.

fn style(&self) -> Style

Return the styling of the widget. The Ui will call this once prior to each update. It does this so that it can check for differences in Style in case a new Element needs to be constructed.

fn default_width<C: CharacterCache>(&self, theme: &Theme, _: &GlyphCache<C>) -> Scalar

The default width of the widget. A reference to the GlyphCache is provided in case the width should adjust to some text len. This method is only used if no width or dimensions are given.

fn default_height(&self, theme: &Theme) -> Scalar

The default height of the widget. This method is only used if no height or dimensions are given.

fn capture_mouse(prev: &State<E>, new: &State<E>) -> bool

Optionally override with the case that the widget should capture the mouse.

fn uncapture_mouse(prev: &State<E>, new: &State<E>) -> bool

Optionally override with the case that the widget should capture the mouse.

fn update<'b, 'c, C>(self, args: UpdateArgs<'b, 'c, Self, C>) -> Option<State<E>> where C: CharacterCache

Update the state of the EnvelopeEditor's cached state.

fn draw<'b, C>(args: DrawArgs<'b, Self, C>) -> Element where C: CharacterCache

Construct an Element from the given EnvelopeEditor State.

fn default_position(&self, _theme: &Theme) -> Position

The default Position for the widget. This is used when no Position is explicitly given when instantiating the Widget.

fn default_h_align(&self, theme: &Theme) -> HorizontalAlign

The default horizontal alignment for the widget. This is used when no HorizontalAlign is explicitly given when instantiating a Widget.

fn default_v_align(&self, theme: &Theme) -> VerticalAlign

The default vertical alignment for the widget. This is used when no VerticalAlign is explicitly given when instantiating a Widget.

fn capture_keyboard(_prev: &Self::State, _new: &Self::State) -> bool

Optionally override with the case that the widget should capture the mouse.

fn uncapture_keyboard(_prev: &Self::State, _new: &Self::State) -> bool

Optionally override with the case that the widget should capture the mouse.

fn drag_area(&self, _dim: Dimensions, _style: &Self::Style, _theme: &Theme) -> Option<Area>

If the widget is draggable, implement this method and return the position an dimensions of the draggable space. The position should be relative to the center of the widget.

fn kid_area(state: &State<Self::State>, _style: &Self::Style, _theme: &Theme) -> KidArea

The area on which child widgets will be placed when using the Place Position methods.

fn parent(self, maybe_parent_id: Option<WidgetId>) -> Self

Set the parent widget for this Widget by passing the WidgetId of the parent. This will attach this Widget to the parent widget.

fn floating(self, is_floating: bool) -> Self

Set whether or not the widget is floating (the default is false). A typical example of a floating widget would be a pop-up or alert window.

fn scrolling(self, scrollable: bool) -> Self

Set whether or not the widget's KidArea is scrollable (the default is false). If a widget is scrollable and it has children widgets that fall outside of its KidArea, the KidArea will become scrollable.

fn vertical_scrolling(self, scrollable: bool) -> Self

Set whether or not the widget's KidArea is scrollable (the default is false). If a widget is scrollable and it has children widgets that fall outside of its KidArea, the KidArea will become scrollable.

fn horizontal_scrolling(self, scrollable: bool) -> Self

Set whether or not the widget's KidArea is scrollable (the default is false). If a widget is scrollable and it has children widgets that fall outside of its KidArea, the KidArea will become scrollable.

fn set_children<C>(_id: WidgetId, _state: &State<Self::State>, _style: &Self::Style, _ui: &mut Ui<C>) where C: CharacterCache

An optionally overridable method for setting child widgets. This will be called immediately after the widget itself is updated. NOTE: The API for this will probably changed somehow, as there is probably a nicer way to do this than give the widget designer mutable access to the entire Ui.

fn set<C>(self, id: WidgetId, ui: &mut Ui<C>) where C: CharacterCache

Note: There should be no need to override this method.

impl<'a, E, F> Colorable for EnvelopeEditor<'a, E, F> where E: EnvelopePoint

fn color(self, color: Color) -> Self

Set the color of the widget.

fn rgba(self, r: f32, g: f32, b: f32, a: f32) -> Self

Set the color of the widget from rgba values.

fn rgb(self, r: f32, g: f32, b: f32) -> Self

Set the color of the widget from rgb values.

fn hsla(self, h: f32, s: f32, l: f32, a: f32) -> Self

Set the color of the widget from hsla values.

fn hsl(self, h: f32, s: f32, l: f32) -> Self

Set the color of the widget from hsl values.

impl<'a, E, F> Frameable for EnvelopeEditor<'a, E, F> where E: EnvelopePoint

fn frame(self, width: f64) -> Self

Set the width of the widget's frame.

fn frame_color(self, color: Color) -> Self

Set the color of the widget's frame.

fn frame_rgba(self, r: f32, g: f32, b: f32, a: f32) -> Self

Set the color of the widget's frame with rgba values.

fn frame_rgb(self, r: f32, g: f32, b: f32) -> Self

Set the color of the widget's frame with rgb values.

fn frame_hsla(self, h: f32, s: f32, l: f32, a: f32) -> Self

Set the color of the widget's frame with hsla values.

fn frame_hsl(self, h: f32, s: f32, l: f32) -> Self

Set the color of the widget's frame with hsl values.

impl<'a, E, F> Labelable<'a> for EnvelopeEditor<'a, E, F> where E: EnvelopePoint

fn label(self, text: &'a str) -> Self

Set the label for the widget.

fn label_color(self, color: Color) -> Self

Set the color of the widget's label.

fn label_font_size(self, size: FontSize) -> Self

Set the font size for the widget's label.

fn label_rgba(self, r: f32, g: f32, b: f32, a: f32) -> Self

Set the color of the widget's label from rgba values.

fn label_rgb(self, r: f32, g: f32, b: f32) -> Self

Set the color of the widget's label from rgb values.

fn label_hsla(self, h: f32, s: f32, l: f32, a: f32) -> Self

Set the color of the widget's label from hsla values.

fn label_hsl(self, h: f32, s: f32, l: f32) -> Self

Set the color of the widget's label from hsl values.

fn small_font<C>(self, ui: &Ui<C>) -> Self

Set a "small" font size for the widget's label.

fn medium_font<C>(self, ui: &Ui<C>) -> Self

Set a "medium" font size for the widget's label.

fn large_font<C>(self, ui: &Ui<C>) -> Self

Set a "large" font size for the widget's label.