Struct launchy::CanvasLayout

pub struct CanvasLayout<'a> { /* fields omitted */ }

Imagine this - you have multiple launchpads, you line them up, and now you use the Launchpads as if they were a single device?! You can do that, with CanvasLayout.

Create a layout, add Canvases to it at the position where they appear on your table, and you're ready to rock!

Example:

let mut canvas_layout = CanvasLayout::new(|msg| println!("Got a message: {:?}", msg));
 
// Assuming you have a Launchpad MK2 and a Launchpad S lying next to it:
canvas_layout.add_by_guess::<launchy::mk2::Canvas>(0, 0);
canvas_layout.add_by_guess::<launchy::s::Canvas>(9, 0);
 
// Light the entire canvas layout red - i.e. both Launchpads will be red
for button in canvas_layout.iter() {
	button.set(&mut canvas_layout, launchy::Color::RED);
}

Implementations

impl<'a> CanvasLayout<'a>

pub fn new(callback: impl Fn(CanvasMessage) + Send + Sync + 'static) -> Self

Create a new CanvasLayout that sends messages to the provided callback. The callback must implement Fn because it may be called from multiple devices concurrently.

pub fn new_polling() -> (Self, CanvasLayoutPoller)

Create a new CanvasLayout, plus an input handler object that you can use to poll messages.

pub fn light_threshold(&self) -> f32

pub fn set_light_threshold(&mut self, value: f32)

pub fn add<C: 'a + Canvas, F, E>(
    &mut self,
    x_offset: u32,
    y_offset: u32,
    rotation: Rotation,
    creator: F
) -> Result<(), E> where
    F: FnOnce(Box<dyn Fn(CanvasMessage) + Send + Sync + 'static>) -> Result<C, E>, 

Add a new device to this canvas layout, at the specified x and y coordinate.

The usage of this method is a bit awkward out of necessity. You need to provide a closure which, when called with a message callback, is expected to return a Canvas that is set up to deliver messsages to the provided message callback.

The Result which the closure returns will be propagated.

Example:

canvas_layout.add(0, 0, |callback| launchy::mk2::Canvas::guess(callback))?;
 
// or even nested layouts:
canvas_layout.add(0, 0, |callback| {
	let mut inner_canvas_layout = CanvasLayout::new(callback);
	inner_canvas_layout.add(0, 0, |inner_callback| launchy::mk2::Canvas::guess(inner_callback))
})?;

If you want an easier way to add simple devices, see add_by_guess.

pub fn add_by_guess<E: 'a + DeviceCanvasTrait>(
    &mut self,
    x: u32,
    y: u32
) -> Result<(), MidiError>

Add a new device to this canvas, at the specified x and y coordinates. The MIDI connections used for communication with the underlying hardware are determined by guessing based on the device name.

Specifiy the type of device using a generic Canvas type parameter.

Example

// Assuming a Launchpad MK2 and a Launchpad S next to it:
canvas_layout.add_by_guess::<launchy::mk2::Canvas>(0, 0);
canvas_layout.add_by_guess::<launchy::s::Canvas>(9, 0);

pub fn add_by_guess_rotated<E: 'a + DeviceCanvasTrait>(
    &mut self,
    x: u32,
    y: u32,
    rotation: Rotation
) -> Result<(), MidiError>

Like add_by_guess, but with a parameter for the rotation of the Launchpad.

Trait Implementations

impl<'_> Canvas for CanvasLayout<'_>

fn lowest_visible_brightness(&self) -> f32

The lowest visible brightness on this canvas. Used to calibrate brightness across Launchpads; users of the library probably don't need to worry about this

fn bounding_box_width(&self) -> u32

The width of the smallest rectangle that still fully encapsulates the shape of this canvas

fn bounding_box_height(&self) -> u32

The height of the smallest rectangle that still fully encapsulates the shape of this canvas

fn is_valid(&self, x: u32, y: u32) -> bool

Check if the location is in bounds

fn get_new_unchecked_ref(&self, x: u32, y: u32) -> &Color

Returns a reference to the in-buffer/unflushed color at the given position. No bounds checking

