Struct launchy::PaddingCanvas

pub struct PaddingCanvas<C: Canvas> { /* fields omitted */ }

A canvas wrapper that fills holes and other irregularities to provide a perfectly rectangular grid.

Launchpads traditionally have non-rectangular shapes:

• Most Launchpads are almost 9x9 - just one pixel is missing
• The Launchpad Pro is almost 10x10, except each corner has a pixel missing
• The Launch Control has an even more irregular placement if the four control buttons are included

Or, even worse, when having a multi-Launchpad setup using CanvasLayout - that's even less rectangular; there will be gaps and empty spaces all over the place.

Sometimes it's a pain to deal with those irregular shapes. For that reason, this struct provides a Canvas wrapper that inserts 'virtual pixels' into all the gaps so that you can work with the Launchpad as if it were a perfectly rectangular grid.

Example:

// Create the base canvas
let mut canvas = launchy::mk2::Canvas::guess(|msg| {});
 
// Wrap the holey canvas in `PaddingCanvas`
let mut canvas = launchy::PaddingCanvas::from(canvas);
 
// Now you can fearlessly work with the canvas as if it's a rectangle
for y in 0..9 {
	for x in 0..9 {
		canvas.set(x, y, launchy::Color::WHITE);
	}
}

Implementations

impl<C: Canvas> PaddingCanvas<C>

pub fn from(inner: C) -> Self

Wrap the given canvas in a PaddingCanvas

Trait Implementations

impl<C: Canvas> Canvas for PaddingCanvas<C>

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 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 is_valid(&self, x: u32, y: u32) -> bool

Check if the location is in bounds

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 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 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<C: Canvas> DrawTarget<Rgb888> for PaddingCanvas<C>

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<C: Canvas> Index<Pad> for PaddingCanvas<C>

type Output = Color

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<C: Canvas> IndexMut<Pad> for PaddingCanvas<C>

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

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