lv_draw_mask.h

Go to the documentation of this file.

 
#ifndef LV_DRAW_MASK_H
#define LV_DRAW_MASK_H
 
#ifdef __cplusplus
extern "C" {
#endif
 
 
/*********************
 *      INCLUDES
 *********************/
#include <stdbool.h>
#include "../misc/lv_area.h"
#include "../misc/lv_color.h"
#include "../misc/lv_math.h"
 
/*********************
 *      DEFINES
 *********************/
#define LV_MASK_ID_INV  (-1)
#if LV_DRAW_COMPLEX
# define _LV_MASK_MAX_NUM     16
#else
# define _LV_MASK_MAX_NUM     1
#endif
 
/**********************
 *      TYPEDEFS
 **********************/
 
enum {
    LV_DRAW_MASK_RES_TRANSP,
    LV_DRAW_MASK_RES_FULL_COVER,
    LV_DRAW_MASK_RES_CHANGED,
    LV_DRAW_MASK_RES_UNKNOWN
};
 
typedef uint8_t lv_draw_mask_res_t;
 
typedef struct {
    void * param;
    void * custom_id;
} _lv_draw_mask_saved_t;
 
typedef _lv_draw_mask_saved_t _lv_draw_mask_saved_arr_t[_LV_MASK_MAX_NUM];
 
 
 
#if LV_DRAW_COMPLEX == 0
static inline  uint8_t lv_draw_mask_get_cnt(void)
{
    return 0;
}
 
static inline bool lv_draw_mask_is_any(const lv_area_t * a)
{
    LV_UNUSED(a);
    return false;
}
 
#endif
 
#if LV_DRAW_COMPLEX
 
enum {
    LV_DRAW_MASK_TYPE_LINE,
    LV_DRAW_MASK_TYPE_ANGLE,
    LV_DRAW_MASK_TYPE_RADIUS,
    LV_DRAW_MASK_TYPE_FADE,
    LV_DRAW_MASK_TYPE_MAP,
    LV_DRAW_MASK_TYPE_POLYGON,
};
 
typedef uint8_t lv_draw_mask_type_t;
 
enum {
    LV_DRAW_MASK_LINE_SIDE_LEFT = 0,
    LV_DRAW_MASK_LINE_SIDE_RIGHT,
    LV_DRAW_MASK_LINE_SIDE_TOP,
    LV_DRAW_MASK_LINE_SIDE_BOTTOM,
};
 
typedef lv_draw_mask_res_t (*lv_draw_mask_xcb_t)(lv_opa_t * mask_buf, lv_coord_t abs_x, lv_coord_t abs_y,
                                                 lv_coord_t len,
                                                 void * p);
 
typedef uint8_t lv_draw_mask_line_side_t;
 
typedef struct {
    lv_draw_mask_xcb_t cb;
    lv_draw_mask_type_t type;
} _lv_draw_mask_common_dsc_t;
 
typedef struct {
    /*The first element must be the common descriptor*/
    _lv_draw_mask_common_dsc_t dsc;
 
    struct {
        /*First point*/
        lv_point_t p1;
 
        /*Second point*/
        lv_point_t p2;
 
        /*Which side to keep?*/
        lv_draw_mask_line_side_t side : 2;
    } cfg;
 
    /*A point of the line*/
    lv_point_t origo;
 
    /*X / (1024*Y) steepness (X is 0..1023 range). What is the change of X in 1024 Y?*/
    int32_t xy_steep;
 
    /*Y / (1024*X) steepness (Y is 0..1023 range). What is the change of Y in 1024 X?*/
    int32_t yx_steep;
 
    /*Helper which stores yx_steep for flat lines and xy_steep for steep (non flat) lines*/
    int32_t steep;
 
    /*Steepness in 1 px in 0..255 range. Used only by flat lines.*/
    int32_t spx;
 
    /*1: It's a flat line? (Near to horizontal)*/
    uint8_t flat : 1;
 
    /*Invert the mask. The default is: Keep the left part.
     *It is used to select left/right/top/bottom*/
    uint8_t inv: 1;
} lv_draw_mask_line_param_t;
 
typedef struct {
    /*The first element must be the common descriptor*/
    _lv_draw_mask_common_dsc_t dsc;
 
    struct {
        lv_point_t vertex_p;
        lv_coord_t start_angle;
        lv_coord_t end_angle;
    } cfg;
 
    lv_draw_mask_line_param_t start_line;
    lv_draw_mask_line_param_t end_line;
    uint16_t delta_deg;
} lv_draw_mask_angle_param_t;
 
typedef struct  {
    uint8_t * buf;
    lv_opa_t * cir_opa;         /*Opacity of values on the circumference of an 1/4 circle*/
    uint16_t * x_start_on_y;        /*The x coordinate of the circle for each y value*/
    uint16_t * opa_start_on_y;      /*The index of `cir_opa` for each y value*/
    int32_t life;               /*How many times the entry way used*/
    uint32_t used_cnt;          /*Like a semaphore to count the referencing masks*/
    lv_coord_t radius;          /*The radius of the entry*/
} _lv_draw_mask_radius_circle_dsc_t;
 
typedef _lv_draw_mask_radius_circle_dsc_t _lv_draw_mask_radius_circle_dsc_arr_t[LV_CIRCLE_CACHE_SIZE];
 
typedef struct {
    /*The first element must be the common descriptor*/
    _lv_draw_mask_common_dsc_t dsc;
 
    struct {
        lv_area_t rect;
        lv_coord_t radius;
        /*Invert the mask. 0: Keep the pixels inside.*/
        uint8_t outer: 1;
    } cfg;
 
    _lv_draw_mask_radius_circle_dsc_t * circle;
} lv_draw_mask_radius_param_t;
 
 
typedef struct {
    /*The first element must be the common descriptor*/
    _lv_draw_mask_common_dsc_t dsc;
 
    struct {
        lv_area_t coords;
        lv_coord_t y_top;
        lv_coord_t y_bottom;
        lv_opa_t opa_top;
        lv_opa_t opa_bottom;
    } cfg;
 
} lv_draw_mask_fade_param_t;
 
 
typedef struct _lv_draw_mask_map_param_t {
    /*The first element must be the common descriptor*/
    _lv_draw_mask_common_dsc_t dsc;
 
    struct {
        lv_area_t coords;
        const lv_opa_t * map;
    } cfg;
} lv_draw_mask_map_param_t;
 
typedef struct {
    /*The first element must be the common descriptor*/
    _lv_draw_mask_common_dsc_t dsc;
 
    struct {
        lv_point_t * points;
        uint16_t point_cnt;
    } cfg;
} lv_draw_mask_polygon_param_t;
 
 
/**********************
 * GLOBAL PROTOTYPES
 **********************/
 
int16_t lv_draw_mask_add(void * param, void * custom_id);
 
 
LV_ATTRIBUTE_FAST_MEM lv_draw_mask_res_t lv_draw_mask_apply(lv_opa_t * mask_buf, lv_coord_t abs_x, lv_coord_t abs_y,
                                                            lv_coord_t len);
 
LV_ATTRIBUTE_FAST_MEM lv_draw_mask_res_t lv_draw_mask_apply_ids(lv_opa_t * mask_buf, lv_coord_t abs_x, lv_coord_t abs_y,
                                                                lv_coord_t len, const int16_t * ids, int16_t ids_count);
 
 
void * lv_draw_mask_remove_id(int16_t id);
 
void * lv_draw_mask_remove_custom(void * custom_id);
 
void lv_draw_mask_free_param(void * p);
 
void _lv_draw_mask_cleanup(void);
 
 
LV_ATTRIBUTE_FAST_MEM uint8_t lv_draw_mask_get_cnt(void);
 
 
bool lv_draw_mask_is_any(const lv_area_t * a);
 
 
void lv_draw_mask_line_points_init(lv_draw_mask_line_param_t * param, lv_coord_t p1x, lv_coord_t p1y, lv_coord_t p2x,
                                   lv_coord_t p2y, lv_draw_mask_line_side_t side);
 
void lv_draw_mask_line_angle_init(lv_draw_mask_line_param_t * param, lv_coord_t p1x, lv_coord_t py, int16_t angle,
                                  lv_draw_mask_line_side_t side);
 
void lv_draw_mask_angle_init(lv_draw_mask_angle_param_t * param, lv_coord_t vertex_x, lv_coord_t vertex_y,
                             lv_coord_t start_angle, lv_coord_t end_angle);
 
void lv_draw_mask_radius_init(lv_draw_mask_radius_param_t * param, const lv_area_t * rect, lv_coord_t radius, bool inv);
 
void lv_draw_mask_fade_init(lv_draw_mask_fade_param_t * param, const lv_area_t * coords, lv_opa_t opa_top,
                            lv_coord_t y_top,
                            lv_opa_t opa_bottom, lv_coord_t y_bottom);
 
void lv_draw_mask_map_init(lv_draw_mask_map_param_t * param, const lv_area_t * coords, const lv_opa_t * map);
 
void lv_draw_mask_polygon_init(lv_draw_mask_polygon_param_t * param, const lv_point_t * points, uint16_t point_cnt);
 
#endif /*LV_DRAW_COMPLEX*/
 
/**********************
 *      MACROS
 **********************/
 
#ifdef __cplusplus
} /*extern "C"*/
#endif
 
#endif /*LV_DRAW_MASK_H*/