use embedded_graphics::{
    fonts::{Font6x8, Text},
    pixelcolor::BinaryColor,
    prelude::*,
    primitives::{Circle, Rectangle, Triangle},
    style::{PrimitiveStyle, TextStyle},
};
use embedded_graphics_simulator::{
    BinaryColorTheme, OutputSettingsBuilder, SimulatorDisplay, Window,
};

fn main() -> Result<(), std::convert::Infallible> {
    // Create a new monochrome simulator display with 128x64 pixels.
    let mut display: SimulatorDisplay<BinaryColor> = SimulatorDisplay::new(Size::new(128, 64));

    // Create styles used by the drawing operations.
    let thin_stroke = PrimitiveStyle::with_stroke(BinaryColor::On, 1);
    let thick_stroke = PrimitiveStyle::with_stroke(BinaryColor::On, 3);
    let fill = PrimitiveStyle::with_fill(BinaryColor::On);
    let text_style = TextStyle::new(Font6x8, BinaryColor::On);

    let yoffset = 10;

    // Draw a 3px wide outline around the display.
    let bottom_right = Point::zero() + display.size() - Point::new(1, 1);
    Rectangle::new(Point::zero(), bottom_right)
        .into_styled(thick_stroke)
        .draw(&mut display)?;

    // Draw a triangle.
    Triangle::new(
        Point::new(16, 16 + yoffset),
        Point::new(16 + 16, 16 + yoffset),
        Point::new(16 + 8, yoffset),
    )
    .into_styled(thin_stroke)
    .draw(&mut display)?;

    // Draw a filled square
    Rectangle::new(Point::new(52, yoffset), Point::new(52 + 16, 16 + yoffset))
        .into_styled(fill)
        .draw(&mut display)?;

    // Draw a circle with a 3px wide stroke.
    Circle::new(Point::new(88, yoffset), 17)
        .into_styled(thick_stroke)
        .draw(&mut display)?;

    // Draw centered text.
    let text = "embedded-graphics";
    let width = text.len() as i32 * 6;
    Text::new(text, Point::new(64 - width / 2, 40))
        .into_styled(text_style)
        .draw(&mut display)?;

    let output_settings = OutputSettingsBuilder::new()
        .theme(BinaryColorTheme::OledBlue)
        .build();
    Window::new("Hello World", &output_settings).show_static(&display);

    Ok(())
}

use embedded_graphics::fonts::Font6x8;
use embedded_graphics::pixelcolor::Rgb565;
use embedded_graphics::prelude::*;
use embedded_graphics::{
    egcircle, egline, egrectangle, egtext, egtriangle, primitive_style, text_style,
};

// Only used for examples - this would be replaced by the driver for your chosen display
use embedded_graphics::mock_display::MockDisplay as Display;

fn main() {
    // Create a display object to draw into
    // This will be whichever display driver you decide to use, like the SSD1306, SSD1351, etc
    let mut display = Display::new();

    // Draw a circle with top-left at (0, 0) with a diameter of 128 and a white 1px stroke
    egcircle!(
        top_left = (0, 0),
        diameter = 128,
        style = primitive_style!(stroke_color = Rgb565::WHITE)
    )
    .draw(&mut display);

    // Draw a 1px thick white line from (64, 64) to (0, 64)
    egline!(
        start = (64, 64),
        end = (0, 64),
        style = primitive_style!(stroke_color = Rgb565::WHITE)
    )
    .draw(&mut display);

    // Draw a 1px red line from (64, 64) to (80, 80)
    egline!(
        start = (64, 64),
        end = (80, 80),
        style = primitive_style!(stroke_color = Rgb565::RED)
    )
    .draw(&mut display);

    // Draw a rectangle from (64, 64) to (80, 80) with a black fill
    egrectangle!(
        top_left = (64, 64),
        bottom_right = (80, 80),
        style = primitive_style!(fill_color = Rgb565::BLACK)
    )
    .draw(&mut display);

    // Print "Hello world!" in a white 6x8 pixel font with the top left corner positioned at (5, 50)
    egtext!(
        text = "Hello world!",
        top_left = (5, 50),
        style = text_style!(font = Font6x8, text_color = Rgb565::WHITE)
    )
    .draw(&mut display);
}