ds_screen.h

/* Copyright (C) 2017 - 2024, Thornwave Labs Inc - All Rights Reserved.
 * Unauthorized copying of this file, via any medium is strictly prohibited.
 * Proprietary and confidential.
 * Written by Razvan Turiac <razvan.turiac@thornwave.com>
*/
 
#ifndef _DS_SCREEN_H
#define _DS_SCREEN_H
 
 
#include <ds_event.h>
#include <ds_view.h>
 
 
class DsKeyboard;
 
 
class DsScreen: public DsView
{
public:
    DsScreen(int32_t phys_width, int32_t phys_height, DsRotation rotation, DsColorMode cmode, uint8_t* linebuffer, uint8_t* aa_linebuffer, uint32_t framebuffer_alignment, bool triple_buffered);
    ~DsScreen();
 
    DsRotation getRotation(void) const;
    
    DsSurface* allocSurface(int32_t width, int32_t height, DsColorMode cmode, size_t palette_size = 0, bool palette_has_alpha = false);
 
    
    void setFocusedView(DsView* view);
 
    
    DsView* getFocusedView(void) const;
 
    
    void registerView(DsView* view, const char* id);
 
    DsView* getView(const char* id);
 
    bool pushView(const char* id, bool on_top = false);
    
    
    bool popView(void);
 
    
    bool popView(const char* id);
 
    
    bool topViewIs(const char* id);
 
    
    bool unrollViewStack(const char* id);
 
    
    bool unrollViewStack(size_t level);
    
    
    size_t getViewStackSize(void) const;
 
 
    void createKeyboard(const ds_bitmap_font_t* font);
 
    DsKeyboard& getKeyboard(void);
 
    
    void run(void);
 
 
    DsRenderer createRenderer(DsSurface &surface);
 
    
    bool isUiThread(void) const;
    
    
    bool isTouchTimeoutExpired(void) const;
    
    
    void kickTouchTimeout(uint32_t timeout_ms);
 
    
    void queueExitLoopEvent(void);
 
    
    void queueVSyncEvent(void);
    
    
    void queueVSyncEventFromISR(int32_t* woken);
 
 
    void queueTouchEvent(const DsTouchEvent::Mode &mode, const DsPoint &pos, uint32_t timestamp);
 
    
    void queueTouchEventFromISR(const DsTouchEvent::Mode &mode, const DsPoint &pos, uint32_t timestamp, int32_t* woken);
 
 
    void queueKeyboardEvent(int32_t key);
 
    
    void queueLambda(const lambda<void(void), 64> &lambda);
 
    
    void queueLambdaFromISR(const lambda<void(void), 64> &lambda, int32_t* woken);
 
 
    void lcdSurfaceUpdateFinished(void);
    void lcdSurfaceUpdateFinishedFromISR(int32_t* woken);
 
 
 
protected:
    volatile bool mDirty;
    volatile bool mLocked;
    bool mCoalescePaintEvents;
    uint8_t mCoalescePaintEventsCounter;
 
    const uint32_t mFrameBufferAlignment;
 
    DsSurface* mFrontSurface;
    DsSurface* mBackSurfaceActive;
    DsSurface* mBackSurfacePending;
 
    DsRect mSurfaceUserRect[3];
 
    DsRenderer mRenderer;
    DsRotation mScreenRotation;
 
 
    virtual void lcdSurfaceUpdate(DsSurface* surface) = 0;
    
    
    virtual void onStart(void);
    
    
    virtual void onFinish(void);
 
    
    virtual void onTouchTimeout(bool expired);
    
    
    virtual void onEventProcessStart(void);
 
    
    virtual void onEventProcessFinish(void);
 
    void enableCoalescePaintEvents(bool enabled);
 
 
private:
    friend class DsView;
    
    struct ViewEntry
    {
        const char* id;
        DsView* view;
 
        bool operator==(const ViewEntry &rhs) const
        {
            return strcmp(id, rhs.id) == 0;
        }
    };
 
    ds_thread_t mUiThreadHandler;
    
    void* mContext;
    DsView* mFocusedView;
    DsKeyboard* mKeyboard;
    DsRect mInvalidRegion;
 
    DsTimer mUpdateTimer;
    DsBinarySemaphore mSyncSemaphore;   
 
    queue<512, DsEvent> mEventQueue;
 
    //touch timeout
    bool mIsTouchTimeoutExpired;
    DsTimer mTouchTimeoutTimer;
 
    static_stack<32, ViewEntry> mViewStack;
    static_vector<32, ViewEntry> mViewVector;
 
    void touchRotate(int32_t &x, int32_t &y);
    bool processEvent(const DsEvent &event);
 
    void onPaint(DsRenderer &renderer) override final;
    bool onTouch(const DsTouchEvent &event) override final;
    
    void invalidateRegion(DsRect region) override final;
 
    void update(DsRect dirty_region);
};
 
 
#endif