display.h

Go to the documentation of this file.

//   Copyright 2016-2023 Jean-Francois Poilpret
//
//   Licensed under the Apache License, Version 2.0 (the "License");
//   you may not use this file except in compliance with the License.
//   You may obtain a copy of the License at
//
//       http://www.apache.org/licenses/LICENSE-2.0
//
//   Unless required by applicable law or agreed to in writing, software
//   distributed under the License is distributed on an "AS IS" BASIS,
//   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//   See the License for the specific language governing permissions and
//   limitations under the License.
 
 
#ifndef DISPLAY_HH
#define DISPLAY_HH
 
#include "../flash.h"
#include "../initializer_list.h"
#include "../types_traits.h"
#include "../utilities.h"
#include "font.h"
 
namespace devices
{
    namespace display
    {
    }
}
 
//TODO Add new 2D primitives e.g. color pixmaps
//TODO Add pattern to DrawMode (to allow dotted lines or pseudo-grey)?
//TODO Add thickness to DrawMode (to allow thick lines)?
//TODO Use device traits to also determine what modes a device can handle!
 
namespace devices::display
{
    template<typename XCOORD, typename YCOORD>
    struct Point
    {
        Point(XCOORD x, YCOORD y) : x{x}, y{y} {}
        XCOORD x;
        YCOORD y;
    };
 
    enum class Mode : uint8_t
    {
        COPY = 0,
        XOR,
        AND,
        OR,
        NO_CHANGE = 0xFF
    };
 
    template<typename COLOR> class DrawMode
    {
    public:
        DrawMode(Mode mode = Mode::NO_CHANGE, COLOR color = COLOR{})
            : mode_{mode}, color_{color} {}
 
        operator bool() const
        {
            return mode_ != Mode::NO_CHANGE;
        }
 
        Mode mode() const
        {
            return mode_;
        }
 
        COLOR color() const
        {
            return color_;
        }
 
        uint8_t bw_pixels_op(uint8_t source, uint8_t dest) const
        {
            // Invert source if colow is black
            if (!color_)
                source = ~source;
            switch (mode_)
            {
                case Mode::COPY:
                default:
                return source;
 
                case Mode::XOR:
                return source ^ dest;
 
                case Mode::AND:
                return source & dest;
 
                case Mode::OR:
                return source | dest;
            }
        }
 
        COLOR pixel_op(COLOR dest) const
        {
            switch (mode_)
            {
                case Mode::COPY:
                default:
                return color_;
 
                case Mode::XOR:
                return color_ ^ dest;
 
                case Mode::AND:
                return color_ & dest;
 
                case Mode::OR:
                return color_ | dest;
            }
        }
 
    private:
        Mode mode_;
        COLOR color_;
    };
 
    template<typename COLOR, bool VERTICAL_FONT> class DrawContext
    {
    public:
        DrawContext() = default;
 
        DrawMode<COLOR> draw_mode() const
        {
            return (is_fill_ ? fill_ : draw_);
        }
        
        const Font<VERTICAL_FONT>& font() const
        {
            return *font_;
        }
        
    private:
        // These variables are set by `Display` (which is a friend) before calling
        // a display device low-level primitive
        bool is_fill_ = false;
        DrawMode<COLOR> draw_{};
        DrawMode<COLOR> fill_{};
        const Font<VERTICAL_FONT>* font_ = nullptr;
 
        template<typename> friend class Display;
    };
 
    enum class Error : uint8_t
    {
        NO_ERROR = 0,
        NO_FONT_SET,
        NO_GLYPH_FOUND,
        OUT_OF_DISPLAY,
        COORDS_INVALID,
        INVALID_GEOMETRY
    };
 
    template<typename DEVICE> struct DisplayDeviceTrait
    {
        static constexpr bool IS_DISPLAY = false;
        using COLOR = void;
        using XCOORD = uint8_t;
        using YCOORD = uint8_t;
        static constexpr XCOORD MAX_X = 0;
        static constexpr YCOORD MAX_Y = 0;
        static constexpr uint8_t WIDTH = 0;
        static constexpr uint8_t HEIGHT = 0;
        using SCALAR = uint8_t;
        using SIGNED_SCALAR = int8_t;
        static constexpr bool VERTICAL_FONT = false;
        static constexpr bool HAS_RASTER = false;
    };
 
