Struct BitTile 

pub struct BitTile<const STORAGE_BYTES: usize> { /* private fields */ }

A bit tile is a 2D array of bits. It is used to store a 2D image in a compact way (where a pixel is represented by a single bit that can be either set or unset) The size of the bit tile is the STORAGE_BYTES generic parameter plus 2 bytes for the width and height. Since the width and height are stored in 2 bytes, the maximum size of the bit tile is 255 x 255 pixels. However, the STORAGE_BYTES parameter is limited to 1024 bytes, so the size of the tile should fit in this space.

Implementations

impl<const STORAGE_BYTES: usize> BitTile<STORAGE_BYTES>

pub fn new(width: u8, height: u8) -> Option<Self>

Creates a new bit tile with the specified width and height.

Arguments

• width - The width of the bit tile in pixels.
• height - The height of the bit tile in pixels.

Returns

• Some(BitTile) - If the bit tile was created successfully.
• None - If the width or height is 0 or if the bit tile does not fit in the allocated space.

pub fn width(&self) -> u8

Returns the width of the bit tile in pixels.

pub fn height(&self) -> u8

Returns the height of the bit tile in pixels.

pub fn size(&self) -> Size

Returns the size of the bit tile in pixels.

pub fn get(&self, x: u32, y: u32) -> Option<bool>

Returns the value of the pixel (set or unset) at the specified coordinates.

Arguments

• x - The x coordinate of the pixel.
• y - The y coordinate of the pixel.

Returns

• Some(bool) - If the pixel is set.
• None - If the coordinates are outside the bounds of the bit tile.

pub fn set(&mut self, x: u32, y: u32, value: bool)

Sets the value of the pixel (set or unset) at the specified coordinates. If the coordinates are outside the bounds of the bit tile, the operation is silently ignored.

Arguments

• x - The x coordinate of the pixel.
• y - The y coordinate of the pixel.
• value - The value of the pixel (set or unset).

pub fn clear(&mut self, value: bool)

Clears the bit tile by setting all pixels to the specified value.

Arguments

• value - The value to set all pixels to (set or unset).

pub fn to_string_format(&self) -> String

Returns a string representation of the bit tile in the format of:

    |...XX....XX...|
    |..XXXX..XXXX..|
    |.XXXXXXXXXXXX.|
    |.XXXXXXXXXXXX.|
    |..XXXXXXXXXX..|
    |...XXXXXXXX...|
    |....XXXXXX....|
    |.....XXXX.....|
    |......XX......|

where:

• X - a pixel that is set
• . - a pixel that is unset
• | - the start and end of a row

Returns

• String - The string representation of the bit tile.

impl BitTile<2>

pub fn from_u16(width: u8, height: u8, bits: u16) -> Option<Self>

pub fn to_u16(&self) -> u16

pub fn reset(&mut self, bits: u16)

impl BitTile<4>

pub fn from_u32(width: u8, height: u8, bits: u32) -> Option<Self>

pub fn to_u32(&self) -> u32

pub fn reset(&mut self, bits: u32)

impl BitTile<8>

pub fn from_u64(width: u8, height: u8, bits: u64) -> Option<Self>

pub fn to_u64(&self) -> u64

pub fn reset(&mut self, bits: u64)

impl BitTile<16>

pub fn from_u128(width: u8, height: u8, bits: u128) -> Option<Self>

pub fn to_u128(&self) -> u128

pub fn reset(&mut self, bits: u128)

Trait Implementations

impl<const STORAGE_BYTES: usize> Clone for BitTile<STORAGE_BYTES>

fn clone(&self) -> BitTile<STORAGE_BYTES>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<const STORAGE_BYTES: usize> Copy for BitTile<STORAGE_BYTES>

impl<const STORAGE_BYTES: usize> Debug for BitTile<STORAGE_BYTES>

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

Formats the value using the given formatter.

impl<const STORAGE_BYTES: usize> Eq for BitTile<STORAGE_BYTES>

impl<const STORAGE_BYTES: usize> FromStr for BitTile<STORAGE_BYTES>

fn from_str(image: &str) -> Result<Self, Self::Err>

Creates a new bit tile from a string. The format uses pipes (characters |) to delimit rows, and single characters to represent different colored pixels. Since a tile is basically a black and white image, the characters used to represent the pixels are:

• (space), . (point) - unset pixels
• everything else - set pixels

For example, the following string will create a bit tile with a width of 14 and a height of 9:

use appcui::prelude::*;
use std::str::FromStr;
     
const HEART_TILE: &str = r#"
    |...rr....rr...|
    |..rrrr..rrrr..|
    |.rrrrrrrrrrrr.|
    |.rrrrrrrrrrrr.|
    |..rrrrrrrrrr..|
    |   rrrrrrrr   |
    |....rrrrrr....|
    |.....rrrr.....|
    |......rr......|
"#;

// use 16 bytes to store the bit tile (14 x 9 = 126 pixels)
// a BitTile<16> implies 16 bytes x 8 bits/byte = 128 bits (128 pixels) maximum storage capacity.
// since 14 x 9 = 126 pixels, this is well within the maximum storage capacity.
let bit_tile: BitTile<16> = BitTile::from_str(HEART_TILE).unwrap();

Arguments

• image - The string to create the bit tile from.

Returns

• Ok(BitTile) - If the bit tile was created successfully.
• Err(StringFormatError) - If the string is not a valid bit tile.

type Err = StringFormatError

The associated error which can be returned from parsing.

impl<const STORAGE_BYTES: usize> PartialEq for BitTile<STORAGE_BYTES>

fn eq(&self, other: &BitTile<STORAGE_BYTES>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<const STORAGE_BYTES: usize> StructuralPartialEq for BitTile<STORAGE_BYTES>