fn get_new_unchecked_mut(&mut self, x: u32, y: u32) -> &mut Color

Returns a mutable reference to the color at the given position. No bounds checking

fn get_old_unchecked_ref(&self, x: u32, y: u32) -> &Color

Returns a reference to the color at the given position. No bounds checking

fn flush(&mut self) -> Result<(), MidiError>

Flush the accumulated changes to the underlying device

fn get(&self, pad: Pad) -> Option<Color>

Returns the currently displayed color at the given position, or None if out of bounds

fn get_old_unchecked(&self, x: u32, y: u32) -> Color

Returns the color at the given position. No bounds checking

fn get_new_unchecked(&self, x: u32, y: u32) -> Color

Returns the in-buffer/unflushed color at the given position. No bounds checking

fn set_unchecked(&mut self, x: u32, y: u32, color: Color)

Set the color at the given position. No bounds checking

fn get_ref(&self, pad: Pad) -> Option<&Color>

Returns a reference to the color at the given position, or None if out of bounds

fn get_mut(&mut self, pad: Pad) -> Option<&mut Color>

Returns a mutable reference to the color at the given position, or None if out of bounds

fn get_new(&self, pad: Pad) -> Option<Color>

Returns the old, unflushed color at the given location, or None if out of bounds

fn at_new(&self, pad: Pad) -> Color

Returns the old, unflushed color at the given location. Panics if out of bounds

#[must_use]fn set(&mut self, pad: Pad, color: Color) -> Option<()>

Sets the color at the given position. Returns None if out of bounds

fn iter(&self) -> CanvasIterator

An iterator over the buttons of a given Canvas. Create an iterator by calling .iter() on a Canvas.

fn toggle(&mut self, pad: Pad, color: Color) -> Option<()>

Toggles the button at the specified coordinate with the given color.

fn clear(&mut self) where
    Self: Sized, 

Clear the entire canvas by setting all buttons to black.

fn into_padded(self) -> PaddingCanvas<Self> where
    Self: Sized, 

impl<'a> DrawTarget<Rgb888> for CanvasLayout<'a>

type Error = ()

Error type to return when a drawing operation fails.

fn draw_pixel(&mut self, pixel: Pixel<Rgb888>) -> Result<(), ()>

Draws a pixel on the display.

fn size(&self) -> Size

Returns the dimensions of the DrawTarget in pixels.

fn draw_iter<T>(&mut self, item: T) -> Result<(), Self::Error> where
    T: IntoIterator<Item = Pixel<C>>, 

Draws an object from an iterator over its pixels.

fn clear(&mut self, color: C) -> Result<(), Self::Error>

Clears the display with the supplied color.

fn draw_line(
    &mut self,
    item: &Styled<Line, PrimitiveStyle<C>>
) -> Result<(), Self::Error>

Draws a styled line primitive.

fn draw_triangle(
    &mut self,
    item: &Styled<Triangle, PrimitiveStyle<C>>
) -> Result<(), Self::Error>

Draws a styled triangle primitive.

fn draw_rectangle(
    &mut self,
    item: &Styled<Rectangle, PrimitiveStyle<C>>
) -> Result<(), Self::Error>

Draws a styled rectangle primitive.

fn draw_circle(
    &mut self,
    item: &Styled<Circle, PrimitiveStyle<C>>
) -> Result<(), Self::Error>

Draws a styled circle primitive.

fn draw_image<'b, I>(
    &mut self,
    item: &'a Image<'b, I, C>
) -> Result<(), Self::Error> where
    C: PixelColor + From<<C as PixelColor>::Raw>,
    I: ImageDimensions,
    &'b I: IntoPixelIter<C>, 

Draws an image with known size

impl<'a> Index<Pad> for CanvasLayout<'a>

type Output = Color

The returned type after indexing.

fn index(&self, pad: Pad) -> &Color

Performs the indexing (container[index]) operation.

impl<'a> IndexMut<Pad> for CanvasLayout<'a>

fn index_mut(&mut self, pad: Pad) -> &mut Color

Performs the mutable indexing (container[index]) operation.