ui_alert_slot.h

/*
 * The control task's alert slot, and the band's record of the alert it
 * took from it.
 *
 * The control task never calls the router (ui_screen.h): it posts an alert
 * into a slot, and the render loop takes it into the band once a frame.
 * The slot holds one alert; a later one replaces it.  Every alert posted is
 * numbered, so the control task can tell an alert shown from one replaced
 * before a frame took it, and can take back one whose cause is over:
 *
 *   - not yet taken: it is dropped and never shows;
 *   - taken, and still the last one taken: the slot records its number,
 *     and the render loop clears it from the band while the band still
 *     shows it (ui_router_withdraw_alert());
 *   - anything else -- an older alert, one replaced or already withdrawn --
 *     is left alone: the band shows no alert of the slot but the last one
 *     taken, so the record of that one is all a withdrawal needs.
 *
 * The slot has no lock of its own; the caller holds the one that guards
 * the memory it lives in.
 *
 * SPDX-License-Identifier: MIT
 */
#pragma once
 
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
 
#include "ui_screen.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
typedef struct {
    char     text[UI_ALERT_MAX];
    bool     pending;    
    uint32_t posted;     
    uint32_t taken;      
    uint32_t withdrawn;  
} ui_alert_slot_t;

uint32_t ui_alert_slot_post(ui_alert_slot_t *s, const char *text);

void ui_alert_slot_withdraw(ui_alert_slot_t *s, uint32_t number);

bool ui_alert_slot_take(ui_alert_slot_t *s, char *out, size_t size);

typedef struct {
    uint32_t slot;   
    uint32_t band;   
} ui_alert_band_t;

bool ui_alert_band_update(ui_alert_band_t *b, const char *text,
                          uint32_t taken, uint32_t withdrawn);
 
#ifdef __cplusplus
}
#endif