    template<typename COLOR_, uint16_t WIDTH_, uint16_t HEIGHT_, 
        bool HAS_RASTER_ = false, bool VERTICAL_FONT_ = false>
        struct DisplayDeviceTrait_impl
    {
        static constexpr bool IS_DISPLAY = true;
        using COLOR = COLOR_;
 
        using XCOORD = typename types_traits::SmallestInt<WIDTH_ - 1>::UNSIGNED_TYPE;
        using YCOORD = typename types_traits::SmallestInt<HEIGHT_ - 1>::UNSIGNED_TYPE;
 
        static constexpr XCOORD MAX_X = WIDTH_ - 1;
        static constexpr YCOORD MAX_Y = HEIGHT_ - 1;
 
        static constexpr uint16_t WIDTH = WIDTH_;
        static constexpr uint16_t HEIGHT = HEIGHT_;
 
        // SCALAR is the biggest of XCOORD and YCOORD types
        using SCALAR = typename types_traits::SmallestInt<utils::max(WIDTH, HEIGHT)>::UNSIGNED_TYPE;
        // SIGNED_SCALAR must be large enough to store -4 * min(WIDTH,HEIGHT)
        using SIGNED_SCALAR = typename types_traits::SmallestInt<utils::min(WIDTH, HEIGHT) * 4 + 1>::SIGNED_TYPE;
 
        static constexpr bool VERTICAL_FONT = VERTICAL_FONT_;
        static constexpr bool HAS_RASTER = HAS_RASTER_;
    };
 
