Embedded/lvgl
1
0
Fork 0
mirror of https://github.com/lvgl/lvgl.git synced 2025-01-28 07:03:00 +08:00
Code Issues Projects Releases Wiki Activity

lv_area: add 'lv_' prefix

Browse Source
This commit is contained in:
Gabor Kiss-Vamosi 2017-11-28 16:15:13 +01:00
parent 83b01aa627
commit 2d09b3dbdf
24 changed files with 241 additions and 155 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

0
.gitmodules vendored
View File

50
lv_draw/lv_draw.c
View File

@ -92,7 +92,7 @@ static void (*map_fp)(const lv_area_t * coords, const lv_area_t * mask, const lv
*/
void lv_draw_rect(const lv_area_t * coords, const lv_area_t * mask, const lv_style_t * style)
{
if(area_get_height(coords) < 1 || area_get_width(coords) < 1) return;
if(lv_area_get_height(coords) < 1 || lv_area_get_width(coords) < 1) return;
#if LV_NO_SHADOW == 0
if(style->body.shadow.width != 0) {
@ -241,7 +241,7 @@ void lv_draw_label(const lv_area_t * coords,const lv_area_t * mask, const lv_sty
lv_coord_t w;
if((flag & LV_TXT_FLAG_EXPAND) == 0) {
w = area_get_width(coords);
w = lv_area_get_width(coords);
} else {
lv_point_t p;
lv_txt_get_size(&p, txt, style->text.font, style->text.letter_space, style->text.line_space, LV_COORD_MAX, flag);
@ -367,7 +367,7 @@ void lv_draw_img(const lv_area_t * coords, const lv_area_t * mask,
/*If the width is greater then real img. width then it is upscaled */
bool upscale = false;
if(area_get_width(coords) > header.w) upscale = true;
if(lv_area_get_width(coords) > header.w) upscale = true;
lv_area_t mask_com; /*Common area of mask and cords*/
bool union_ok;
@ -408,16 +408,16 @@ void lv_draw_img(const lv_area_t * coords, const lv_area_t * mask,
/* Move the file pointer to the start address according to mask
* But take care, the upscaled maps look greater*/
uint32_t start_offset = sizeof(lv_img_raw_header_t);
start_offset += (area_get_width(coords) >> us_shift) *
start_offset += (lv_area_get_width(coords) >> us_shift) *
((mask_com.y1 - coords->y1) >> us_shift) * sizeof(lv_color_t); /*First row*/
start_offset += ((mask_com.x1 - coords->x1) >> us_shift) * sizeof(lv_color_t); /*First col*/
lv_fs_seek(&file, start_offset);
uint32_t useful_data = (area_get_width(&mask_com) >> us_shift) * sizeof(lv_color_t);
uint32_t next_row = (area_get_width(coords) >> us_shift) * sizeof(lv_color_t) - useful_data;
uint32_t useful_data = (lv_area_get_width(&mask_com) >> us_shift) * sizeof(lv_color_t);
uint32_t next_row = (lv_area_get_width(coords) >> us_shift) * sizeof(lv_color_t) - useful_data;
lv_area_t line;
area_cpy(&line, &mask_com);
lv_area_copy(&line, &mask_com);
lv_area_set_height(&line, us_val); /*Create a line area. Hold 2 pixels if upscaled*/
lv_coord_t row;
@ -594,8 +594,8 @@ static void lv_draw_rect_main_mid(const lv_area_t * coords, const lv_area_t * ma
lv_color_t gcolor = style->body.grad_color;
uint8_t mix;
lv_opa_t opa = style->body.opa;
lv_coord_t height = area_get_height(coords);
lv_coord_t width = area_get_width(coords);
lv_coord_t height = lv_area_get_height(coords);
lv_coord_t width = lv_area_get_width(coords);
radius = lv_draw_cont_radius_corr(radius, width, height);
@ -645,8 +645,8 @@ static void lv_draw_rect_main_corner(const lv_area_t * coords, const lv_area_t *
lv_color_t act_color;
lv_opa_t opa = style->body.opa;
uint8_t mix;
lv_coord_t height = area_get_height(coords);
lv_coord_t width = area_get_width(coords);
lv_coord_t height = lv_area_get_height(coords);
lv_coord_t width = lv_area_get_width(coords);
radius = lv_draw_cont_radius_corr(radius, width, height);
@ -841,8 +841,8 @@ static void lv_draw_rect_border_straight(const lv_area_t * coords, const lv_area
{
uint16_t radius = style->body.radius;
lv_coord_t width = area_get_width(coords);
lv_coord_t height = area_get_height(coords);
lv_coord_t width = lv_area_get_width(coords);
lv_coord_t height = lv_area_get_height(coords);
uint16_t bwidth = style->body.border.width;
lv_opa_t opa = style->body.border.opa;
lv_border_part_t part = style->body.border.part;
@ -1004,8 +1004,8 @@ static void lv_draw_rect_border_corner(const lv_area_t * coords, const lv_area_t
/*0 px border width drawn as 1 px, so decrement the bwidth*/
bwidth--;
lv_coord_t width = area_get_width(coords);
lv_coord_t height = area_get_height(coords);
lv_coord_t width = lv_area_get_width(coords);
lv_coord_t height = lv_area_get_height(coords);
radius = lv_draw_cont_radius_corr(radius, width, height);
@ -1141,19 +1141,19 @@ static void lv_draw_rect_shadow(const lv_area_t * coords, const lv_area_t * mask
{
/* If mask is in the middle of cords do not draw shadow*/
lv_coord_t radius = style->body.radius;
lv_coord_t width = area_get_width(coords);
lv_coord_t height = area_get_height(coords);
lv_coord_t width = lv_area_get_width(coords);
lv_coord_t height = lv_area_get_height(coords);
radius = lv_draw_cont_radius_corr(radius, width, height);
lv_area_t area_tmp;
/*Check horizontally without radius*/
area_cpy(&area_tmp, coords);
lv_area_copy(&area_tmp, coords);
area_tmp.x1 += radius;
area_tmp.x2 -= radius;
if(lv_area_is_in(mask, &area_tmp) != false) return;
/*Check vertically without radius*/
area_cpy(&area_tmp, coords);
lv_area_copy(&area_tmp, coords);
area_tmp.y1 += radius;
area_tmp.y2 -= radius;
if(lv_area_is_in(mask, &area_tmp) != false) return;
@ -1169,8 +1169,8 @@ static void lv_draw_cont_shadow_full(const lv_area_t * coords, const lv_area_t *
{
lv_coord_t radius = style->body.radius;
lv_coord_t width = area_get_width(coords);
lv_coord_t height = area_get_height(coords);
lv_coord_t width = lv_area_get_width(coords);
lv_coord_t height = lv_area_get_height(coords);
radius = lv_draw_cont_radius_corr(radius, width, height);
@ -1310,8 +1310,8 @@ static void lv_draw_cont_shadow_bottom(const lv_area_t * coords, const lv_area_t
{
lv_coord_t radius = style->body.radius;
lv_coord_t width = area_get_width(coords);
lv_coord_t height = area_get_height(coords);
lv_coord_t width = lv_area_get_width(coords);
lv_coord_t height = lv_area_get_height(coords);
radius = lv_draw_cont_radius_corr(radius, width, height);
@ -1382,8 +1382,8 @@ static void lv_draw_cont_shadow_full_straight(const lv_area_t * coords, const lv
lv_coord_t radius = style->body.radius;
lv_coord_t width = area_get_width(coords);
lv_coord_t height = area_get_height(coords);
lv_coord_t width = lv_area_get_width(coords);
lv_coord_t height = lv_area_get_height(coords);
radius = lv_draw_cont_radius_corr(radius, width, height);

10
lv_draw/lv_draw_rbasic.c
View File

@ -187,14 +187,14 @@ void lv_rmap(const lv_area_t * cords_p, const lv_area_t * mask_p,
if(union_ok == false) return;
/*Go to the first pixel*/
lv_coord_t map_width = area_get_width(cords_p);
lv_coord_t map_width = lv_area_get_width(cords_p);
map_p+= (masked_a.y1 - cords_p->y1) * map_width;
map_p += masked_a.x1 - cords_p->x1;
if(transp == false) {
lv_coord_t row;
lv_coord_t mask_w = area_get_width(&masked_a) - 1;
for(row = 0; row < area_get_height(&masked_a); row++) {
lv_coord_t mask_w = lv_area_get_width(&masked_a) - 1;
for(row = 0; row < lv_area_get_height(&masked_a); row++) {
lv_disp_map(masked_a.x1, masked_a.y1 + row, masked_a.x1 + mask_w, masked_a.y1 + row, map_p);
map_p += map_width;
@ -202,9 +202,9 @@ void lv_rmap(const lv_area_t * cords_p, const lv_area_t * mask_p,
}else {
lv_color_t transp_color = LV_COLOR_TRANSP;
lv_coord_t row;
for(row = 0; row < area_get_height(&masked_a); row++) {
for(row = 0; row < lv_area_get_height(&masked_a); row++) {
lv_coord_t col;
for(col = 0; col < area_get_width(&masked_a); col ++) {
for(col = 0; col < lv_area_get_width(&masked_a); col ++) {
if(map_p[col].full != transp_color.full) {
lv_rpx(masked_a.x1 + col, masked_a.y1 + row, mask_p, map_p[col], opa);
}

97
lv_draw/lv_draw_vbasic.c
View File

@ -26,6 +26,7 @@
/*********************
* DEFINES
*********************/
#define VFILL_HW_ACC_WIDTH_LIMIT 50 /*Always fill < 50 px with 'sw_color_fill' because of the hw. init overhead*/
/**********************
* TYPEDEFS
@ -34,7 +35,7 @@
/**********************
* STATIC PROTOTYPES
**********************/
static void sw_color_cpy(lv_color_t * dest, const lv_color_t * src, uint32_t length, lv_opa_t opa);
static void sw_mem_blend(lv_color_t * dest, const lv_color_t * src, uint32_t length, lv_opa_t opa);
static void sw_color_fill(lv_area_t * mem_area, lv_color_t * mem, const lv_area_t * fill_area, lv_color_t color, lv_opa_t opa);
/**********************
@ -68,7 +69,7 @@ void lv_vpx(lv_coord_t x, lv_coord_t y, const lv_area_t * mask_p, lv_color_t col
return;
}
uint32_t vdb_width = area_get_width(&vdb_p->area);
uint32_t vdb_width = lv_area_get_width(&vdb_p->area);
/*Make the coordinates relative to VDB*/
x-=vdb_p->area.x1;
@ -94,6 +95,10 @@ void lv_vpx(lv_coord_t x, lv_coord_t y, const lv_area_t * mask_p, lv_color_t col
void lv_vfill(const lv_area_t * cords_p, const lv_area_t * mask_p,
lv_color_t color, lv_opa_t opa)
{
/*Used to store color maps for blending*/
static lv_color_t color_map[LV_HOR_RES];
static lv_coord_t last_width = 0;
lv_area_t res_a;
bool union_ok;
lv_vdb_t * vdb_p = lv_vdb_get();
@ -113,28 +118,65 @@ void lv_vfill(const lv_area_t * cords_p, const lv_area_t * mask_p,
vdb_rel_a.y2 = res_a.y2 - vdb_p->area.y1;
lv_color_t * vdb_buf_tmp = vdb_p->buf;
uint32_t vdb_width = area_get_width(&vdb_p->area);
uint32_t vdb_width = lv_area_get_width(&vdb_p->area);
/*Move the vdb_tmp to the first row*/
vdb_buf_tmp += vdb_width * vdb_rel_a.y1;
if(lv_disp_is_copy_supported() == false) {
lv_coord_t w = lv_area_get_width(&vdb_rel_a);
if(w < VFILL_HW_ACC_WIDTH_LIMIT) { /*Don't use hw. acc. for every small fill (because of the init overhead)*/
sw_color_fill(&vdb_p->area, vdb_buf_tmp, &vdb_rel_a, color, opa);
} else {
static lv_color_t color_map[LV_HOR_RES];
static lv_coord_t last_width = 0;
lv_coord_t map_width = area_get_width(&vdb_rel_a);
if(color_map[0].full != color.full || last_width != map_width) {
uint16_t i;
for(i = 0; i < map_width; i++) {
color_map[i].full = color.full;
} else if(opa == LV_OPA_COVER) {
/*Use hw fill if present*/
if(lv_disp_is_mem_fill_supported()) {
lv_coord_t row;
for(row = vdb_rel_a.y1;row <= vdb_rel_a.y2; row++) {
lv_disp_mem_fill(&vdb_buf_tmp[vdb_rel_a.x1], w, color);
vdb_buf_tmp += vdb_width;
}
}
/*Use hw blend if present and the area is not too small*/
else if(lv_area_get_height(&vdb_rel_a) > VFILL_HW_ACC_WIDTH_LIMIT &&
lv_disp_is_mem_blend_supported())
{
if(color_map[0].full != color.full || last_width != w) {
uint16_t i;
for(i = 0; i < w; i++) {
color_map[i].full = color.full;
}
last_width = w;
}
lv_coord_t row;
for(row = vdb_rel_a.y1;row <= vdb_rel_a.y2; row++) {
lv_disp_mem_blend(&vdb_buf_tmp[vdb_rel_a.x1], color_map, w, opa);
vdb_buf_tmp += vdb_width;
}
last_width = map_width;
}
lv_coord_t row;
for(row = vdb_rel_a.y1;row <= vdb_rel_a.y2; row++) {
lv_disp_copy(&vdb_buf_tmp[vdb_rel_a.x1], color_map, map_width, opa);
vdb_buf_tmp += vdb_width;
/*Else use sw fill if no better option*/
else {
sw_color_fill(&vdb_p->area, vdb_buf_tmp, &vdb_rel_a, color, opa);
}
}
/*Opacity*/
else
{
if(lv_disp_is_mem_blend_supported() == false) {
sw_color_fill(&vdb_p->area, vdb_buf_tmp, &vdb_rel_a, color, opa);
} else {
if(color_map[0].full != color.full || last_width != w) {
uint16_t i;
for(i = 0; i < w; i++) {
color_map[i].full = color.full;
}
last_width = w;
}
lv_coord_t row;
for(row = vdb_rel_a.y1;row <= vdb_rel_a.y2; row++) {
lv_disp_mem_blend(&vdb_buf_tmp[vdb_rel_a.x1], color_map, w, opa);
vdb_buf_tmp += vdb_width;
}
}
}
}
@ -166,7 +208,7 @@ void lv_vletter(const lv_point_t * pos_p, const lv_area_t * mask_p,
pos_p->y + letter_h < mask_p->y1 || pos_p->y > mask_p->y2) return;
lv_vdb_t * vdb_p = lv_vdb_get();
lv_coord_t vdb_width = area_get_width(&vdb_p->area);
lv_coord_t vdb_width = lv_area_get_width(&vdb_p->area);
lv_color_t * vdb_buf_tmp = vdb_p->buf;
lv_coord_t col, row;
uint8_t col_bit;
@ -295,7 +337,7 @@ void lv_vmap(const lv_area_t * cords_p, const lv_area_t * mask_p,
if(upscale != false) ds_shift = 1;
/*If the map starts OUT of the masked area then calc. the first pixel*/
lv_coord_t map_width = area_get_width(cords_p) >> ds_shift;
lv_coord_t map_width = lv_area_get_width(cords_p) >> ds_shift;
if(cords_p->y1 < masked_a.y1) {
map_p += (uint32_t) map_width * ((masked_a.y1 - cords_p->y1) >> ds_shift);
}
@ -309,7 +351,7 @@ void lv_vmap(const lv_area_t * cords_p, const lv_area_t * mask_p,
masked_a.x2 = masked_a.x2 - vdb_p->area.x1;
masked_a.y2 = masked_a.y2 - vdb_p->area.y1;
lv_coord_t vdb_width = area_get_width(&vdb_p->area);
lv_coord_t vdb_width = lv_area_get_width(&vdb_p->area);
lv_color_t * vdb_buf_tmp = vdb_p->buf;
vdb_buf_tmp += (uint32_t) vdb_width * masked_a.y1; /*Move to the first row*/
@ -319,13 +361,13 @@ void lv_vmap(const lv_area_t * cords_p, const lv_area_t * mask_p,
if(upscale == false) {
if(transp == false) { /*Simply copy the pixels to the VDB*/
lv_coord_t row;
lv_coord_t map_useful_w = area_get_width(&masked_a);
lv_coord_t map_useful_w = lv_area_get_width(&masked_a);
for(row = masked_a.y1; row <= masked_a.y2; row++) {
if(lv_disp_is_copy_supported() == false) {
sw_color_cpy(&vdb_buf_tmp[masked_a.x1], &map_p[masked_a.x1], map_useful_w, opa);
if(lv_disp_is_mem_blend_supported() == false) {
sw_mem_blend(&vdb_buf_tmp[masked_a.x1], &map_p[masked_a.x1], map_useful_w, opa);
} else {
lv_disp_copy(&vdb_buf_tmp[masked_a.x1], &map_p[masked_a.x1], map_useful_w, opa);
lv_disp_mem_blend(&vdb_buf_tmp[masked_a.x1], &map_p[masked_a.x1], map_useful_w, opa);
}
map_p += map_width; /*Next row on the map*/
vdb_buf_tmp += vdb_width; /*Next row on the VDB*/
@ -463,13 +505,13 @@ void lv_vmap(const lv_area_t * cords_p, const lv_area_t * mask_p,
**********************/
/**
* Copy pixels to destination memory using opacity
* Blend pixels to destination memory using opacity
* @param dest a memory address. Copy 'src' here.
* @param src pointer to pixel map. Copy it to 'dest'.
* @param length number of pixels in 'src'
* @param opa opacity (0, LV_OPA_TRANSP: transparent ... 255, LV_OPA_COVER, fully cover)
*/
static void sw_color_cpy(lv_color_t * dest, const lv_color_t * src, uint32_t length, lv_opa_t opa)
static void sw_mem_blend(lv_color_t * dest, const lv_color_t * src, uint32_t length, lv_opa_t opa)
{
if(opa == LV_OPA_COVER) {
memcpy(dest, src, length * sizeof(lv_color_t));
@ -494,7 +536,7 @@ static void sw_color_fill(lv_area_t * mem_area, lv_color_t * mem, const lv_area_
/*Set all row in vdb to the given color*/
lv_coord_t row;
uint32_t col;
lv_coord_t mem_width = area_get_width(mem_area);
lv_coord_t mem_width = lv_area_get_width(mem_area);
/*Run simpler function without opacity*/
if(opa == LV_OPA_COVER) {
@ -502,6 +544,7 @@ static void sw_color_fill(lv_area_t * mem_area, lv_color_t * mem, const lv_area_
for(col = fill_area->x1; col <= fill_area->x2; col++) {
mem[col] = color;
}
/*Copy the first row to all other rows*/
lv_color_t * mem_first = &mem[fill_area->x1];
lv_coord_t copy_size = (fill_area->x2 - fill_area->x1 + 1) * sizeof(lv_color_t);

53
lv_hal/lv_hal_disp.c
View File

@ -13,6 +13,7 @@
#include <stddef.h>
#include "../lv_hal/lv_hal_disp.h"
#include "../lv_misc/lv_mem.h"
#include "../lv_obj/lv_obj.h"
/*********************
* DEFINES
@ -48,9 +49,10 @@ static lv_disp_t *active;
*/
void lv_disp_drv_init(lv_disp_drv_t *driver)
{
driver->fill_fp = NULL;
driver->map_fp = NULL;
driver->blend_fp = NULL;
driver->disp_fill = NULL;
driver->disp_map = NULL;
driver->mem_blend = NULL;
driver->mem_fill = NULL;
}
/**
@ -73,6 +75,7 @@ lv_disp_t * lv_disp_drv_register(lv_disp_drv_t *driver)
if (disp_list == NULL) {
disp_list = node;
active = node;
lv_obj_invalidate(lv_scr_act());
} else {
node->next = disp_list;
}
@ -88,6 +91,7 @@ lv_disp_t * lv_disp_drv_register(lv_disp_drv_t *driver)
void lv_disp_set_active(lv_disp_t * disp)
{
active = disp;
lv_obj_invalidate(lv_scr_act());
}
/**
@ -125,7 +129,7 @@ lv_disp_t * lv_disp_next(lv_disp_t * disp)
void lv_disp_fill(int32_t x1, int32_t y1, int32_t x2, int32_t y2, lv_color_t color)
{
if(active == NULL) return;
if(active->driver.fill_fp != NULL) active->driver.fill_fp(x1, y1, x2, y2, color);
if(active->driver.disp_fill != NULL) active->driver.disp_fill(x1, y1, x2, y2, color);
}
/**
@ -139,31 +143,54 @@ void lv_disp_fill(int32_t x1, int32_t y1, int32_t x2, int32_t y2, lv_color_t col
void lv_disp_map(int32_t x1, int32_t y1, int32_t x2, int32_t y2, const lv_color_t * color_map)
{
if(active == NULL) return;
if(active->driver.map_fp != NULL) active->driver.map_fp(x1, y1, x2, y2, color_map);
if(active->driver.disp_map != NULL) active->driver.disp_map(x1, y1, x2, y2, color_map);
}
/**
* Blend pixels to a destination memory from a source memory
* In 'lv_disp_drv_t' 'mem_blend' is optional. (NULL if not available)
* @param dest a memory address. Blend 'src' here.
* @param src pointer to pixel map. Blend it to 'dest'.
* @param length number of pixels in 'src'
* @param opa opacity (0, LV_OPA_TRANSP: transparent ... 255, LV_OPA_COVER, fully cover)
*/
void lv_disp_mem_blend(lv_color_t * dest, const lv_color_t * src, uint32_t length, lv_opa_t opa)
{
if(active == NULL) return;
if(active->driver.mem_blend != NULL) active->driver.mem_blend(dest, src, length, opa);
}
/**
* Copy pixels to a destination memory applying opacity
* In 'lv_disp_drv_t' 'copy' is optional. (NULL to use the built-in copy function)
* Fill a memory with a color (GPUs may support it)
* In 'lv_disp_drv_t' 'mem_fill' is optional. (NULL if not available)
* @param dest a memory address. Copy 'src' here.
* @param src pointer to pixel map. Copy it to 'dest'.
* @param length number of pixels in 'src'
* @param opa opacity (0, LV_OPA_TRANSP: transparent ... 255, LV_OPA_COVER, fully cover)
*/
void lv_disp_copy(lv_color_t * dest, const lv_color_t * src, uint32_t length, lv_opa_t opa)
void lv_disp_mem_fill(lv_color_t * dest, uint32_t length, lv_color_t color)
{
if(active == NULL) return;
if(active->driver.blend_fp != NULL) active->driver.blend_fp(dest, src, length, opa);
if(active->driver.mem_fill != NULL) active->driver.mem_fill(dest, length, color);
}
/**
* Shows if 'copy' is supported or not
* @return false: 'copy' is not supported in the drover; true: 'copy' is supported in the driver
* Shows if memory blending (by GPU) is supported or not
* @return false: 'mem_blend' is not supported in the driver; true: 'mem_blend' is supported in the driver
*/
bool lv_disp_is_copy_supported(void)
bool lv_disp_is_mem_blend_supported(void)
{
if(active->driver.blend_fp) return true;
if(active->driver.mem_blend) return true;
else return false;
}
/**
* Shows if memory fill (by GPU) is supported or not
* @return false: 'mem_fill' is not supported in the drover; true: 'mem_fill' is supported in the driver
*/
bool lv_disp_is_mem_fill_supported(void)
{
if(active->driver.mem_fill) return true;
else return false;
}

34
lv_hal/lv_hal_disp.h
View File

@ -32,9 +32,10 @@ extern "C" {
* Display Driver structure to be registered by HAL
*/
typedef struct _disp_drv_t {
void (*fill_fp)(int32_t x1, int32_t y1, int32_t x2, int32_t y2, lv_color_t color);
void (*map_fp)(int32_t x1, int32_t y1, int32_t x2, int32_t y2, const lv_color_t * color_p);
void (*blend_fp)(lv_color_t * dest, const lv_color_t * src, uint32_t length, lv_opa_t opa);
void (*disp_fill)(int32_t x1, int32_t y1, int32_t x2, int32_t y2, lv_color_t color);
void (*disp_map)(int32_t x1, int32_t y1, int32_t x2, int32_t y2, const lv_color_t * color_p);
void (*mem_blend)(lv_color_t * dest, const lv_color_t * src, uint32_t length, lv_opa_t opa);
void (*mem_fill)(lv_color_t * dest, uint32_t length, lv_color_t color);
} lv_disp_drv_t;
typedef struct _disp_t {
@ -102,20 +103,35 @@ void lv_disp_fill(int32_t x1, int32_t y1, int32_t x2, int32_t y2, lv_color_t col
void lv_disp_map(int32_t x1, int32_t y1, int32_t x2, int32_t y2, const lv_color_t * color_map);
/**
* Copy pixels to a destination memory applying opacity
* In 'lv_disp_drv_t' 'copy' is optional. (NULL to use the built-in copy function)
* Blend pixels to a destination memory from a source memory
* In 'lv_disp_drv_t' 'mem_blend' is optional. (NULL if not available)
* @param dest a memory address. Blend 'src' here.
* @param src pointer to pixel map. Blend it to 'dest'.
* @param length number of pixels in 'src'
* @param opa opacity (0, LV_OPA_TRANSP: transparent ... 255, LV_OPA_COVER, fully cover)
*/
void lv_disp_mem_blend(lv_color_t * dest, const lv_color_t * src, uint32_t length, lv_opa_t opa);
/**
* Fill a memory with a color (GPUs may support it)
* In 'lv_disp_drv_t' 'mem_fill' is optional. (NULL if not available)
* @param dest a memory address. Copy 'src' here.
* @param src pointer to pixel map. Copy it to 'dest'.
* @param length number of pixels in 'src'
* @param opa opacity (0, LV_OPA_TRANSP: transparent ... 255, LV_OPA_COVER, fully cover)
*/
void lv_disp_copy(lv_color_t * dest, const lv_color_t * src, uint32_t length, lv_opa_t opa);
void lv_disp_mem_fill(lv_color_t * dest, uint32_t length, lv_color_t color);
/**
* Shows if memory blending (by GPU) is supported or not
* @return false: 'mem_blend' is not supported in the driver; true: 'mem_blend' is supported in the driver
*/
bool lv_disp_is_mem_blend_supported(void);
/**
* Shows if 'copy' is supported or not
* @return false: 'copy' is not supported in the drover; true: 'copy' is supported in the driver
* Shows if memory fill (by GPU) is supported or not
* @return false: 'mem_fill' is not supported in the drover; true: 'mem_fill' is supported in the driver
*/
bool lv_disp_is_copy_supported(void);
bool lv_disp_is_mem_fill_supported(void);
/**********************
* MACROS

2
lv_misc/lv_anim.h
View File

@ -14,7 +14,7 @@ extern "C" {
/*********************
* INCLUDES
*********************/
#include "../../../lv_conf.h"
#include "../../lv_conf.h"
#if LV_NO_ANIM == 0
#include <stdint.h>

4
lv_misc/lv_area.c
View File

@ -77,8 +77,8 @@ void lv_area_set_height(lv_area_t * area_p, lv_coord_t h)
*/
void lv_area_set_pos(lv_area_t * area_p, lv_coord_t x, lv_coord_t y)
{
lv_coord_t w = area_get_width(area_p);
lv_coord_t h = area_get_height(area_p);
lv_coord_t w = lv_area_get_width(area_p);
lv_coord_t h = lv_area_get_height(area_p);
area_p->x1 = x;
area_p->y1 = y;
lv_area_set_width(area_p, w);

6
lv_misc/lv_area.h
View File

@ -62,7 +62,7 @@ void lv_area_set(lv_area_t * area_p, lv_coord_t x1, lv_coord_t y1, lv_coord_t x2
* @param dest pointer to the destination area
* @param src pointer to the source area
*/
static void inline area_cpy(lv_area_t * dest, const lv_area_t * src)
static void inline lv_area_copy(lv_area_t * dest, const lv_area_t * src)
{
memcpy(dest, src, sizeof(lv_area_t));
}
@ -72,7 +72,7 @@ static void inline area_cpy(lv_area_t * dest, const lv_area_t * src)
* @param area_p pointer to an area
* @return the width of the area (if x1 == x2 -> width = 1)
*/
static inline lv_coord_t area_get_width(const lv_area_t * area_p)
static inline lv_coord_t lv_area_get_width(const lv_area_t * area_p)
{
return area_p->x2 - area_p->x1 + 1;
}
@ -82,7 +82,7 @@ static inline lv_coord_t area_get_width(const lv_area_t * area_p)
* @param area_p pointer to an area
* @return the height of the area (if y1 == y2 -> height = 1)
*/
static inline lv_coord_t area_get_height(const lv_area_t * area_p)
static inline lv_coord_t lv_area_get_height(const lv_area_t * area_p)
{
return area_p->y2 - area_p->y1 + 1;
}

10
lv_obj/lv_obj.c
View File

@ -214,7 +214,7 @@ lv_obj_t * lv_obj_create(lv_obj_t * parent, lv_obj_t * copy)
}
if(copy != NULL) {
area_cpy(&new_obj->coords, &copy->coords);
lv_area_copy(&new_obj->coords, &copy->coords);
new_obj->ext_size = copy->ext_size;
/*Set free data*/
@ -357,7 +357,7 @@ void lv_obj_invalidate(lv_obj_t * obj)
bool union_ok = true;
/*Start with the original coordinates*/
lv_coord_t ext_size = obj->ext_size;
area_cpy(&area_trunc, &obj->coords);
lv_area_copy(&area_trunc, &obj->coords);
area_trunc.x1 -= ext_size;
area_trunc.y1 -= ext_size;
area_trunc.x2 += ext_size;
@ -1122,7 +1122,7 @@ uint16_t lv_obj_count_children(lv_obj_t * obj)
*/
void lv_obj_get_coords(lv_obj_t * obj, lv_area_t * cords_p)
{
area_cpy(cords_p, &obj->coords);
lv_area_copy(cords_p, &obj->coords);
}
@ -1161,7 +1161,7 @@ lv_coord_t lv_obj_get_y(lv_obj_t * obj)
*/
lv_coord_t lv_obj_get_width(lv_obj_t * obj)
{
return area_get_width(&obj->coords);
return lv_area_get_width(&obj->coords);
}
/**
@ -1171,7 +1171,7 @@ lv_coord_t lv_obj_get_width(lv_obj_t * obj)
*/
lv_coord_t lv_obj_get_height(lv_obj_t * obj)
{
return area_get_height(&obj->coords);
return lv_area_get_height(&obj->coords);
}
/**

10
lv_obj/lv_refr.c
View File

@ -115,10 +115,10 @@ void lv_inv_area(const lv_area_t * area_p)
/*Save the area*/
if(inv_buf_p < LV_INV_FIFO_SIZE) {
area_cpy(&inv_buf[inv_buf_p].area,&com_area);
lv_area_copy(&inv_buf[inv_buf_p].area,&com_area);
} else {/*If no place for the area add the screen*/
inv_buf_p = 0;
area_cpy(&inv_buf[inv_buf_p].area,&scr_area);
lv_area_copy(&inv_buf[inv_buf_p].area,&scr_area);
}
inv_buf_p ++;
}
@ -199,7 +199,7 @@ static void lv_refr_join_area(void)
/*Join two area only if the joined area size is smaller*/
if(lv_area_get_size(&joined_area) <
(lv_area_get_size(&inv_buf[join_in].area) + lv_area_get_size(&inv_buf[join_from].area))) {
area_cpy(&inv_buf[join_in].area, &joined_area);
lv_area_copy(&inv_buf[join_in].area, &joined_area);
/*Mark 'join_form' is joined into 'join_in'*/
inv_buf[join_from].joined = 1;
@ -257,8 +257,8 @@ static void lv_refr_area_no_vdb(const lv_area_t * area_p)
static void lv_refr_area_with_vdb(const lv_area_t * area_p)
{
/*Calculate the max row num*/
uint32_t max_row = (uint32_t) LV_VDB_SIZE / (area_get_width(area_p));
if(max_row > area_get_height(area_p)) max_row = area_get_height(area_p);
uint32_t max_row = (uint32_t) LV_VDB_SIZE / (lv_area_get_width(area_p));
if(max_row > lv_area_get_height(area_p)) max_row = lv_area_get_height(area_p);
/*Round the row number with downscale*/
#if LV_ANTIALIAS == 1

2
lv_obj/lv_vdb.c
View File

@ -111,7 +111,7 @@ void lv_vdb_flush(void)
* */
lv_coord_t x;
lv_coord_t y;
lv_coord_t w = area_get_width(&vdb_act->area);
lv_coord_t w = lv_area_get_width(&vdb_act->area);
lv_color_t * in1_buf = vdb_act->buf; /*Pointer to the first row*/
lv_color_t * in2_buf = vdb_act->buf + w; /*Pointer to the second row*/
lv_color_t * out_buf = vdb_act->buf; /*Store the result here*/

6
lv_objx/lv_bar.c
View File

@ -276,14 +276,14 @@ static bool lv_bar_design(lv_obj_t * bar, const lv_area_t * mask, lv_design_mode
lv_style_t *style_indic = lv_bar_get_style(bar, LV_BAR_STYLE_INDIC);
lv_area_t indic_area;
area_cpy(&indic_area, &bar->coords);
lv_area_copy(&indic_area, &bar->coords);
indic_area.x1 += style_indic->body.padding.hor;
indic_area.x2 -= style_indic->body.padding.hor;
indic_area.y1 += style_indic->body.padding.ver;
indic_area.y2 -= style_indic->body.padding.ver;
lv_coord_t w = area_get_width(&indic_area);
lv_coord_t h = area_get_height(&indic_area);
lv_coord_t w = lv_area_get_width(&indic_area);
lv_coord_t h = lv_area_get_height(&indic_area);
if(w >= h) {
indic_area.x2 = (int32_t) ((int32_t)w * (ext->cur_value - ext->min_value)) / (ext->max_value - ext->min_value);

18
lv_objx/lv_btnm.c
View File

@ -400,14 +400,14 @@ static bool lv_btnm_design(lv_obj_t * btnm, const lv_area_t * mask, lv_design_mo
/*Skip hidden buttons*/
if(button_is_hidden(ext->map_p[txt_i])) continue;
area_cpy(&area_tmp, &ext->button_areas[btn_i]);
lv_area_copy(&area_tmp, &ext->button_areas[btn_i]);
area_tmp.x1 += area_btnm.x1;
area_tmp.y1 += area_btnm.y1;
area_tmp.x2 += area_btnm.x1;
area_tmp.y2 += area_btnm.y1;
btn_w = area_get_width(&area_tmp);
btn_h = area_get_height(&area_tmp);
btn_w = lv_area_get_width(&area_tmp);
btn_h = lv_area_get_height(&area_tmp);
/*Load the style*/
if(button_is_inactive(ext->map_p[txt_i])) btn_style = lv_btnm_get_style(btnm, LV_BTNM_STYLE_BTN_INA);
@ -437,7 +437,7 @@ static bool lv_btnm_design(lv_obj_t * btnm, const lv_area_t * mask, lv_design_mo
lv_point_t txt_size;
lv_txt_get_size(&txt_size, ext->map_p[txt_i], font,
btn_style->text.letter_space, btn_style->text.line_space,
area_get_width(&area_btnm), LV_TXT_FLAG_NONE);
lv_area_get_width(&area_btnm), LV_TXT_FLAG_NONE);
area_tmp.x1 += (btn_w - txt_size.x) / 2;
area_tmp.y1 += (btn_h - txt_size.y) / 2;
@ -487,7 +487,7 @@ static lv_res_t lv_btnm_signal(lv_obj_t * btnm, lv_signal_t sign, void * param)
if(btn_pr != ext->btn_id_pr) {
lv_indev_reset_lpr(param);
if(ext->btn_id_pr != LV_BTNM_PR_NONE) {
area_cpy(&btn_area, &ext->button_areas[ext->btn_id_pr]);
lv_area_copy(&btn_area, &ext->button_areas[ext->btn_id_pr]);
btn_area.x1 += btnm_area.x1;
btn_area.y1 += btnm_area.y1;
btn_area.x2 += btnm_area.x1;
@ -495,7 +495,7 @@ static lv_res_t lv_btnm_signal(lv_obj_t * btnm, lv_signal_t sign, void * param)
lv_inv_area(&btn_area);
}
if(btn_pr != LV_BTNM_PR_NONE) {
area_cpy(&btn_area, &ext->button_areas[btn_pr]);
lv_area_copy(&btn_area, &ext->button_areas[btn_pr]);
btn_area.x1 += btnm_area.x1;
btn_area.y1 += btnm_area.y1;
btn_area.x2 += btnm_area.x1;
@ -529,7 +529,7 @@ static lv_res_t lv_btnm_signal(lv_obj_t * btnm, lv_signal_t sign, void * param)
/*Invalidate to old pressed area*/;
lv_obj_get_coords(btnm, &btnm_area);
area_cpy(&btn_area, &ext->button_areas[ext->btn_id_pr]);
lv_area_copy(&btn_area, &ext->button_areas[ext->btn_id_pr]);
btn_area.x1 += btnm_area.x1;
btn_area.y1 += btnm_area.y1;
btn_area.x2 += btnm_area.x1;
@ -538,7 +538,7 @@ static lv_res_t lv_btnm_signal(lv_obj_t * btnm, lv_signal_t sign, void * param)
if(ext->toggle != 0) {
/*Invalidate to old toggled area*/;
area_cpy(&btn_area, &ext->button_areas[ext->btn_id_tgl]);
lv_area_copy(&btn_area, &ext->button_areas[ext->btn_id_tgl]);
btn_area.x1 += btnm_area.x1;
btn_area.y1 += btnm_area.y1;
btn_area.x2 += btnm_area.x1;
@ -682,7 +682,7 @@ static uint16_t get_button_from_point(lv_obj_t * btnm, lv_point_t * p)
lv_obj_get_coords(btnm, &btnm_cords);
for(i = 0; i < ext->btn_cnt; i++) {
area_cpy(&btn_area, &ext->button_areas[i]);
lv_area_copy(&btn_area, &ext->button_areas[i]);
btn_area.x1 += btnm_cords.x1;
btn_area.y1 += btnm_cords.y1;
btn_area.x2 += btnm_cords.x1;

6
lv_objx/lv_cont.c
View File

@ -201,8 +201,8 @@ static lv_res_t lv_cont_signal(lv_obj_t * cont, lv_signal_t sign, void * param)
lv_cont_refr_layout(cont);
lv_cont_refr_autofit(cont);
} else if(sign == LV_SIGNAL_CORD_CHG) {
if(lv_obj_get_width(cont) != area_get_width(param) ||
lv_obj_get_height(cont) != area_get_height(param)) {
if(lv_obj_get_width(cont) != lv_area_get_width(param) ||
lv_obj_get_height(cont) != lv_area_get_height(param)) {
lv_cont_refr_layout(cont);
lv_cont_refr_autofit(cont);
}
@ -582,7 +582,7 @@ static void lv_cont_refr_autofit(lv_obj_t * cont)
cont->coords.y2 != new_cords.y2) {
lv_obj_invalidate(cont);
area_cpy(&cont->coords, &new_cords);
lv_area_copy(&cont->coords, &new_cords);
lv_obj_invalidate(cont);
/*Notify the object about its new coordinates*/

4
lv_objx/lv_label.c
View File

@ -685,8 +685,8 @@ static lv_res_t lv_label_signal(lv_obj_t * label, lv_signal_t sign, void * param
lv_label_refr_text(label);
}
else if (sign == LV_SIGNAL_CORD_CHG) {
if(area_get_width(&label->coords) != area_get_width(param) ||
area_get_height(&label->coords) != area_get_height(param))
if(lv_area_get_width(&label->coords) != lv_area_get_width(param) ||
lv_area_get_height(&label->coords) != lv_area_get_height(param))
{
lv_label_revert_dots(label);
lv_label_refr_text(label);

2
lv_objx/lv_list.c
View File

@ -479,7 +479,7 @@ static lv_res_t lv_list_signal(lv_obj_t * list, lv_signal_t sign, void * param)
if(sign == LV_SIGNAL_CORD_CHG) {
/*Be sure the width of the buttons are correct*/
lv_coord_t w = lv_obj_get_width(list);
if(w != area_get_width(param)) { /*Width changed*/
if(w != lv_area_get_width(param)) { /*Width changed*/
refr_btn_width(list);
}
}

2
lv_objx/lv_mbox.c
View File

@ -351,7 +351,7 @@ static lv_res_t lv_mbox_signal(lv_obj_t * mbox, lv_signal_t sign, void * param)
lv_mbox_ext_t * ext = lv_obj_get_ext_attr(mbox);
if(sign == LV_SIGNAL_CORD_CHG) {
if(lv_obj_get_width(mbox) != area_get_width(param)) {
if(lv_obj_get_width(mbox) != lv_area_get_width(param)) {
mbox_realign(mbox);
}

28
lv_objx/lv_page.c
View File

@ -352,7 +352,7 @@ static bool lv_page_design(lv_obj_t * scrl, const lv_area_t * mask, lv_design_mo
lv_area_t sb_area;
if(ext->sb.hor_draw) {
/*Convert the relative coordinates to absolute*/
area_cpy(&sb_area, &ext->sb.hor_area);
lv_area_copy(&sb_area, &ext->sb.hor_area);
sb_area.x1 += scrl->coords.x1;
sb_area.y1 += scrl->coords.y1;
sb_area.x2 += scrl->coords.x1;
@ -362,7 +362,7 @@ static bool lv_page_design(lv_obj_t * scrl, const lv_area_t * mask, lv_design_mo
if(ext->sb.ver_draw) {
/*Convert the relative coordinates to absolute*/
area_cpy(&sb_area, &ext->sb.ver_area);
lv_area_copy(&sb_area, &ext->sb.ver_area);
sb_area.x1 += scrl->coords.x1;
sb_area.y1 += scrl->coords.y1;
sb_area.x2 += scrl->coords.x1;
@ -463,8 +463,8 @@ static lv_res_t lv_page_signal(lv_obj_t * page, lv_signal_t sign, void * param)
}
else if(sign == LV_SIGNAL_CORD_CHG) {
/*Refresh the scrollbar and notify the scrl if the size is changed*/
if(ext->scrl != NULL && (lv_obj_get_width(page) != area_get_width(param) ||
lv_obj_get_height(page) != area_get_height(param)))
if(ext->scrl != NULL && (lv_obj_get_width(page) != lv_area_get_width(param) ||
lv_obj_get_height(page) != lv_area_get_height(param)))
{
/*If no hor_fit enabled set the scrollable's width to the page's width*/
if(lv_cont_get_hor_fit(ext->scrl) == false) {
@ -540,7 +540,7 @@ static lv_res_t lv_page_scrollable_signal(lv_obj_t * scrl, lv_signal_t sign, voi
lv_obj_get_coords(page, &page_cords);
/*scrollable width smaller then page width? -> align to left*/
if(area_get_width(&scrl_cords) + 2 * hpad < area_get_width(&page_cords)) {
if(lv_area_get_width(&scrl_cords) + 2 * hpad < lv_area_get_width(&page_cords)) {
if(scrl_cords.x1 != page_cords.x1 + hpad) {
new_x = hpad;
refr_x = true;
@ -548,7 +548,7 @@ static lv_res_t lv_page_scrollable_signal(lv_obj_t * scrl, lv_signal_t sign, voi
} else {
/*The edges of the scrollable can not be in the page (minus hpad) */
if(scrl_cords.x2 < page_cords.x2 - hpad) {
new_x = area_get_width(&page_cords) - area_get_width(&scrl_cords) - hpad; /* Right align */
new_x = lv_area_get_width(&page_cords) - lv_area_get_width(&scrl_cords) - hpad; /* Right align */
refr_x = true;
}
if (scrl_cords.x1 > page_cords.x1 + hpad) {
@ -558,7 +558,7 @@ static lv_res_t lv_page_scrollable_signal(lv_obj_t * scrl, lv_signal_t sign, voi
}
/*scrollable height smaller then page height? -> align to left*/
if(area_get_height(&scrl_cords) + 2 * vpad < area_get_height(&page_cords)) {
if(lv_area_get_height(&scrl_cords) + 2 * vpad < lv_area_get_height(&page_cords)) {
if(scrl_cords.y1 != page_cords.y1 + vpad) {
new_y = vpad;
refr_y = true;
@ -566,7 +566,7 @@ static lv_res_t lv_page_scrollable_signal(lv_obj_t * scrl, lv_signal_t sign, voi
} else {
/*The edges of the scrollable can not be in the page (minus vpad) */
if(scrl_cords.y2 < page_cords.y2 - vpad) {
new_y = area_get_height(&page_cords) - area_get_height(&scrl_cords) - vpad; /* Bottom align */
new_y = lv_area_get_height(&page_cords) - lv_area_get_height(&scrl_cords) - vpad; /* Bottom align */
refr_y = true;
}
if (scrl_cords.y1 > page_cords.y1 + vpad) {
@ -585,7 +585,7 @@ static lv_res_t lv_page_scrollable_signal(lv_obj_t * scrl, lv_signal_t sign, voi
if(page_ext->sb.mode == LV_SB_MODE_DRAG) {
lv_area_t sb_area_tmp;
if(page_ext->sb.hor_draw) {
area_cpy(&sb_area_tmp, &page_ext->sb.hor_area);
lv_area_copy(&sb_area_tmp, &page_ext->sb.hor_area);
sb_area_tmp.x1 += page->coords.x1;
sb_area_tmp.y1 += page->coords.y1;
sb_area_tmp.x2 += page->coords.x2;
@ -594,7 +594,7 @@ static lv_res_t lv_page_scrollable_signal(lv_obj_t * scrl, lv_signal_t sign, voi
page_ext->sb.hor_draw = 0;
}
if(page_ext->sb.ver_draw) {
area_cpy(&sb_area_tmp, &page_ext->sb.ver_area);
lv_area_copy(&sb_area_tmp, &page_ext->sb.ver_area);
sb_area_tmp.x1 += page->coords.x1;
sb_area_tmp.y1 += page->coords.y1;
sb_area_tmp.x2 += page->coords.x2;
@ -656,7 +656,7 @@ static void lv_page_sb_refresh(lv_obj_t * page)
/*Invalidate the current (old) scrollbar areas*/
lv_area_t sb_area_tmp;
if(ext->sb.hor_draw != 0) {
area_cpy(&sb_area_tmp, &ext->sb.hor_area);
lv_area_copy(&sb_area_tmp, &ext->sb.hor_area);
sb_area_tmp.x1 += page->coords.x1;
sb_area_tmp.y1 += page->coords.y1;
sb_area_tmp.x2 += page->coords.x2;
@ -664,7 +664,7 @@ static void lv_page_sb_refresh(lv_obj_t * page)
lv_inv_area(&sb_area_tmp);
}
if(ext->sb.ver_draw != 0) {
area_cpy(&sb_area_tmp, &ext->sb.ver_area);
lv_area_copy(&sb_area_tmp, &ext->sb.ver_area);
sb_area_tmp.x1 += page->coords.x1;
sb_area_tmp.y1 += page->coords.y1;
sb_area_tmp.x2 += page->coords.x2;
@ -718,7 +718,7 @@ static void lv_page_sb_refresh(lv_obj_t * page)
/*Invalidate the new scrollbar areas*/
if(ext->sb.hor_draw != 0) {
area_cpy(&sb_area_tmp, &ext->sb.hor_area);
lv_area_copy(&sb_area_tmp, &ext->sb.hor_area);
sb_area_tmp.x1 += page->coords.x1;
sb_area_tmp.y1 += page->coords.y1;
sb_area_tmp.x2 += page->coords.x2;
@ -726,7 +726,7 @@ static void lv_page_sb_refresh(lv_obj_t * page)
lv_inv_area(&sb_area_tmp);
}
if(ext->sb.ver_draw != 0) {
area_cpy(&sb_area_tmp, &ext->sb.ver_area);
lv_area_copy(&sb_area_tmp, &ext->sb.ver_area);
sb_area_tmp.x1 += page->coords.x1;
sb_area_tmp.y1 += page->coords.y1;
sb_area_tmp.x2 += page->coords.x2;

6
lv_objx/lv_roller.c
View File

@ -262,8 +262,8 @@ static lv_res_t lv_roller_signal(lv_obj_t * roller, lv_signal_t sign, void * par
refr_position(roller, false);
} else if(sign == LV_SIGNAL_CORD_CHG) {
if(lv_obj_get_width(roller) != area_get_width(param) ||
lv_obj_get_height(roller) != area_get_height(param)) {
if(lv_obj_get_width(roller) != lv_area_get_width(param) ||
lv_obj_get_height(roller) != lv_area_get_height(param)) {
lv_ddlist_set_fix_height(roller, lv_obj_get_height(roller));
lv_obj_set_height(lv_page_get_scrl(roller),
@ -363,7 +363,7 @@ static void draw_bg(lv_obj_t *roller, const lv_area_t *mask)
lv_area_t half_roller;
lv_coord_t h = lv_obj_get_height(roller);
bool union_ok;
area_cpy(&half_roller, &roller->coords);
lv_area_copy(&half_roller, &roller->coords);
half_roller.x1 -= roller->ext_size; /*Add ext size too (e.g. because of shadow draw) */
half_roller.x2 += roller->ext_size;

34
lv_objx/lv_slider.c
View File

@ -243,15 +243,15 @@ static bool lv_slider_design(lv_obj_t * slider, const lv_area_t * mask, lv_desig
/*Draw the bar*/
lv_area_t area_bar;
area_cpy(&area_bar, &slider->coords);
lv_area_copy(&area_bar, &slider->coords);
/*Be sure at least vpad/hpad width bar will remain*/
lv_coord_t pad_ver_bar = style_slider->body.padding.ver;
lv_coord_t pad_hor_bar = style_slider->body.padding.hor;
if(pad_ver_bar * 2 + LV_SLIDER_SIZE_MIN > area_get_height(&area_bar)) {
pad_ver_bar = (area_get_height(&area_bar) - LV_SLIDER_SIZE_MIN) >> 1;
if(pad_ver_bar * 2 + LV_SLIDER_SIZE_MIN > lv_area_get_height(&area_bar)) {
pad_ver_bar = (lv_area_get_height(&area_bar) - LV_SLIDER_SIZE_MIN) >> 1;
}
if(pad_hor_bar * 2 + LV_SLIDER_SIZE_MIN > area_get_width(&area_bar)) {
pad_hor_bar = (area_get_width(&area_bar) - LV_SLIDER_SIZE_MIN) >> 1;
if(pad_hor_bar * 2 + LV_SLIDER_SIZE_MIN > lv_area_get_width(&area_bar)) {
pad_hor_bar = (lv_area_get_width(&area_bar) - LV_SLIDER_SIZE_MIN) >> 1;
}
area_bar.x1 += pad_hor_bar;
@ -262,16 +262,16 @@ static bool lv_slider_design(lv_obj_t * slider, const lv_area_t * mask, lv_desig
/*Draw the indicator*/
lv_area_t area_indic;
area_cpy(&area_indic, &area_bar);
lv_area_copy(&area_indic, &area_bar);
/*Be sure at least vpad/hpad width indicator will remain*/
lv_coord_t pad_ver_indic = style_indic->body.padding.ver;
lv_coord_t pad_hor_indic = style_indic->body.padding.hor;
if(pad_ver_indic * 2 + LV_SLIDER_SIZE_MIN > area_get_height(&area_bar)) {
pad_ver_indic = (area_get_height(&area_bar) - LV_SLIDER_SIZE_MIN) >> 1;
if(pad_ver_indic * 2 + LV_SLIDER_SIZE_MIN > lv_area_get_height(&area_bar)) {
pad_ver_indic = (lv_area_get_height(&area_bar) - LV_SLIDER_SIZE_MIN) >> 1;
}
if(pad_hor_indic * 2 + LV_SLIDER_SIZE_MIN > area_get_width(&area_bar)) {
pad_hor_indic = (area_get_width(&area_bar) - LV_SLIDER_SIZE_MIN) >> 1;
if(pad_hor_indic * 2 + LV_SLIDER_SIZE_MIN > lv_area_get_width(&area_bar)) {
pad_hor_indic = (lv_area_get_width(&area_bar) - LV_SLIDER_SIZE_MIN) >> 1;
}
area_indic.x1 += pad_hor_indic;
@ -279,8 +279,8 @@ static bool lv_slider_design(lv_obj_t * slider, const lv_area_t * mask, lv_desig
area_indic.y1 += pad_ver_indic;
area_indic.y2 -= pad_ver_indic;
lv_coord_t slider_w = area_get_width(&slider->coords);
lv_coord_t slider_h = area_get_height(&slider->coords);
lv_coord_t slider_w = lv_area_get_width(&slider->coords);
lv_coord_t slider_h = lv_area_get_height(&slider->coords);
lv_coord_t cur_value = lv_slider_get_value(slider);
lv_coord_t min_value = lv_slider_get_min_value(slider);
@ -290,11 +290,11 @@ static bool lv_slider_design(lv_obj_t * slider, const lv_area_t * mask, lv_desig
if(ext->drag_value != LV_SLIDER_NOT_PRESSED) cur_value = ext->drag_value;
if(slider_w >= slider_h) {
area_indic.x2 = (int32_t) ((int32_t)area_get_width(&area_indic) * (cur_value - min_value)) / (max_value - min_value);
area_indic.x2 = (int32_t) ((int32_t)lv_area_get_width(&area_indic) * (cur_value - min_value)) / (max_value - min_value);
area_indic.x2 += area_indic.x1;
} else {
area_indic.y1 = (int32_t) ((int32_t)area_get_height(&area_indic) * (cur_value - min_value)) / (max_value - min_value);
area_indic.y1 = (int32_t) ((int32_t)lv_area_get_height(&area_indic) * (cur_value - min_value)) / (max_value - min_value);
area_indic.y1 = area_indic.y2 - area_indic.y1;
}
@ -302,7 +302,7 @@ static bool lv_slider_design(lv_obj_t * slider, const lv_area_t * mask, lv_desig
/*Draw the knob*/
lv_area_t knob_area;
area_cpy(&knob_area, &slider->coords);
lv_area_copy(&knob_area, &slider->coords);
if(slider_w >= slider_h) {
if(ext->knob_in == 0) {
@ -395,8 +395,8 @@ static lv_res_t lv_slider_signal(lv_obj_t * slider, lv_signal_t sign, void * par
else if(sign == LV_SIGNAL_CORD_CHG) {
/* The knob size depends on slider size.
* During the drawing method the ext. size is used by the knob so refresh the ext. size.*/
if(lv_obj_get_width(slider) != area_get_width(param) ||
lv_obj_get_height(slider) != area_get_height(param)) {
if(lv_obj_get_width(slider) != lv_area_get_width(param) ||
lv_obj_get_height(slider) != lv_area_get_height(param)) {
slider->signal_func(slider, LV_SIGNAL_REFR_EXT_SIZE, NULL);
}
} else if(sign == LV_SIGNAL_REFR_EXT_SIZE) {

4
lv_objx/lv_ta.c
View File

@ -915,8 +915,8 @@ static lv_res_t lv_ta_signal(lv_obj_t * ta, lv_signal_t sign, void * param)
} else if(sign == LV_SIGNAL_CORD_CHG) {
/*Set the label width according to the text area width*/
if(ext->label) {
if(lv_obj_get_width(ta) != area_get_width(param) ||
lv_obj_get_height(ta) != area_get_height(param)) {
if(lv_obj_get_width(ta) != lv_area_get_width(param) ||
lv_obj_get_height(ta) != lv_area_get_height(param)) {
lv_obj_t * scrl = lv_page_get_scrl(ta);
lv_style_t * style_scrl = lv_obj_get_style(scrl);
lv_obj_set_width(ext->label, lv_obj_get_width(scrl) - 2 * style_scrl->body.padding.hor);

4
lv_objx/lv_tabview.c
View File

@ -506,8 +506,8 @@ static lv_res_t lv_tabview_signal(lv_obj_t * tabview, lv_signal_t sign, void * p
}
else if(sign == LV_SIGNAL_CORD_CHG) {
if(ext->content != NULL &&
(lv_obj_get_width(tabview) != area_get_width(param) ||
lv_obj_get_height(tabview) != area_get_height(param)))
(lv_obj_get_width(tabview) != lv_area_get_width(param) ||
lv_obj_get_height(tabview) != lv_area_get_height(param)))
{
tabview_realign(tabview);
}

4
lv_objx/lv_win.c
View File

@ -443,8 +443,8 @@ static lv_res_t lv_win_signal(lv_obj_t * win, lv_signal_t sign, void * param)
}
else if(sign == LV_SIGNAL_CORD_CHG) {
/*If the size is changed refresh the window*/
if(area_get_width(param) != lv_obj_get_width(win) ||
area_get_height(param) != lv_obj_get_height(win)) {
if(lv_area_get_width(param) != lv_obj_get_width(win) ||
lv_area_get_height(param) != lv_obj_get_height(win)) {
lv_win_realign(win);
}
}