[−][src]Trait embedded_graphics_core::draw_target::DrawTargetExt

pub trait DrawTargetExt: DrawTarget + Sized {
    pub fn translated(&mut self, offset: Point) -> Translated<'_, Self>;

    pub fn cropped(&mut self, area: &Rectangle) -> Cropped<'_, Self>;

    pub fn clipped(&mut self, area: &Rectangle) -> Clipped<'_, Self>;

    pub fn color_converted<C>(&mut self) -> ColorConverted<'_, Self, C>
    where
        C: PixelColor + Into<Self::Color>;
}

Extension trait for DrawTargets.

Required methods

pub fn translated(&mut self, offset: Point) -> Translated<'_, Self>[src]

Creates a translated draw target based on this draw target.

All drawing operations are translated by offset pixels, before being passed to the parent draw target.

Examples

use embedded_graphics::{
    fonts::{Font6x8, Text},
    mock_display::MockDisplay,
    pixelcolor::BinaryColor,
    prelude::*,
    style::MonoTextStyle,
};

let mut display = MockDisplay::new();
let mut translated_display = display.translated(Point::new(10, 5));

// Draws text at position (10, 5) in the display coordinate system
Text::new("Text", Point::zero())
    .into_styled(MonoTextStyle::new(Font6x8, BinaryColor::On))
    .draw(&mut translated_display)?;

pub fn cropped(&mut self, area: &Rectangle) -> Cropped<'_, Self>[src]

Creates a cropped draw target based on this draw target.

A cropped draw target is a draw target for a rectangular subregion of the parent draw target. Its coordinate system is shifted so that the origin coincides with area.top_left in the parent draw target's coordinate system.

The bounding box of the returned target will always be contained inside the bounding box of the parent target. If any of the requested area lies outside the parent target's bounding box the intersection of the parent target's bounding box and area will be used.

Drawing operations outside the bounding box will not be clipped.

Examples

use embedded_graphics::{
    fonts::{Font6x8, Text},
    mock_display::MockDisplay,
    pixelcolor::Rgb565,
    prelude::*,
    primitives::Rectangle,
    style::MonoTextStyle,
};

/// Fills a draw target with a blue background and prints centered yellow text.
fn draw_text<T>(target: &mut T, text: &str) -> Result<(), T::Error>
where
    T: DrawTarget<Color = Rgb565>,
{
    target.clear(Rgb565::BLUE)?;

    let target_size = target.bounding_box().size;
    let text_size = Font6x8::CHARACTER_SIZE.component_mul(Size::new(text.len() as u32, 1));

    let text_position = Point::zero() + (target_size - text_size) / 2;

    Text::new(text, text_position)
        .into_styled(MonoTextStyle::new(Font6x8, Rgb565::YELLOW))
        .draw(target)
}

let mut display = MockDisplay::new();
display.set_allow_overdraw(true);

let area = Rectangle::new(Point::new(5, 10), Size::new(40, 15));
let mut cropped_display = display.cropped(&area);

draw_text(&mut cropped_display, "Text")?;

pub fn clipped(&mut self, area: &Rectangle) -> Clipped<'_, Self>[src]

Creates a clipped draw target based on this draw target.

A clipped draw target is a draw target for a rectangular subregion of the parent draw target. The coordinate system of the created draw target is equal to the parent target's coordinate system. All drawing operations outside the bounding box will be clipped.

The bounding box of the returned target will always be contained inside the bounding box of the parent target. If any of the requested area lies outside the parent target's bounding box the intersection of the parent target's bounding box and area will be used.

Examples

use embedded_graphics::{
    fonts::{Font12x16, Text},
    mock_display::MockDisplay,
    pixelcolor::BinaryColor,
    prelude::*,
    primitives::Rectangle,
    style::MonoTextStyle,
};

let mut display = MockDisplay::new();

let area = Rectangle::new(Point::zero(), Size::new(4 * 12, 16));
let mut clipped_display = display.clipped(&area);

// Only the first 4 characters will be drawn, because the others are outside
// the clipping area
Text::new("Clipped", Point::zero())
    .into_styled(MonoTextStyle::new(Font12x16, BinaryColor::On))
    .draw(&mut clipped_display)?;

pub fn color_converted<C>(&mut self) -> ColorConverted<'_, Self, C> where
    C: PixelColor + Into<Self::Color>, [src]

Creates a color conversion draw target.

A color conversion draw target is used to draw drawables with a different color type to a draw target. The drawable color type must implement Into<C>, where C is the draw target color type.

Performance

Color conversion can be expensive on embedded hardware and should be avoided if possible. Using the same color type for drawables and the draw target makes sure that no unnecessary color conversion is used. But in some cases color conversion will be required, for example, to draw images with a color format only known at runtime.

Examples

This example draws a BinaryColor image to an Rgb888 display.

use embedded_graphics::{
    image::{Image, ImageRaw},
    mock_display::MockDisplay,
    pixelcolor::{BinaryColor, Rgb888},
    prelude::*,
};

/// The image data.
const DATA: &[u8] = &[
    0b11110000, //
    0b10010000, //
    0b10010000, //
    0b11110000, //
];

// Create a `BinaryColor` image from the image data.
let raw_image = ImageRaw::<BinaryColor>::new(DATA, 4, 4);
let image = Image::new(&raw_image, Point::zero());

// Create a `Rgb888` display.
let mut display = MockDisplay::<Rgb888>::new();

// The image can't directly be drawn to the draw target because they use different
// color type. This will fail to compile:
// image.draw(&mut display)?;

// To fix this `color_converted` is added to enable color conversion.
image.draw(&mut display.color_converted())?;
Loading content...

Implementors

impl<T> DrawTargetExt for T where
    T: DrawTarget, [src]

Loading content...