screen.h

/*
 * Copyright (C) 2018 Microchip Technology Inc.  All rights reserved.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
#ifndef EGT_SCREEN_H
#define EGT_SCREEN_H
 
#include <cairo.h>
#include <egt/detail/meta.h>
#include <egt/geometry.h>
#include <egt/types.h>
#include <iosfwd>
#include <memory>
#include <vector>
 
namespace egt
{
inline namespace v1
{
 
class EGT_API Screen
{
public:
 
    using DamageArray = std::vector<Rect>;
 
    Screen() noexcept;
    Screen(const Screen&) = default;
    Screen& operator=(const Screen&) = default;
    Screen(Screen&&) noexcept = default;
    Screen& operator=(Screen&&) noexcept = default;
 
    virtual void flip(const DamageArray& damage);
 
    virtual void schedule_flip()  = 0;
 
    virtual uint32_t index() { return 0; }
 
    EGT_NODISCARD Size size() const { return m_size; }
 
    EGT_NODISCARD Rect box() const { return Rect(Point(), m_size); }
 
    EGT_NODISCARD shared_cairo_t context() const { return m_cr; }
 
    static void damage_algorithm(Screen::DamageArray& damage, Rect rect);
 
    void async_flip(bool async)
    {
        m_async = async;
    }
 
    EGT_NODISCARD virtual size_t max_brightness() const;
 
    EGT_NODISCARD virtual size_t brightness() const;
 
    virtual void brightness(size_t brightness);
 
    virtual void low_fidelity();
 
    virtual void high_fidelity();
 
    EGT_NODISCARD PixelFormat format() const { return m_format; };
 
    EGT_NODISCARD virtual bool have_planes() const { return false; }
 
    EGT_NODISCARD virtual bool is_composer() const { return false; }
 
    virtual ~Screen() noexcept = default;
 
protected:
 
    void init(void** ptr, uint32_t count, const Size& size,
              PixelFormat format = PixelFormat::argb8888);
 
    void init(const Size& size, PixelFormat format = PixelFormat::argb8888)
    {
        init(nullptr, 0, size, format);
    }
 
    struct ScreenBuffer
    {
        explicit ScreenBuffer(cairo_surface_t* s) noexcept
            : surface(s)
        {
            damage.reserve(10);
        }
 
        unique_cairo_surface_t surface;
 
        DamageArray damage;
 
        void add_damage(const Rect& rect)
        {
            Screen::damage_algorithm(damage, rect);
        }
    };
 
    virtual void copy_to_buffer(ScreenBuffer& buffer);
 
    void copy_to_buffer_software(ScreenBuffer& buffer);
 
    shared_cairo_surface_t m_surface;
 
    shared_cairo_t m_cr;
 
    using BufferArray = std::vector<ScreenBuffer>;
 
    BufferArray m_buffers;
 
    Size m_size;
 
    bool m_async{false};
 
    PixelFormat m_format{};
};
 
}
}
 
#endif