Struct Layers

pub struct Layers<IMG> { /* private fields */ }

An ordered collection of Layers. There is always one active layer.

Implementations

impl<IMG: Bitmap> Layers<IMG>

pub fn new(size: Size<i32>) -> Self

Creates a new set of layers

pub fn active(&self) -> &Layer<IMG>

Get the active Layer

pub fn active_index(&self) -> usize

Get the index of the active Layer

pub fn count(&self) -> usize

Get the number of Layers

pub fn canvas_at(&self, index: usize) -> &Canvas<IMG>

Get the Canvas of the Layer at the specified index

pub fn active_canvas(&self) -> &Canvas<IMG>

Get the Canvas of the active Layer

pub fn get(&self, index: usize) -> &Layer<IMG>

Get a Layer by its index

pub fn blended(&self) -> IMG

Get an image of all the Layers blended together

pub fn blended_area(&self, r: Rect<i32>) -> IMG

Get an image of an area (determined by a rectangle) of all Layers blended together

pub fn get_mut(&mut self, index: usize) -> &mut Layer<IMG>

Get a mutable reference to a Layer by its index

pub fn canvas_at_mut(&mut self, index: usize) -> &mut Canvas<IMG>

Get a mutable reference to the Canvas of the Layer at a certain index

pub fn active_canvas_mut(&mut self) -> &mut Canvas<IMG>

Get a mutable reference to the Canvas of the active Layer

pub fn resize_all(&mut self, size: Size<i32>) -> Vec<IMG>

Resize all Layers, returning the images that were there before the resizing (used for undoing)

pub fn switch_to(&mut self, index: usize)

Set the active Layer to the specified index

pub fn add_new_above(&mut self)

Add a new Layer above all layers

pub fn add_at(&mut self, index: usize, layer: Layer<IMG>)

Add a new Layer at the specified index

pub fn delete(&mut self, index: usize) -> Layer<IMG>

Delete the Layer at the specified index

pub fn set_visibility(&mut self, index: usize, visible: bool)

Set whether the Layer at the specified index is visible or not

pub fn set_opacity(&mut self, index: usize, opacity: u8)

Set the opacity (alpha) of the Layer at the specified index

pub fn swap(&mut self, first: usize, second: usize)

Swap the positions of two Layers

pub fn visible_pixel(&self, p: Point<i32>) -> Color

Get the color of the visible pixel at a certain Point in the canvas, considering the blended result of all layers with their visibility and opacity settings

Trait Implementations

impl<IMG: Debug> Debug for Layers<IMG>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de, IMG> Deserialize<'de> for Layers<IMG>

where IMG: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<IMG> Serialize for Layers<IMG>

where IMG: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.