    template<typename DISPLAY_DEVICE> class Display : public DISPLAY_DEVICE
    {
        using DISPLAY_TRAITS = DisplayDeviceTrait<DISPLAY_DEVICE>;
        // Check at compile-time that DISPLAY_DEVICE is really a Display Device
        static_assert(DISPLAY_TRAITS::IS_DISPLAY, 
            "DISPLAY_DEVICE must be a Display Device (a DisplayDeviceTrait must exist for it)!");
        using DRAW_CONTEXT = DrawContext<typename DISPLAY_TRAITS::COLOR, DISPLAY_TRAITS::VERTICAL_FONT>;
 
    public:
        using COLOR = typename DISPLAY_TRAITS::COLOR;
        using FONT = Font<DISPLAY_TRAITS::VERTICAL_FONT>;
        using DRAW_MODE = DrawMode<COLOR>;
        using XCOORD = typename DISPLAY_TRAITS::XCOORD;
        using YCOORD = typename DISPLAY_TRAITS::YCOORD;
 
        using POINT = Point<XCOORD, YCOORD>;
 
        using SCALAR = typename DISPLAY_TRAITS::SCALAR;
 
        static constexpr XCOORD WIDTH = DISPLAY_TRAITS::WIDTH;
        static constexpr YCOORD HEIGHT = DISPLAY_TRAITS::HEIGHT;
 
    protected:
        using SIGNED_SCALAR = typename DISPLAY_TRAITS::SIGNED_SCALAR;
 
    public:
        Display() = default;
 
        void set_draw_mode(const DRAW_MODE& mode)
        {
            context_.draw_ = mode;
        }
 
        void set_fill_mode(const DRAW_MODE& mode)
        {
            context_.fill_ = mode;
        }
 
        void set_font(const FONT& font)
        {
            context_.font_ = &font;
        }
 
        Error last_error() const
        {
            return last_error_;
        }
 
        void erase()
        {
            DISPLAY_DEVICE::erase();
            invalidate();
        }
 
        void draw_char(POINT point, char value)
        {
            // Check one font is currently selected
            if (!check_font()) return;
            // Check coordinates are suitable for character display
            const uint8_t width = context_.font_->width();
            XCOORD x = point.x;
            YCOORD y = point.y;
            if (!is_valid_char_xy(x, y, width)) return;
            // Check glyph exists for current character
            uint16_t glyph_ref = get_glyph(value);
            if (glyph_ref == 0) return;
            // Delegate glyph display to actual device
            uint8_t displayed_width = DISPLAY_DEVICE::write_char(x, y, glyph_ref, context_);
            invalidate(x, y, XCOORD(x + displayed_width), YCOORD(y + context_.font_->height() - 1));
        }
 
        void draw_string(POINT point, const char* content)
        {
            // Check one font is currently selected
            if (!check_font()) return;
            const uint8_t width = context_.font_->width();
 
            XCOORD x = point.x;
            YCOORD y = point.y;
            XCOORD xcurrent = x;
            while (*content)
            {
                // Check coordinates are suitable for character display
                if (!is_valid_char_xy(xcurrent, y, width)) break;
                // Check glyph exists for current character
                uint16_t glyph_ref = get_glyph(*content);
                if (glyph_ref == 0) break;
                // Delegate glyph display to actual device
                const uint8_t displayed_width = DISPLAY_DEVICE::write_char(xcurrent, y, glyph_ref, context_);
                xcurrent += displayed_width;
                ++content;
            }
            // Invalidate if needed
            if (xcurrent > x)
            {
                // Clear error only if all content was displayed without issue
                bool clear_error = (*content == 0); 
                invalidate(x, y, XCOORD(xcurrent - 1), YCOORD(y + context_.font_->height() - 1), clear_error);
            }
        }
 
        void draw_string(POINT point, const flash::FlashStorage* content)
        {
            //TODO factor out common code with 1st draw_string() [only 2 lines different!]
            // Check one font is currently selected
            if (!check_font()) return;
            const uint8_t width = context_.font_->width();
 
            XCOORD x = point.x;
            YCOORD y = point.y;
            XCOORD xcurrent = x;
            uint16_t address = (uint16_t) content;
            char value;
            while ((value = pgm_read_byte(address)) != 0)
            {
                // Check coordinates are suitable for character display
                if (!is_valid_char_xy(xcurrent, y, width)) break;
                // Check glyph exists for current character
                uint16_t glyph_ref = get_glyph(value);
                if (glyph_ref == 0) break;
                // Delegate glyph display to actual device
                const uint8_t displayed_width = DISPLAY_DEVICE::write_char(xcurrent, y, glyph_ref, context_);
                xcurrent += displayed_width;
                ++address;
            }
            // Invalidate if needed
            if (xcurrent > x)
            {
                // Clear error only if all content was displayed without issue
                bool clear_error = (value == 0);
                invalidate(x, y, XCOORD(xcurrent -1), YCOORD(y + context_.font_->height() - 1), clear_error);
            }
        }
 
        void draw_point(POINT point)
        {
            XCOORD x = point.x;
            YCOORD y = point.y;
            if (!is_valid_xy(x, y)) return;
            if (DISPLAY_DEVICE::set_pixel(x, y, context_))
                invalidate(x, y, x, y);
            else
                // Even when set_pixel() returns false, this is not an error!
                last_error_ = Error::NO_ERROR;
        }
 
        void draw_line(POINT point1, POINT point2)
        {
            XCOORD x1 = point1.x;
            YCOORD y1 = point1.y;
            XCOORD x2 = point2.x;
            YCOORD y2 = point2.y;
            if (!is_valid_xy(x1, y1)) return;
            if (!is_valid_xy(x2, y2)) return;
 
            // Check if specifc case (vertical or horizontal line)
            if (x1 == x2)
            {
                // if 2 points are the same: nothing to do
                if (y1 == y2)
                {
                    last_error_ = Error::INVALID_GEOMETRY;
                    return;
                }
                // Ensure y1 < y2
                swap_to_sort(y1, y2);
                draw_vline(x1, y1, y2);
            }
            else if (y1 == y2)
            {
                // Ensure x1 < x2
                swap_to_sort(x1, x2);
                draw_hline(x1, y1, x2);
            }
            else
            {
                // Possibly swap x1-x2 and y1-y2 to ensure x1 < x2
                if (swap_to_sort(x1, x2)) utils::swap(y1, y2);
                // Usual case, apply Bresenham's line algorithm
                draw_line_bresenham(x1, y1, x2, y2);
                // Ensure y1 < y2 for invalid region instantiation
                swap_to_sort(y1, y2);
            }
            invalidate(x1, y1, x2, y2);
        }
 
        void draw_rectangle(POINT point1, POINT point2)
        {
            draw_rounded_rectangle(point1, point2, 0);
        }
 
        void draw_rounded_rectangle(POINT point1, POINT point2, SCALAR radius)
        {
            XCOORD x1 = point1.x;
            YCOORD y1 = point1.y;
            XCOORD x2 = point2.x;
            YCOORD y2 = point2.y;
            if (!is_valid_xy(x1, y1)) return;
            if (!is_valid_xy(x2, y2)) return;
            if ((x1 == x2) || (y1 == y2))
            {
                last_error_ = Error::INVALID_GEOMETRY;
                return;
            }
            // Possibly swap x1-x2 and y1-y2
            swap_to_sort(x1, x2);
            swap_to_sort(y1, y2);
            if ((radius * 2 > x2 - x1) || (radius * 2 > y2 - y1))
            {
                last_error_ = Error::INVALID_GEOMETRY;
                return;
            }
 
            // Draw edges
            if (context_.draw_)
            {
                // For rounded rectangles we need to draw one less pixel on the right (in XOR mode)
                SCALAR delta = (radius ? radius + 1 : 0);
                // Simply draw 2 horizontal and 2 vertical lines
                draw_hline(x1 + radius, y1, x2 - delta);
                draw_hline(x1 + radius, y2, x2 - delta);
                // Note that we avoid drawing the same pixels (corners) twice 
                // (due to a drawing mode that might potentially be XOR)
                draw_vline(x1, y1 + radius + 1, y2 - radius - 1);
                draw_vline(x2, y1 + radius + 1, y2 - radius - 1);
            }
 
            if ((radius != 0) && (context_.draw_ || context_.fill_))
            {
                // Draw 4 quarter-circles & fill with horizontal lines
                draw_circle_bresenham(x1 + radius, y1 + radius, x2 - radius, y2 - radius, radius);
            }
 
            // Fill rectangle inside
            if (context_.fill_)
            {
                context_.is_fill_ = true;
                // Simply draw enough horizontal lines
                // For rounded rectangles we need to draw one more line on the top
                SCALAR delta = (radius ? radius : 1);
                for (YCOORD y = y1 + delta; y < y2 - radius; ++y)
                    draw_hline(x1 + 1, y, x2 - 1);
                context_.is_fill_ = false;
            }
 
            invalidate(x1, y1, x2, y2);
        }
 
        void draw_circle(POINT center, SCALAR radius)
        {
            XCOORD xc = center.x;
            YCOORD yc = center.y;
            if (!is_valid_xy(xc, yc)) return;
            if (radius == 0)
            {
                last_error_ = Error::INVALID_GEOMETRY;
                return;
            }
            if (    (xc < radius) || (xc + radius >= WIDTH)
                ||  (yc < radius) || (yc + radius >= HEIGHT))
            {
                last_error_ = Error::OUT_OF_DISPLAY;
                return;
            }
            // Apply Bresenham's circle algorithm
            draw_circle_bresenham(xc, yc, xc, yc, radius);
            invalidate(XCOORD(xc - radius), YCOORD(yc - radius), XCOORD(xc + radius), YCOORD(yc + radius));
        }
 
        void draw_polyline(std::initializer_list<POINT> points)
        {
            draw_lines(points, false);
        }
 
        void draw_polygon(std::initializer_list<POINT> points)
        {
            draw_lines(points, true);
        }
 
        template<typename F>
        void draw_bitmap(POINT origin, POINT size, F input_streamer)
        {
            // Check origin and size are compatible with display device resolution
            const XCOORD xorg = origin.x;
            const YCOORD yorg = origin.y;
            if (!is_valid_xy(xorg, yorg)) return;
            const XCOORD w = size.x;
            const YCOORD h = size.y;
            if (!is_valid_xy(w, h)) return;
            if (!is_valid_xy(xorg + w, yorg + h)) return;
 
            if (context_.draw_ || context_.fill_)
            {
                const XCOORD cols = (w / 8) + (w % 8 ? 1 : 0);
                XCOORD xcurrent = 0;
                YCOORD ycurrent;
                for (ycurrent = yorg; ycurrent < yorg + h; ++ycurrent)
                {
                    xcurrent = xorg;
                    for (XCOORD col = 0; col < cols; ++col)
                    {
                        uint8_t value = input_streamer();
                        // Draw each pixel with draw or fill mode
                        for (uint8_t i = 0; i < 8; ++i)
                        {
                            if (value & 0x80)
                            {
                                DISPLAY_DEVICE::set_pixel(xcurrent, ycurrent, context_);
                            }
                            else
                            {
                                context_.is_fill_ = true;
                                DISPLAY_DEVICE::set_pixel(xcurrent, ycurrent, context_);
                                context_.is_fill_ = false;
                            }
                            ++xcurrent;
                            value <<= 1;
                        }
                    }
                }
                // Invalidate
                invalidate(xorg, yorg, XCOORD(xcurrent - 1), YCOORD(ycurrent - 1));
            }
        }
 
        void update()
        {
            if (DISPLAY_TRAITS::HAS_RASTER && !invalid_area_.empty)
            {
                DISPLAY_DEVICE::update(invalid_area_.x1, invalid_area_.y1, invalid_area_.x2, invalid_area_.y2);
                invalid_area_.empty = true;
            }
        }
 
        void force_update()
        {
            invalidate();
            update();
        }
 
    protected:
        struct InvalidArea
        {
            InvalidArea() = default;
            InvalidArea(XCOORD x1, YCOORD y1, XCOORD x2, YCOORD y2)
                : x1{x1}, y1{y1}, x2{x2}, y2{y2}, empty{false} {}
 
            InvalidArea& operator+=(const InvalidArea& a)
            {
                if (!a.empty)
                {
                    if (empty)
                    {
                        x1 = a.x1;
                        y1 = a.y1;
                        x2 = a.x2;
                        y2 = a.y2;
                        empty = false;
                    }
                    else
                    {
                        if (a.x1 < x1) x1 = a.x1;
                        if (a.y1 < y1) y1 = a.y1;
                        if (a.x2 > x2) x2 = a.x2;
                        if (a.y2 > y2) y2 = a.y2;
                    }
                }
                return *this;
            }
 
            static InvalidArea EMPTY;
 
            XCOORD x1 = 0;
            YCOORD y1 = 0;
            XCOORD x2 = 0;
            YCOORD y2 = 0;
            bool empty = true;
        };
 
        using INVALID_AREA = InvalidArea;
 
        void invalidate(XCOORD x1, XCOORD y1,XCOORD x2, YCOORD y2, bool clear_error = true)
        {
            if (DISPLAY_TRAITS::HAS_RASTER)
                invalid_area_ += INVALID_AREA{x1, y1, x2, y2};
            if (clear_error)
                last_error_ = Error::NO_ERROR;
        }
 
        void invalidate()
        {
            if (DISPLAY_TRAITS::HAS_RASTER)
                invalid_area_ = INVALID_AREA{0, 0, WIDTH - 1, HEIGHT - 1};
            last_error_ = Error::NO_ERROR;
        }
 
        bool check_font()
        {
            if (context_.font_ != nullptr) return true;
            last_error_ = Error::NO_FONT_SET;
            return false;
        }
 
        bool is_valid_xy(XCOORD x, YCOORD y)
        {
            if ((x < WIDTH) && (y < HEIGHT)) return true;
            last_error_ = Error::OUT_OF_DISPLAY;
            return false;
        }
 
        bool is_valid_char_xy(XCOORD x, YCOORD y, uint8_t width)
        {
            if ((x + width > WIDTH) || (y >= HEIGHT))
            {
                last_error_ = Error::OUT_OF_DISPLAY;
                return false;
            }
            if (DISPLAY_DEVICE::is_valid_char_xy(x, y)) return true;
            last_error_ = Error::COORDS_INVALID;
            return false;
        }
 
        uint16_t get_glyph(char value)
        {
            // Load pixmap for current character
            uint16_t glyph_ref = context_.font_->get_char_glyph_ref(value);
            if (glyph_ref != 0) return glyph_ref;
            last_error_ = Error::NO_GLYPH_FOUND;
            return 0;
        }
 
        void draw_lines(std::initializer_list<POINT> points, bool polygon)
        {
            if (points.size() < 2)
            {
                last_error_ = Error::INVALID_GEOMETRY;
                return;
            }
            const POINT* next = points.begin();
            POINT current = *next;
            POINT first = current;
            while (++next != points.end())
            {
                draw_line(current, *next);
                current = *next;
                // Revert double end point drawing (in case of XOR mode)!
                if (!polygon || (next + 1) != points.end())
                    draw_point(current);
            }
            if (polygon)
            {
                draw_line(current, first);
                // Revert double end point drawing (in case of XOR mode)!
                draw_point(first);
            }
        }
 
        void draw_vline(XCOORD x1, YCOORD y1, YCOORD y2)
        {
            swap_to_sort(y1, y2);
            for (YCOORD y = y1; y <= y2; ++y)
                DISPLAY_DEVICE::set_pixel(x1, y, context_);
        }
        
        void draw_hline(XCOORD x1, YCOORD y1, XCOORD x2)
        {
            swap_to_sort(x1, x2);
            for (XCOORD x = x1; x <= x2; ++x)
                DISPLAY_DEVICE::set_pixel(x, y1, context_);
        }
 
        // Draw a segment according to Bresenham algorithm
        // https://en.wikipedia.org/wiki/Bresenham%27s_line_algorithm
        // https://fr.wikipedia.org/wiki/Algorithme_de_trac%C3%A9_de_segment_de_Bresenham
        void draw_line_bresenham(XCOORD x1, YCOORD y1, XCOORD x2, YCOORD y2)
        {
            // We are sure that x1 < x2 when calling this method
            SIGNED_SCALAR dx = SIGNED_SCALAR(x2) - SIGNED_SCALAR(x1);
            SIGNED_SCALAR dy = SIGNED_SCALAR(y2) - SIGNED_SCALAR(y1);
 
            if (dy > 0)
            {
                // 1st quadrant
                draw_line_bresenham_1st_quadrant(x1, y1, x2, y2, dx, dy);
            }
            else
            {
                // 4th quadrant
                draw_line_bresenham_4th_quadrant(x1, y1, x2, y2, dx, dy);
            }
        }
 
        void draw_line_bresenham_1st_quadrant(XCOORD x1, YCOORD y1, XCOORD x2, YCOORD y2, 
            SIGNED_SCALAR dx, SIGNED_SCALAR dy)
        {
            if (dx >= dy)
            {
                // 1st octant
                SIGNED_SCALAR e = dx;
                dx *= 2;
                dy *= 2;
                while (true)
                {
                    DISPLAY_DEVICE::set_pixel(x1, y1, context_);
                    if (x1 == x2) break;
                    ++x1;
                    e -= dy;
                    if (e < 0)
                    {
                        ++y1;
                        e += dx;
                    }
                }
            }
            else
            {
                // 2nd octant
                SIGNED_SCALAR e = dy;
                dx *= 2;
                dy *= 2;
                while (true)
                {
                    DISPLAY_DEVICE::set_pixel(x1, y1, context_);
                    if (y1 == y2) break;
                    ++y1;
                    e -= dx;
                    if (e < 0)
                    {
                        ++x1;
                        e += dy;
                    }
                }
            }
        }
 
        void draw_line_bresenham_4th_quadrant(XCOORD x1, YCOORD y1, XCOORD x2, YCOORD y2, 
            SIGNED_SCALAR dx, SIGNED_SCALAR dy)
        {
            if (dx >= -dy)
            {
                // 8th octant
                SIGNED_SCALAR e = dx;
                dx *= 2;
                dy *= 2;
                while (true)
                {
                    DISPLAY_DEVICE::set_pixel(x1, y1, context_);
                    if (x1 == x2) break;
                    ++x1;
                    e += dy;
                    if (e < 0)
                    {
                        --y1;
                        e += dx;
                    }
                }
            }
            else
            {
                // 7th octant
                SIGNED_SCALAR e = dy;
                dx *= 2;
                dy *= 2;
                while (true)
                {
                    DISPLAY_DEVICE::set_pixel(x1, y1, context_);
                    if (y1 == y2) break;
                    --y1;
                    e += dx;
                    if (e > 0)
                    {
                        ++x1;
                        e += dy;
                    }
                }
            }
        }
 
        void draw_pixels(XCOORD x, YCOORD y1, YCOORD y2)
        {
            DISPLAY_DEVICE::set_pixel(x, y1, context_);
            if (y1 != y2)
                DISPLAY_DEVICE::set_pixel(x, y2, context_);
        }
 
        // https://fr.wikipedia.org/wiki/Algorithme_de_trac%C3%A9_d%27arc_de_cercle_de_Bresenham
        void draw_circle_bresenham(XCOORD xc1, YCOORD yc1, XCOORD xc2, YCOORD yc2, SCALAR radius)
        {
            XCOORD x = 0;
            YCOORD y = radius;
            SIGNED_SCALAR m = 5 - 4 * radius;
            // Ensure filler lines in octants 3 & 4 do net get drawn twice (partly)
            XCOORD delta_x = 0;
            while (x <= y)
            {
                if (context_.draw_)
                {
                    // All these conditions are necessary to avoid drawing the same point twice
                    // which would fail in XOR Mode
                    draw_pixels(x + xc2, y + yc2, -y + yc1);                    // octants 2 & 7
                    if (x != 0)
                        draw_pixels(-x + xc1, y + yc2, -y + yc1);               // octants 3 & 6
                    if (x != y)
                    {
                        draw_pixels(y + xc2, x + yc2, -x + yc1);                // octants 1 & 8 
                        if (y != 0)
                            draw_pixels(-y + xc1, x + yc2, -x + yc1);           // octants 4 & 5
                    }
                }
                // Draw filler lines for octants 1&4, 5&8 if needed
                // If y == x, fill lines are already drawn afterwards
                if (context_.fill_ && x != y)
                {
                    context_.is_fill_ = true;
                    draw_hline(y + xc2 - 1, x + yc2, -y + xc1 + 1);             // octants 1 & 8
                    // If x==0, fill line has just been drawn above
                    if (x != 0)
                        draw_hline(y + xc2 - 1, -x + yc1, -y + xc1 + 1);        // octants 4 & 5
                    context_.is_fill_ = false;
                }
                if (m > 0)
                {
                    // Draw filler lines for octants 2&3, 6&7 if needed
                    if (context_.fill_ && y != radius)
                    {
                        context_.is_fill_ = true;
                        draw_hline(xc2 + x - delta_x, yc1 - y, xc1 - x + delta_x);  // octants 2 & 3
                        draw_hline(xc2 + x - delta_x, yc2 + y, xc1 - x + delta_x);  // octants 6 & 7
                        context_.is_fill_ = false;
                    }
                    delta_x = 0;
                    --y;
                    m -= 8 * y;
                }
                ++x;
                ++delta_x;
                m += 8 * x + 4;
            }
        }
 
        template<typename COORD>
        static bool swap_to_sort(COORD& a1, COORD& a2)
        {
            if (a1 > a2)
            {
                utils::swap(a1, a2);
                return true;
            }
            else
                return false;
        }
        
    private:
        // Draw Context that will be passed to actual device low-level drawing primitives
        DRAW_CONTEXT context_{};
 
        // The result status of the last drawing primitive called
        Error last_error_ = Error::NO_ERROR;
 
        // Minimal rectangle to update
        INVALID_AREA invalid_area_ = INVALID_AREA::EMPTY;
    };
 
    template<typename DISPLAY_DEVICE>
    typename Display<DISPLAY_DEVICE>::InvalidArea Display<DISPLAY_DEVICE>::InvalidArea::EMPTY = InvalidArea{};
}
 
#endif /* DISPLAY_HH */