github-code/lvgl
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

refactor: disp->display, res->result/resolution, hor/ver->horizontal/vertical, txt->text, angle->rotation, zoom->scale

Browse Source
This commit is contained in:
Gabor Kiss-Vamosi
2023-09-18 22:57:30 +02:00
parent 57a83cb2ad
commit 0721884ee9
202 changed files with 1894 additions and 1814 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
Kconfig
View File

@@ -1026,8 +1026,8 @@ menu "LVGL configuration"
config LV_USE_BMP
bool "BMP decoder library"
config LV_USE_SJPG
bool "JPG + split JPG decoder library"
config LV_USE_JPG
bool "JPG decoder library"
config LV_USE_GIF
bool "GIF decoder library"

50
demos/benchmark/lv_demo_benchmark.c
View File

@@ -9,7 +9,7 @@
#include "lv_demo_benchmark.h"
#if LV_USE_DEMO_BENCHMARK
#include "../../src/disp/lv_disp_private.h"
#include "../../src/display/lv_display_private.h"
/*********************
* DEFINES
@@ -74,7 +74,7 @@ static lv_style_t style_common;
static bool scene_with_opa = true;
static uint32_t last_flush_cb_call;
static uint32_t render_start_time;
static void (*flush_cb_ori)(lv_disp_t *, const lv_area_t *, uint8_t *);
static void (*flush_cb_ori)(lv_display_t *, const lv_area_t *, uint8_t *);
static uint32_t disp_ori_timer_period;
static uint32_t anim_ori_timer_period;
@@ -100,10 +100,10 @@ static void benchmark_event_remove(void);
static void show_scene_report(void);
static void calc_scene_statistics(void);
static lv_res_t load_next_scene(void);
static lv_result_t load_next_scene(void);
static void next_scene_timer_cb(lv_timer_t * timer);
static void single_scene_finsih_timer_cb(lv_timer_t * timer);
static void dummy_flush_cb(lv_disp_t * drv, const lv_area_t * area, uint8_t * pxmap);
static void dummy_flush_cb(lv_display_t * drv, const lv_area_t * area, uint8_t * pxmap);
static void generate_report(void);
static void rect_create(lv_style_t * style);
@@ -666,7 +666,7 @@ void lv_demo_benchmark(lv_demo_benchmark_mode_t _mode)
benchmark_init();
if(mode == LV_DEMO_BENCHMARK_MODE_RENDER_ONLY) {
while(load_next_scene() == LV_RES_OK) {
while(load_next_scene() == LV_RESULT_OK) {
uint32_t i;
for(i = 0; i < RENDER_REPEAT_CNT; i++) {
/*Wait a little to be sure something happens with the animations*/
@@ -733,9 +733,9 @@ void lv_demo_benchmark_run_scene(lv_demo_benchmark_mode_t _mode, uint16_t scene_
static void benchmark_init(void)
{
lv_disp_t * disp = lv_disp_get_default();
lv_display_t * disp = lv_display_get_default();
lv_disp_add_event(disp, benchmark_event_cb, LV_EVENT_ALL, NULL);
lv_display_add_event(disp, benchmark_event_cb, LV_EVENT_ALL, NULL);
flush_cb_ori = disp->flush_cb;
disp->flush_cb = dummy_flush_cb;
@@ -785,12 +785,12 @@ static void benchmark_event_cb(lv_event_t * e)
static void benchmark_event_remove(void)
{
lv_disp_t * disp = lv_disp_get_default();
lv_display_t * disp = lv_display_get_default();
uint32_t i;
for(i = 0; i < lv_disp_get_event_count(disp); i++) {
lv_event_dsc_t * dsc = lv_disp_get_event_dsc(disp, i);
for(i = 0; i < lv_display_get_event_count(disp); i++) {
lv_event_dsc_t * dsc = lv_display_get_event_dsc(disp, i);
if(lv_event_dsc_get_cb(dsc) == benchmark_event_cb) {
lv_disp_remove_event(disp, i);
lv_display_remove_event(disp, i);
return;
}
}
@@ -827,9 +827,9 @@ static void calc_scene_statistics(void)
}
}
static lv_res_t load_next_scene(void)
static lv_result_t load_next_scene(void)
{
if(scene_act >= 0 && scenes[scene_act].create_cb == NULL) return LV_RES_INV;
if(scene_act >= 0 && scenes[scene_act].create_cb == NULL) return LV_RESULT_INVALID;
lv_obj_clean(scene_bg);
@@ -841,14 +841,14 @@ static lv_res_t load_next_scene(void)
scene_with_opa = true;
}
if(scene_act >= 0 && scenes[scene_act].create_cb == NULL) return LV_RES_INV;
if(scene_act >= 0 && scenes[scene_act].create_cb == NULL) return LV_RESULT_INVALID;
last_flush_cb_call = 0;
rnd_reset();
scenes[scene_act].create_cb();
lv_label_set_text_fmt(title, "%s%s", scenes[scene_act].name, scene_with_opa ? " + opa" : "");
return LV_RES_OK;
return LV_RESULT_OK;
}
static void next_scene_timer_cb(lv_timer_t * timer)
@@ -857,9 +857,9 @@ static void next_scene_timer_cb(lv_timer_t * timer)
calc_scene_statistics();
show_scene_report();
lv_res_t res = load_next_scene();
lv_result_t res = load_next_scene();
if(res == LV_RES_INV) {
if(res == LV_RESULT_INVALID) {
lv_timer_del(timer);
generate_report();
}
@@ -870,7 +870,7 @@ static void single_scene_finsih_timer_cb(lv_timer_t * timer)
LV_UNUSED(timer);
calc_scene_statistics();
lv_disp_t * disp = lv_disp_get_default();
lv_display_t * disp = lv_display_get_default();
disp->flush_cb = flush_cb_ori;
if(mode == LV_DEMO_BENCHMARK_MODE_RENDER_ONLY) {
@@ -886,13 +886,13 @@ static void single_scene_finsih_timer_cb(lv_timer_t * timer)
lv_obj_invalidate(lv_scr_act());
}
static void dummy_flush_cb(lv_disp_t * drv, const lv_area_t * area, uint8_t * pxmap)
static void dummy_flush_cb(lv_display_t * drv, const lv_area_t * area, uint8_t * pxmap)
{
LV_UNUSED(area);
if(mode == LV_DEMO_BENCHMARK_MODE_RENDER_AND_DRIVER) {
/*Measure the time since render start after flushing*/
bool last = lv_disp_flush_is_last(drv);
bool last = lv_display_flush_is_last(drv);
flush_cb_ori(drv, area, pxmap);
if(last) {
@@ -908,7 +908,7 @@ static void dummy_flush_cb(lv_disp_t * drv, const lv_area_t * area, uint8_t * px
}
}
else if(mode == LV_DEMO_BENCHMARK_MODE_REAL) {
bool last = lv_disp_flush_is_last(drv);
bool last = lv_display_flush_is_last(drv);
flush_cb_ori(drv, area, pxmap);
/*Measure the time since the previous last flush (full render)*/
@@ -929,10 +929,10 @@ static void dummy_flush_cb(lv_disp_t * drv, const lv_area_t * area, uint8_t * px
}
}
else if(mode == LV_DEMO_BENCHMARK_MODE_RENDER_ONLY) {
bool last = lv_disp_flush_is_last(drv);
bool last = lv_display_flush_is_last(drv);
/*Just bypass the driver and measure the pure rendering time*/
lv_disp_flush_ready(drv);
lv_display_flush_ready(drv);
if(last) {
uint32_t t = lv_tick_elaps(render_start_time);
@@ -950,7 +950,7 @@ static void dummy_flush_cb(lv_disp_t * drv, const lv_area_t * area, uint8_t * px
static void generate_report(void)
{
lv_disp_t * disp = lv_disp_get_default();
lv_display_t * disp = lv_display_get_default();
disp->flush_cb = flush_cb_ori;
if(mode == LV_DEMO_BENCHMARK_MODE_RENDER_ONLY) {
@@ -1114,7 +1114,7 @@ static void img_create(lv_style_t * style, const void * src, bool rotate, bool z
lv_image_set_src(obj, src);
lv_obj_set_style_image_recolor(obj, lv_color_hex(rnd_next(0, 0xFFFFF0)), 0);
if(rotate) lv_image_set_angle(obj, rnd_next(0, 3599));
if(rotate) lv_image_set_rotation(obj, rnd_next(0, 3599));
if(zoom) lv_image_set_zoom(obj, rnd_next(IMG_ZOOM_MIN, IMG_ZOOM_MAX));
lv_image_set_antialias(obj, aa);

4
demos/multilang/lv_demo_multilang.c
View File

@@ -249,8 +249,8 @@ static void inactive_timer_cb(lv_timer_t * t)
return;
}
if(lv_disp_get_inactive_time(NULL) > 8000) {
lv_disp_trig_activity(NULL);
if(lv_display_get_inactive_time(NULL) > 8000) {
lv_display_trig_activity(NULL);
lv_obj_scroll_by(cont, 100, 0, LV_ANIM_ON);
lv_obj_add_flag(lv_layer_top(), LV_OBJ_FLAG_CLICKABLE);
scrolled = true;

12
demos/music/lv_demo_music_main.c
View File

@@ -281,7 +281,7 @@ lv_obj_t * _lv_demo_music_main_create(lv_obj_t * parent)
lv_anim_set_var(&a, album_image_obj);
lv_anim_set_time(&a, 1000);
lv_anim_set_delay(&a, INTRO_TIME + 1000);
lv_anim_set_values(&a, 1, LV_ZOOM_NONE);
lv_anim_set_values(&a, 1, LV_SCALE_NONE);
lv_anim_set_exec_cb(&a, _image_set_zoom_anim_cb);
lv_anim_set_ready_cb(&a, NULL);
lv_anim_start(&a);
@@ -305,7 +305,7 @@ lv_obj_t * _lv_demo_music_main_create(lv_obj_t * parent)
lv_anim_set_var(&a, logo);
lv_anim_set_time(&a, 400);
lv_anim_set_delay(&a, INTRO_TIME + 800);
lv_anim_set_values(&a, LV_ZOOM_NONE, 10);
lv_anim_set_values(&a, LV_SCALE_NONE, 10);
lv_anim_set_ready_cb(&a, lv_obj_del_anim_ready_cb);
lv_anim_start(&a);
@@ -373,7 +373,7 @@ void _lv_demo_music_pause(void)
spectrum_i = 0;
lv_anim_del(spectrum_obj, spectrum_anim_cb);
lv_obj_invalidate(spectrum_obj);
lv_image_set_zoom(album_image_obj, LV_ZOOM_NONE);
lv_image_set_zoom(album_image_obj, LV_SCALE_NONE);
if(sec_counter_timer) lv_timer_pause(sec_counter_timer);
lv_obj_clear_state(play_obj, LV_STATE_CHECKED);
}
@@ -720,7 +720,7 @@ static void track_load(uint32_t id)
lv_anim_set_path_cb(&a, lv_anim_path_linear);
lv_anim_set_var(&a, album_image_obj);
lv_anim_set_time(&a, 500);
lv_anim_set_values(&a, LV_ZOOM_NONE, LV_ZOOM_NONE / 2);
lv_anim_set_values(&a, LV_SCALE_NONE, LV_SCALE_NONE / 2);
lv_anim_set_exec_cb(&a, _image_set_zoom_anim_cb);
lv_anim_set_ready_cb(&a, NULL);
lv_anim_start(&a);
@@ -731,7 +731,7 @@ static void track_load(uint32_t id)
lv_anim_set_var(&a, album_image_obj);
lv_anim_set_time(&a, 500);
lv_anim_set_delay(&a, 100);
lv_anim_set_values(&a, LV_ZOOM_NONE / 4, LV_ZOOM_NONE);
lv_anim_set_values(&a, LV_SCALE_NONE / 4, LV_SCALE_NONE);
lv_anim_set_exec_cb(&a, _image_set_zoom_anim_cb);
lv_anim_set_ready_cb(&a, NULL);
lv_anim_start(&a);
@@ -924,7 +924,7 @@ static void spectrum_anim_cb(void * a, int32_t v)
}
if(spectrum[spectrum_i][0] < 4) bar_rot += dir;
lv_image_set_zoom(album_image_obj, LV_ZOOM_NONE + spectrum[spectrum_i][0]);
lv_image_set_zoom(album_image_obj, LV_SCALE_NONE + spectrum[spectrum_i][0]);
}
static void start_anim_cb(void * a, int32_t v)

4
demos/stress/lv_demo_stress.c
View File

@@ -62,8 +62,8 @@ static void obj_test_task_cb(lv_timer_t * tmr)
switch(state) {
case -1: {
lv_res_t res = lv_mem_test();
if(res != LV_RES_OK) {
lv_result_t res = lv_mem_test();
if(res != LV_RESULT_OK) {
LV_LOG_ERROR("Memory integrity error");
}

6
demos/transform/lv_demo_transform.c
View File

@@ -87,7 +87,7 @@ void lv_demo_transform(void)
card_to_transform = card_create();
lv_obj_center(card_to_transform);
lv_coord_t disp_w = lv_disp_get_hor_res(NULL);
lv_coord_t disp_w = lv_display_get_horizontal_resolution(NULL);
lv_obj_t * arc = lv_arc_create(lv_scr_act());
lv_obj_set_size(arc, disp_w - 20, disp_w - 20);
lv_arc_set_range(arc, 0, 270);
@@ -148,14 +148,14 @@ static void arc_event_cb(lv_event_t * e)
lv_obj_t * arc = lv_event_get_target(e);
int32_t v = lv_arc_get_angle_end(arc);
lv_obj_set_style_transform_angle(card_to_transform, v * 10, 0);
lv_obj_set_style_transform_rotation(card_to_transform, v * 10, 0);
}
static void slider_event_cb(lv_event_t * e)
{
lv_obj_t * slider = lv_event_get_target(e);
int32_t v = lv_slider_get_value(slider);
lv_obj_set_style_transform_zoom(card_to_transform, v, 0);
lv_obj_set_style_transform_scale(card_to_transform, v, 0);
}
#endif

4
demos/widgets/lv_demo_widgets.c
View File

@@ -1284,7 +1284,7 @@ static void slider_event_cb(lv_event_t * e)
lv_snprintf(buf, sizeof(buf), "%"LV_PRId32, lv_slider_get_value(obj));
lv_point_t text_size;
lv_txt_get_size(&text_size, buf, font_normal, 0, 0, LV_COORD_MAX, LV_TEXT_FLAG_NONE);
lv_text_get_size(&text_size, buf, font_normal, 0, 0, LV_COORD_MAX, LV_TEXT_FLAG_NONE);
lv_area_t txt_area;
txt_area.x1 = draw_task->area.x1 + lv_area_get_width(&draw_task->area) / 2 - text_size.x / 2;
@@ -1437,7 +1437,7 @@ static void chart_event_cb(lv_event_t * e)
lv_snprintf(buf, sizeof(buf), "%"LV_PRIu32, ser->y_points[base_dsc->id2]);
lv_point_t text_size;
lv_txt_get_size(&text_size, buf, font_normal, 0, 0, LV_COORD_MAX, LV_TEXT_FLAG_NONE);
lv_text_get_size(&text_size, buf, font_normal, 0, 0, LV_COORD_MAX, LV_TEXT_FLAG_NONE);
lv_area_t txt_area;
if(lv_chart_get_type(obj) == LV_CHART_TYPE_BAR) {

28
docs/overview/style-props.md
View File

@@ -120,8 +120,8 @@ Move the object with this value in Y direction. Applied after layouts, aligns an
<li style='display:inline; margin-right: 20px; margin-left: 0px'><strong>Ext. draw</strong> No</li>
</ul>
### transform_zoom
Zoom an objects. The value 256 (or `LV_ZOOM_NONE`) means normal size, 128 half size, 512 double size, and so on
### transform_scale
Zoom an objects. The value 256 (or `LV_SCALE_NONE`) means normal size, 128 half size, 512 double size, and so on
<ul>
<li style='display:inline; margin-right: 20px; margin-left: 0px'><strong>Default</strong> 0</li>
<li style='display:inline; margin-right: 20px; margin-left: 0px'><strong>Inherited</strong> No</li>
@@ -129,7 +129,7 @@ Zoom an objects. The value 256 (or `LV_ZOOM_NONE`) means normal size, 128 half s
<li style='display:inline; margin-right: 20px; margin-left: 0px'><strong>Ext. draw</strong> Yes</li>
</ul>
### transform_angle
### transform_rotation
Rotate an objects. The value is interpreted in 0.1 degree units. E.g. 450 means 45 deg.
<ul>
<li style='display:inline; margin-right: 20px; margin-left: 0px'><strong>Default</strong> 0</li>
@@ -327,8 +327,8 @@ Set the dithering mode of the gradient of the background. The possible values ar
<li style='display:inline; margin-right: 20px; margin-left: 0px'><strong>Ext. draw</strong> No</li>
</ul>
### bg_img_src
Set a background image. Can be a pointer to `lv_img_dsc_t`, a path to a file or an `LV_SYMBOL_...`
### bg_image_src
Set a background image. Can be a pointer to `lv_image_dsc_t`, a path to a file or an `LV_SYMBOL_...`
<ul>
<li style='display:inline; margin-right: 20px; margin-left: 0px'><strong>Default</strong> `NULL`</li>
<li style='display:inline; margin-right: 20px; margin-left: 0px'><strong>Inherited</strong> No</li>
@@ -336,7 +336,7 @@ Set a background image. Can be a pointer to `lv_img_dsc_t`, a path to a file or
<li style='display:inline; margin-right: 20px; margin-left: 0px'><strong>Ext. draw</strong> Yes</li>
</ul>
### bg_img_opa
### bg_image_opa
Set the opacity of the background image. Value 0, `LV_OPA_0` or `LV_OPA_TRANSP` means fully transparent, 255, `LV_OPA_100` or `LV_OPA_COVER` means fully covering, other values or LV_OPA_10, LV_OPA_20, etc means semi transparency.
<ul>
<li style='display:inline; margin-right: 20px; margin-left: 0px'><strong>Default</strong> `LV_OPA_COVER`</li>
@@ -345,7 +345,7 @@ Set the opacity of the background image. Value 0, `LV_OPA_0` or `LV_OPA_TRANSP`
<li style='display:inline; margin-right: 20px; margin-left: 0px'><strong>Ext. draw</strong> No</li>
</ul>
### bg_img_recolor
### bg_image_recolor
Set a color to mix to the background image.
<ul>
<li style='display:inline; margin-right: 20px; margin-left: 0px'><strong>Default</strong> `0x000000`</li>
@@ -354,7 +354,7 @@ Set a color to mix to the background image.
<li style='display:inline; margin-right: 20px; margin-left: 0px'><strong>Ext. draw</strong> No</li>
</ul>
### bg_img_recolor_opa
### bg_image_recolor_opa
Set the intensity of background image recoloring. Value 0, `LV_OPA_0` or `LV_OPA_TRANSP` means no mixing, 255, `LV_OPA_100` or `LV_OPA_COVER` means full recoloring, other values or LV_OPA_10, LV_OPA_20, etc are interpreted proportionally.
<ul>
<li style='display:inline; margin-right: 20px; margin-left: 0px'><strong>Default</strong> `LV_OPA_TRANSP`</li>
@@ -363,7 +363,7 @@ Set the intensity of background image recoloring. Value 0, `LV_OPA_0` or `LV_OPA
<li style='display:inline; margin-right: 20px; margin-left: 0px'><strong>Ext. draw</strong> No</li>
</ul>
### bg_img_tiled
### bg_image_tiled
If enabled the background image will be tiled. The possible values are `true` or `false`.
<ul>
<li style='display:inline; margin-right: 20px; margin-left: 0px'><strong>Default</strong> 0</li>
@@ -519,7 +519,7 @@ Set the opacity of the shadow. Value 0, `LV_OPA_0` or `LV_OPA_TRANSP` means full
## Image
Properties to describe the images
### img_opa
### image_opa
Set the opacity of an image. Value 0, `LV_OPA_0` or `LV_OPA_TRANSP` means fully transparent, 255, `LV_OPA_100` or `LV_OPA_COVER` means fully covering, other values or LV_OPA_10, LV_OPA_20, etc means semi transparency.
<ul>
<li style='display:inline; margin-right: 20px; margin-left: 0px'><strong>Default</strong> `LV_OPA_COVER`</li>
@@ -528,7 +528,7 @@ Set the opacity of an image. Value 0, `LV_OPA_0` or `LV_OPA_TRANSP` means fully
<li style='display:inline; margin-right: 20px; margin-left: 0px'><strong>Ext. draw</strong> No</li>
</ul>
### img_recolor
### image_recolor
Set color to mixt to the image.
<ul>
<li style='display:inline; margin-right: 20px; margin-left: 0px'><strong>Default</strong> `0x000000`</li>
@@ -537,7 +537,7 @@ Set color to mixt to the image.
<li style='display:inline; margin-right: 20px; margin-left: 0px'><strong>Ext. draw</strong> No</li>
</ul>
### img_recolor_opa
### image_recolor_opa
Set the intensity of the color mixing. Value 0, `LV_OPA_0` or `LV_OPA_TRANSP` means fully transparent, 255, `LV_OPA_100` or `LV_OPA_COVER` means fully covering, other values or LV_OPA_10, LV_OPA_20, etc means semi transparency.
<ul>
<li style='display:inline; margin-right: 20px; margin-left: 0px'><strong>Default</strong> 0</li>
@@ -642,8 +642,8 @@ Set the opacity of the arcs.
<li style='display:inline; margin-right: 20px; margin-left: 0px'><strong>Ext. draw</strong> No</li>
</ul>
### arc_img_src
Set an image from which the arc will be masked out. It's useful to display complex effects on the arcs. Can be a pointer to `lv_img_dsc_t` or a path to a file
### arc_image_src
Set an image from which the arc will be masked out. It's useful to display complex effects on the arcs. Can be a pointer to `lv_image_dsc_t` or a path to a file
<ul>
<li style='display:inline; margin-right: 20px; margin-left: 0px'><strong>Default</strong> `NULL`</li>
<li style='display:inline; margin-right: 20px; margin-left: 0px'><strong>Inherited</strong> No</li>

4
env_support/cmsis-pack/lv_conf_cmsis.h
View File

@@ -277,7 +277,7 @@
/*Maximum buffer size to allocate for rotation.
*Only used if software rotation is enabled in the display driver.*/
#define LV_DISP_ROT_MAX_BUF (10*1024)
#define LV_DISPLAY_ROT_MAX_BUF (10*1024)
/*Garbage Collector settings
*Used if lvgl is bound to higher level language and the memory is managed by that language*/
@@ -315,7 +315,7 @@
/*Define a custom attribute to `lv_timer_handler` function*/
#define LV_ATTRIBUTE_TIMER_HANDLER
/*Define a custom attribute to `lv_disp_flush_ready` function*/
/*Define a custom attribute to `lv_display_flush_ready` function*/
#define LV_ATTRIBUTE_FLUSH_READY
/*Required alignment size for buffers*/

4
examples/others/snapshot/lv_example_snapshot_1.c
View File

@@ -31,7 +31,7 @@ void lv_example_snapshot_1(void)
lv_obj_set_style_bg_color(snapshot_obj, lv_palette_main(LV_PALETTE_PURPLE), 0);
lv_obj_set_style_bg_opa(snapshot_obj, LV_OPA_100, 0);
lv_image_set_zoom(snapshot_obj, 128);
lv_image_set_angle(snapshot_obj, 300);
lv_image_set_rotation(snapshot_obj, 300);
/*Create the container and its children*/
lv_obj_t * container = lv_obj_create(root);
@@ -48,7 +48,7 @@ void lv_example_snapshot_1(void)
lv_image_set_src(img, &img_star);
lv_obj_set_style_bg_color(img, lv_color_black(), 0);
lv_obj_set_style_bg_opa(img, LV_OPA_COVER, 0);
// lv_obj_set_style_transform_zoom(img, 400, LV_STATE_PRESSED);
// lv_obj_set_style_transform_scale(img, 400, LV_STATE_PRESSED);
lv_obj_add_flag(img, LV_OBJ_FLAG_CLICKABLE);
lv_obj_add_event(img, event_cb, LV_EVENT_PRESSED, snapshot_obj);
lv_obj_add_event(img, event_cb, LV_EVENT_RELEASED, snapshot_obj);

4
examples/others/snapshot/lv_example_snapshot_1.py
View File

@@ -44,7 +44,7 @@ root.set_style_bg_color(lv.palette_main(lv.PALETTE.LIGHT_BLUE), 0)
snapshot_obj = lv.image(root)
snapshot_obj.set_style_bg_color(lv.palette_main(lv.PALETTE.PURPLE), 0)
snapshot_obj.set_style_bg_opa(lv.OPA.COVER, 0)
snapshot_obj.set_zoom(128)
snapshot_obj.set_scale(128)
# Create the container and its children
container = lv.obj(root)
@@ -59,7 +59,7 @@ for i in range(4):
image.set_src(image_star)
image.set_style_bg_color(lv.palette_main(lv.PALETTE.GREY), 0)
image.set_style_bg_opa(lv.OPA.COVER, 0)
image.set_style_transform_zoom(400, lv.STATE.PRESSED)
image.set_style_transform_scale(400, lv.STATE.PRESSED)
image.add_flag(image.FLAG.CLICKABLE)
image.add_event(lambda e: event_cb(e, snapshot_obj), lv.EVENT.PRESSED, None)
image.add_event(lambda e: event_cb(e, snapshot_obj), lv.EVENT.RELEASED, None)

20
examples/porting/lv_port_disp_template.c
View File

@@ -34,7 +34,7 @@
**********************/
static void disp_init(void);
static void disp_flush(lv_disp_t * disp, const lv_area_t * area, lv_color_t * px_map);
static void disp_flush(lv_display_t * disp, const lv_area_t * area, lv_color_t * px_map);
/**********************
* STATIC VARIABLES
@@ -58,27 +58,27 @@ void lv_port_disp_init(void)
/*------------------------------------
* Create a display and set a flush_cb
* -----------------------------------*/
lv_disp_t * disp = lv_disp_create(MY_DISP_HOR_RES, MY_DISP_VER_RES);
lv_disp_set_flush_cb(disp, disp_flush);
lv_display_t * disp = lv_display_create(MY_DISP_HOR_RES, MY_DISP_VER_RES);
lv_display_set_flush_cb(disp, disp_flush);
/* Example 1
* One buffer for partial rendering*/
static lv_color_t buf_1_1[MY_DISP_HOR_RES * 10]; /*A buffer for 10 rows*/
lv_disp_set_draw_buffers(disp, buf_1_1, NULL, sizeof(buf_1_1), LV_DISP_RENDER_MODE_PARTIAL);
lv_display_set_draw_buffers(disp, buf_1_1, NULL, sizeof(buf_1_1), LV_DISPLAY_RENDER_MODE_PARTIAL);
/* Example 2
* Two buffers for partial rendering
* In flush_cb DMA or similar hardware should be used to update the display in the background.*/
static lv_color_t buf_2_1[MY_DISP_HOR_RES * 10];
static lv_color_t buf_2_2[MY_DISP_HOR_RES * 10];
lv_disp_set_draw_buffers(disp, buf_2_1, buf_2_2, sizeof(buf_2_1), LV_DISP_RENDER_MODE_PARTIAL);
lv_display_set_draw_buffers(disp, buf_2_1, buf_2_2, sizeof(buf_2_1), LV_DISPLAY_RENDER_MODE_PARTIAL);
/* Example 3
* Two buffers screen sized buffer for double buffering.
* Both LV_DISP_RENDER_MODE_DIRECT and LV_DISP_RENDER_MODE_FULL works, see their comments*/
* Both LV_DISPLAY_RENDER_MODE_DIRECT and LV_DISPLAY_RENDER_MODE_FULL works, see their comments*/
static lv_color_t buf_3_1[MY_DISP_HOR_RES * MY_DISP_VER_RES];
static lv_color_t buf_3_2[MY_DISP_HOR_RES * MY_DISP_VER_RES];
lv_disp_set_draw_buffers(disp, buf_3_1, buf_3_2, sizeof(buf_3_1), LV_DISP_RENDER_MODE_DIRECT);
lv_display_set_draw_buffers(disp, buf_3_1, buf_3_2, sizeof(buf_3_1), LV_DISPLAY_RENDER_MODE_DIRECT);
}
@@ -111,8 +111,8 @@ void disp_disable_update(void)
/*Flush the content of the internal buffer the specific area on the display.
*`px_map` contains the rendered image as raw pixel map and it should be copied to `area` on the display.
*You can use DMA or any hardware acceleration to do this operation in the background but
*'lv_disp_flush_ready()' has to be called when it's finished.*/
static void disp_flush(lv_disp_t * disp_drv, const lv_area_t * area, lv_color_t * px_map)
*'lv_display_flush_ready()' has to be called when it's finished.*/
static void disp_flush(lv_display_t * disp_drv, const lv_area_t * area, lv_color_t * px_map)
{
if(disp_flush_enabled) {
/*The most simple case (but also the slowest) to put all pixels to the screen one-by-one*/
@@ -130,7 +130,7 @@ static void disp_flush(lv_disp_t * disp_drv, const lv_area_t * area, lv_color_t
/*IMPORTANT!!!
*Inform the graphics library that you are ready with the flushing*/
lv_disp_flush_ready(disp_drv);
lv_display_flush_ready(disp_drv);
}
#else /*Enable this file at the top*/

4
examples/styles/lv_example_style_14.c
View File

@@ -24,7 +24,7 @@ static void new_theme_init_and_set(void)
lv_style_set_border_width(&style_btn, 3);
/*Initialize the new theme from the current theme*/
lv_theme_t * th_act = lv_disp_get_theme(NULL);
lv_theme_t * th_act = lv_display_get_theme(NULL);
static lv_theme_t th_new;
th_new = *th_act;
@@ -33,7 +33,7 @@ static void new_theme_init_and_set(void)
lv_theme_set_apply_cb(&th_new, new_theme_apply_cb);
/*Assign the new theme to the current display*/
lv_disp_set_theme(NULL, &th_new);
lv_display_set_theme(NULL, &th_new);
}

2
examples/styles/lv_example_style_14.py
View File

@@ -49,7 +49,7 @@ class ExampleStyle_14:
# Initialize the new theme from the current theme
self.th_new = NewTheme()
self.th_new.set_apply_cb(self.new_theme_apply_cb)
lv.disp_get_default().set_theme(self.th_new)
lv.display_get_default().set_theme(self.th_new)
exampleStyle_14 = ExampleStyle_14()

4
examples/styles/lv_example_style_15.c
View File

@@ -35,8 +35,8 @@ void lv_example_style_15(void)
*The button and the label is rendered to a layer first and that layer is transformed*/
btn = lv_button_create(lv_scr_act());
lv_obj_set_size(btn, 100, 40);
lv_obj_set_style_transform_angle(btn, 150, 0); /*15 deg*/
lv_obj_set_style_transform_zoom(btn, 256 + 64, 0); /*1.25x*/
lv_obj_set_style_transform_rotation(btn, 150, 0); /*15 deg*/
lv_obj_set_style_transform_scale(btn, 256 + 64, 0); /*1.25x*/
lv_obj_set_style_transform_pivot_x(btn, 50, 0);
lv_obj_set_style_transform_pivot_y(btn, 20, 0);
lv_obj_set_style_opa(btn, LV_OPA_50, 0);

4
examples/styles/lv_example_style_15.py
View File

@@ -26,8 +26,8 @@ label.center()
# The button and the label is rendered to a layer first and that layer is transformed
button = lv.button(lv.scr_act())
button.set_size(100, 40)
button.set_style_transform_angle(150, 0) # 15 deg
button.set_style_transform_zoom(256 + 64, 0) # 1.25x
button.set_style_transform_rotation(150, 0) # 15 deg
button.set_style_transform_scale(256 + 64, 0) # 1.25x
button.set_style_transform_pivot_x(50, 0)
button.set_style_transform_pivot_y(20, 0)
button.set_style_opa(lv.OPA._50, 0)

2
examples/styles/lv_example_style_6.c
View File

@@ -18,7 +18,7 @@ void lv_example_style_6(void)
lv_style_set_image_recolor(&style, lv_palette_main(LV_PALETTE_BLUE));
lv_style_set_image_recolor_opa(&style, LV_OPA_50);
lv_style_set_transform_angle(&style, 300);
lv_style_set_transform_rotation(&style, 300);
/*Create an object with the new style*/
lv_obj_t * obj = lv_image_create(lv_scr_act());

2
examples/styles/lv_example_style_6.py
View File

@@ -26,7 +26,7 @@ style.set_border_color(lv.palette_main(lv.PALETTE.BLUE))
style.set_image_recolor(lv.palette_main(lv.PALETTE.BLUE))
style.set_image_recolor_opa(lv.OPA._50)
style.set_transform_angle(300)
style.set_transform_rotation(300)
# Create an object with the new style
obj = lv.image(lv.scr_act())

4
examples/widgets/bar/lv_example_bar_6.c
View File

@@ -18,8 +18,8 @@ static void event_cb(lv_event_t * e)
lv_snprintf(buf, sizeof(buf), "%d", (int)lv_bar_get_value(obj));
lv_point_t txt_size;
lv_txt_get_size(&txt_size, buf, label_dsc.font, label_dsc.letter_space, label_dsc.line_space, LV_COORD_MAX,
label_dsc.flag);
lv_text_get_size(&txt_size, buf, label_dsc.font, label_dsc.letter_space, label_dsc.line_space, LV_COORD_MAX,
label_dsc.flag);
lv_area_t txt_area;
txt_area.x1 = 0;

4
examples/widgets/btnmatrix/lv_example_btnmatrix_2.c
View File

@@ -48,8 +48,8 @@ static void event_cb(lv_event_t * e)
if(draw_task->type == LV_DRAW_TASK_TYPE_FILL) {
LV_IMAGE_DECLARE(img_star);
lv_image_header_t header;
lv_res_t res = lv_image_decoder_get_info(&img_star, &header);
if(res != LV_RES_OK) return;
lv_result_t res = lv_image_decoder_get_info(&img_star, &header);
if(res != LV_RESULT_OK) return;
lv_area_t a;
a.x1 = 0;

2
examples/widgets/calendar/lv_example_calendar_1.py
View File

@@ -5,7 +5,7 @@ def event_handler(e):
if code == lv.EVENT.VALUE_CHANGED:
source = e.get_current_target_obj()
date = lv.calendar_date_t()
if source.get_pressed_date(date) == lv.RES.OK:
if source.get_pressed_date(date) == lv.RESULT.OK:
calendar.set_today_date(date.year, date.month, date.day)
print("Clicked date: %02d.%02d.%02d"%(date.day, date.month, date.year))

2
examples/widgets/canvas/lv_example_canvas_1.c
View File

@@ -64,7 +64,7 @@ void lv_example_canvas_1(void)
lv_draw_image_dsc_t img_dsc;
lv_draw_image_dsc_init(&img_dsc);
img_dsc.angle = 120;
img_dsc.rotation = 120;
img_dsc.src = &img;
img_dsc.pivot.x = CANVAS_WIDTH / 2;
img_dsc.pivot.y = CANVAS_HEIGHT / 2;

2
examples/widgets/canvas/lv_example_canvas_1.py
View File

@@ -72,7 +72,7 @@ canvas.fill_bg(lv.palette_lighten(lv.PALETTE.GREY, 3), lv.OPA.COVER)
image_dsc = lv.draw_image_dsc_t()
image_dsc.init();
image_dsc.angle = 120;
image_dsc.rotation = 120;
image_dsc.src = image;
image_dsc.pivot.x = _CANVAS_WIDTH // 2;
image_dsc.pivot.y = _CANVAS_HEIGHT // 2;

4
examples/widgets/chart/lv_example_chart_5.c
View File

@@ -84,13 +84,13 @@ void lv_example_chart_5(void)
lv_obj_t * slider;
slider = lv_slider_create(lv_scr_act());
lv_slider_set_range(slider, LV_ZOOM_NONE, LV_ZOOM_NONE * 10);
lv_slider_set_range(slider, LV_SCALE_NONE, LV_SCALE_NONE * 10);
lv_obj_add_event(slider, slider_x_event_cb, LV_EVENT_VALUE_CHANGED, NULL);
lv_obj_set_size(slider, 200, 10);
lv_obj_align_to(slider, chart, LV_ALIGN_OUT_BOTTOM_MID, 0, 20);
slider = lv_slider_create(lv_scr_act());
lv_slider_set_range(slider, LV_ZOOM_NONE, LV_ZOOM_NONE * 10);
lv_slider_set_range(slider, LV_SCALE_NONE, LV_SCALE_NONE * 10);
lv_obj_add_event(slider, slider_y_event_cb, LV_EVENT_VALUE_CHANGED, NULL);
lv_obj_set_size(slider, 10, 150);
lv_obj_align_to(slider, chart, LV_ALIGN_OUT_RIGHT_MID, 20, 0);

4
examples/widgets/chart/lv_example_chart_5.py
View File

@@ -76,13 +76,13 @@ chart.set_point_count(pcnt)
chart.set_ext_y_array(ser, ecg_sample)
slider = lv.slider(lv.scr_act())
slider.set_range(lv.ZOOM_NONE, lv.ZOOM_NONE * 10)
slider.set_range(lv.SCALE_NONE, lv.SCALE_NONE * 10)
slider.add_event(slider_x_event_cb, lv.EVENT.VALUE_CHANGED, None)
slider.set_size(200,10)
slider.align_to(chart, lv.ALIGN.OUT_BOTTOM_MID, 0, 20)
slider = lv.slider(lv.scr_act())
slider.set_range(lv.ZOOM_NONE, lv.ZOOM_NONE * 10)
slider.set_range(lv.SCALE_NONE, lv.SCALE_NONE * 10)
slider.add_event(slider_y_event_cb, lv.EVENT.VALUE_CHANGED, None)
slider.set_size(10, 150)
slider.align_to(chart, lv.ALIGN.OUT_RIGHT_MID, 20, 0)

2
examples/widgets/dropdown/lv_example_dropdown_3.c
View File

@@ -32,7 +32,7 @@ void lv_example_dropdown_3(void)
/*Use a custom image as down icon and flip it when the list is opened*/
LV_IMAGE_DECLARE(img_caret_down)
lv_dropdown_set_symbol(dropdown, &img_caret_down);
lv_obj_set_style_transform_angle(dropdown, 1800, LV_PART_INDICATOR | LV_STATE_CHECKED);
lv_obj_set_style_transform_rotation(dropdown, 1800, LV_PART_INDICATOR | LV_STATE_CHECKED);
/*In a menu we don't need to show the last clicked item*/
lv_dropdown_set_selected_highlight(dropdown, false);

2
examples/widgets/dropdown/lv_example_dropdown_3.py
View File

@@ -37,7 +37,7 @@ dropdown.set_text("Menu")
# Use a custom image as down icon and flip it when the list is opened
# LV_IMAGE_DECLARE(image_caret_down)
dropdown.set_symbol(image_caret_down_argb)
dropdown.set_style_transform_angle(1800, lv.PART.INDICATOR | lv.STATE.CHECKED)
dropdown.set_style_transform_rotation(1800, lv.PART.INDICATOR | lv.STATE.CHECKED)
# In a menu we don't need to show the last clicked item
dropdown.set_selected_highlight(False)

2
examples/widgets/img/lv_example_img_3.c
View File

@@ -3,7 +3,7 @@
static void set_angle(void * img, int32_t v)
{
lv_image_set_angle(img, v);
lv_image_set_rotation(img, v);
}
static void set_zoom(void * img, int32_t v)

2
examples/widgets/menu/lv_example_menu_1.c
View File

@@ -5,7 +5,7 @@ void lv_example_menu_1(void)
{
/*Create a menu object*/
lv_obj_t * menu = lv_menu_create(lv_scr_act());
lv_obj_set_size(menu, lv_disp_get_hor_res(NULL), lv_disp_get_ver_res(NULL));
lv_obj_set_size(menu, lv_display_get_horizontal_resolution(NULL), lv_display_get_vertical_resolution(NULL));
lv_obj_center(menu);
lv_obj_t * cont;

2
examples/widgets/menu/lv_example_menu_2.c
View File

@@ -17,7 +17,7 @@ void lv_example_menu_2(void)
lv_obj_t * menu = lv_menu_create(lv_scr_act());
lv_menu_set_mode_root_back_button(menu, LV_MENU_ROOT_BACK_BUTTON_ENABLED);
lv_obj_add_event(menu, back_event_handler, LV_EVENT_CLICKED, menu);
lv_obj_set_size(menu, lv_disp_get_hor_res(NULL), lv_disp_get_ver_res(NULL));
lv_obj_set_size(menu, lv_display_get_horizontal_resolution(NULL), lv_display_get_vertical_resolution(NULL));
lv_obj_center(menu);
lv_obj_t * cont;

2
examples/widgets/menu/lv_example_menu_3.c
View File

@@ -5,7 +5,7 @@ void lv_example_menu_3(void)
{
/*Create a menu object*/
lv_obj_t * menu = lv_menu_create(lv_scr_act());
lv_obj_set_size(menu, lv_disp_get_hor_res(NULL), lv_disp_get_ver_res(NULL));
lv_obj_set_size(menu, lv_display_get_horizontal_resolution(NULL), lv_display_get_vertical_resolution(NULL));
lv_obj_center(menu);
/*Modify the header*/

2
examples/widgets/menu/lv_example_menu_4.c
View File

@@ -32,7 +32,7 @@ void lv_example_menu_4(void)
{
/*Create a menu object*/
menu = lv_menu_create(lv_scr_act());
lv_obj_set_size(menu, lv_disp_get_hor_res(NULL), lv_disp_get_ver_res(NULL));
lv_obj_set_size(menu, lv_display_get_horizontal_resolution(NULL), lv_display_get_vertical_resolution(NULL));
lv_obj_center(menu);
lv_obj_t * cont;

2
examples/widgets/menu/lv_example_menu_5.c
View File

@@ -30,7 +30,7 @@ void lv_example_menu_5(void)
}
lv_menu_set_mode_root_back_button(menu, LV_MENU_ROOT_BACK_BUTTON_ENABLED);
lv_obj_add_event(menu, back_event_handler, LV_EVENT_CLICKED, menu);
lv_obj_set_size(menu, lv_disp_get_hor_res(NULL), lv_disp_get_ver_res(NULL));
lv_obj_set_size(menu, lv_display_get_horizontal_resolution(NULL), lv_display_get_vertical_resolution(NULL));
lv_obj_center(menu);
lv_obj_t * cont;

2
examples/widgets/scale/lv_example_scale_5.c
View File

@@ -7,7 +7,7 @@
void lv_example_scale_5(void)
{
lv_obj_t * scale = lv_scale_create(lv_scr_act());
lv_obj_set_size(scale, lv_disp_get_hor_res(NULL) / 2, lv_disp_get_ver_res(NULL) / 2);
lv_obj_set_size(scale, lv_display_get_horizontal_resolution(NULL) / 2, lv_display_get_vertical_resolution(NULL) / 2);
lv_scale_set_label_show(scale, true);
lv_scale_set_total_tick_count(scale, 10);

2
examples/widgets/slider/lv_example_slider_3.c
View File

@@ -40,7 +40,7 @@ static void slider_event_cb(lv_event_t * e)
lv_snprintf(buf, sizeof(buf), "%d - %d", (int)lv_slider_get_left_value(obj), (int)lv_slider_get_value(obj));
lv_point_t label_size;
lv_txt_get_size(&label_size, buf, LV_FONT_DEFAULT, 0, 0, LV_COORD_MAX, 0);
lv_text_get_size(&label_size, buf, LV_FONT_DEFAULT, 0, 0, LV_COORD_MAX, 0);
lv_area_t label_area;
label_area.x1 = 0;
label_area.x2 = label_size.x - 1;

2
examples/widgets/slider/lv_example_slider_3.py
View File

@@ -12,7 +12,7 @@ def slider_event_cb(e):
if base_dsc.part == lv.PART.INDICATOR:
label_text = "{:d} - {:d}".format(obj.get_left_value(),slider.get_value())
label_size = lv.point_t()
lv.txt_get_size(label_size, label_text, lv.font_default(), 0, 0, lv.COORD.MAX, 0)
lv.text_get_size(label_size, label_text, lv.font_default(), 0, 0, lv.COORD.MAX, 0)
# print(label_size.x,label_size.y)
label_area = lv.area_t()
label_area.x1 = dsc.area.x1 + dsc.area.get_width() // 2 - label_size.x // 2

8
lv_conf_template.h
View File

@@ -239,7 +239,7 @@
/*Maximum buffer size to allocate for rotation.
*Only used if software rotation is enabled in the display driver.*/
#define LV_DISP_ROT_MAX_BUF (10*1024)
#define LV_DISPLAY_ROT_MAX_BUF (10*1024)
#define LV_ENABLE_GLOBAL_CUSTOM 0
#if LV_ENABLE_GLOBAL_CUSTOM
@@ -278,7 +278,7 @@
/*Define a custom attribute to `lv_timer_handler` function*/
#define LV_ATTRIBUTE_TIMER_HANDLER
/*Define a custom attribute to `lv_disp_flush_ready` function*/
/*Define a custom attribute to `lv_display_flush_ready` function*/
#define LV_ATTRIBUTE_FLUSH_READY
/*Required alignment size for buffers*/
@@ -721,7 +721,7 @@
#define LV_USE_SDL 0
#if LV_USE_SDL
#define LV_SDL_INCLUDE_PATH <SDL2/SDL.h>
#define LV_SDL_RENDER_MODE LV_DISP_RENDER_MODE_DIRECT /*LV_DISP_RENDER_MODE_DIRECT is recommended for best performance*/
#define LV_SDL_RENDER_MODE LV_DISPLAY_RENDER_MODE_DIRECT /*LV_DISPLAY_RENDER_MODE_DIRECT is recommended for best performance*/
#define LV_SDL_BUF_COUNT 1 /*1 or 2*/
#define LV_SDL_FULLSCREEN 0 /*1: Make the window full screen by default*/
#define LV_SDL_DIRECT_EXIT 1 /*1: Exit the application when all SDL widows are closed*/
@@ -732,7 +732,7 @@
#if LV_USE_LINUX_FBDEV
#define LV_LINUX_FBDEV_BSD 0
#define LV_LINUX_FBDEV_NUTTX 0
#define LV_LINUX_FBDEV_RENDER_MODE LV_DISP_RENDER_MODE_PARTIAL
#define LV_LINUX_FBDEV_RENDER_MODE LV_DISPLAY_RENDER_MODE_PARTIAL
#define LV_LINUX_FBDEV_BUFFER_COUNT 0
#define LV_LINUX_FBDEV_BUFFER_SIZE 60
#endif

8
lvgl.h
View File

@@ -40,7 +40,7 @@ extern "C" {
#include "src/core/lv_group.h"
#include "src/indev/lv_indev.h"
#include "src/core/lv_refr.h"
#include "src/disp/lv_disp.h"
#include "src/display/lv_display.h"
#include "src/font/lv_font.h"
#include "src/font/lv_font_loader.h"
@@ -114,9 +114,9 @@ extern "C" {
#include "src/dev/sdl/lv_sdl_mousewheel.h"
#include "src/dev/sdl/lv_sdl_keyboard.h"
#include "src/dev/disp/drm/lv_linux_drm.h"
#include "src/dev/disp/fb/lv_linux_fbdev.h"
#include "src/dev/disp/lcd/lv_nuttx_lcd.h"
#include "src/dev/display/drm/lv_linux_drm.h"
#include "src/dev/display/fb/lv_linux_fbdev.h"
#include "src/dev/display/lcd/lv_nuttx_lcd.h"
#include "src/dev/input/touchscreen/lv_nuttx_touchscreen.h"

24
scripts/style_api_gen.py
View File

@@ -58,11 +58,11 @@ props = [
'style_type': 'num', 'var_type': 'lv_coord_t', 'default':0, 'inherited': 0, 'layout': 1, 'ext_draw': 0,
'dsc': "Move the object with this value in Y direction. Applied after layouts, aligns and other positioning. Pixel and percentage (with `lv_pct(x)`) values can be used. Percentage values are relative to the object's height." },
{'name': 'TRANSFORM_ZOOM',
{'name': 'TRANSFORM_SCALE',
'style_type': 'num', 'var_type': 'lv_coord_t', 'default':0, 'inherited': 0, 'layout': 1, 'ext_draw': 1,
'dsc': "Zoom an objects. The value 256 (or `LV_ZOOM_NONE`) means normal size, 128 half size, 512 double size, and so on" },
'dsc': "Zoom an objects. The value 256 (or `LV_SCALE_NONE`) means normal size, 128 half size, 512 double size, and so on" },
{'name': 'TRANSFORM_ANGLE',
{'name': 'TRANSFORM_ROTATION',
'style_type': 'num', 'var_type': 'lv_coord_t', 'default':0, 'inherited': 0, 'layout': 1, 'ext_draw': 1,
'dsc': "Rotate an objects. The value is interpreted in 0.1 degree units. E.g. 450 means 45 deg."},
@@ -149,23 +149,23 @@ props = [
'style_type': 'num', 'var_type': 'lv_dither_mode_t', 'default':'`LV_DITHER_NONE`', 'inherited': 0, 'layout': 0, 'ext_draw': 0,
'dsc': "Set the dithering mode of the gradient of the background. The possible values are `LV_DITHER_NONE/ORDERED/ERR_DIFF`."},
{'name': 'BG_IMG_SRC',
{'name': 'BG_IMAGE_SRC',
'style_type': 'ptr', 'var_type': 'const void *', 'default':'`NULL`', 'inherited': 0, 'layout': 0, 'ext_draw': 1,
'dsc': "Set a background image. Can be a pointer to `lv_image_dsc_t`, a path to a file or an `LV_SYMBOL_...`"},
{'name': 'BG_IMG_OPA',
{'name': 'BG_IMAGE_OPA',
'style_type': 'num', 'var_type': 'lv_opa_t', 'default':'`LV_OPA_COVER`', 'inherited': 0, 'layout': 0, 'ext_draw': 0,
'dsc': "Set the opacity of the background image. Value 0, `LV_OPA_0` or `LV_OPA_TRANSP` means fully transparent, 255, `LV_OPA_100` or `LV_OPA_COVER` means fully covering, other values or LV_OPA_10, LV_OPA_20, etc means semi transparency."},
{'name': 'BG_IMG_RECOLOR',
{'name': 'BG_IMAGE_RECOLOR',
'style_type': 'color', 'var_type': 'lv_color_t', 'default':'`0x000000`', 'inherited': 0, 'layout': 0, 'ext_draw': 0, 'filtered': 1,
'dsc': "Set a color to mix to the background image."},
{'name': 'BG_IMG_RECOLOR_OPA',
{'name': 'BG_IMAGE_RECOLOR_OPA',
'style_type': 'num', 'var_type': 'lv_opa_t', 'default':'`LV_OPA_TRANSP`', 'inherited': 0, 'layout': 0, 'ext_draw': 0,
'dsc': "Set the intensity of background image recoloring. Value 0, `LV_OPA_0` or `LV_OPA_TRANSP` means no mixing, 255, `LV_OPA_100` or `LV_OPA_COVER` means full recoloring, other values or LV_OPA_10, LV_OPA_20, etc are interpreted proportionally."},
{'name': 'BG_IMG_TILED',
{'name': 'BG_IMAGE_TILED',
'style_type': 'num', 'var_type': 'bool', 'default':0, 'inherited': 0, 'layout': 0, 'ext_draw': 0,
'dsc': "If enabled the background image will be tiled. The possible values are `true` or `false`."},
@@ -233,15 +233,15 @@ props = [
'dsc': "Set the opacity of the shadow. Value 0, `LV_OPA_0` or `LV_OPA_TRANSP` means fully transparent, 255, `LV_OPA_100` or `LV_OPA_COVER` means fully covering, other values or LV_OPA_10, LV_OPA_20, etc means semi transparency."},
{'section': 'Image', 'dsc':'Properties to describe the images' },
{'name': 'IMG_OPA',
{'name': 'IMAGE_OPA',
'style_type': 'num', 'var_type': 'lv_opa_t' , 'default':'`LV_OPA_COVER`', 'inherited': 0, 'layout': 0, 'ext_draw': 0,
'dsc': "Set the opacity of an image. Value 0, `LV_OPA_0` or `LV_OPA_TRANSP` means fully transparent, 255, `LV_OPA_100` or `LV_OPA_COVER` means fully covering, other values or LV_OPA_10, LV_OPA_20, etc means semi transparency."},
{'name': 'IMG_RECOLOR',
{'name': 'IMAGE_RECOLOR',
'style_type': 'color', 'var_type': 'lv_color_t', 'default':'`0x000000`', 'inherited': 0, 'layout': 0, 'ext_draw': 0, 'filtered': 1,
'dsc': "Set color to mixt to the image."},
{'name': 'IMG_RECOLOR_OPA',
{'name': 'IMAGE_RECOLOR_OPA',
'style_type': 'num', 'var_type': 'lv_opa_t' , 'default':0, 'inherited': 0, 'layout': 0, 'ext_draw': 0,
'dsc': "Set the intensity of the color mixing. Value 0, `LV_OPA_0` or `LV_OPA_TRANSP` means fully transparent, 255, `LV_OPA_100` or `LV_OPA_COVER` means fully covering, other values or LV_OPA_10, LV_OPA_20, etc means semi transparency."},
@@ -287,7 +287,7 @@ props = [
'style_type': 'num', 'var_type': 'lv_opa_t' , 'default':'`LV_OPA_COVER`', 'inherited': 0, 'layout': 0, 'ext_draw': 0,
'dsc': "Set the opacity of the arcs."},
{'name': 'ARC_IMG_SRC',
{'name': 'ARC_IMAGE_SRC',
'style_type': 'ptr', 'var_type': 'const void *', 'default':'`NULL`', 'inherited': 0, 'layout': 0, 'ext_draw': 0,
'dsc': "Set an image from which the arc will be masked out. It's useful to display complex effects on the arcs. Can be a pointer to `lv_image_dsc_t` or a path to a file"},

6
src/core/lv_global.h
View File

@@ -49,7 +49,7 @@ extern "C" {
* TYPEDEFS
**********************/
struct _lv_disp_t;
struct _lv_display_t;
struct _lv_group_t;
struct _my_theme_t;
struct _lv_indev_t;
@@ -68,8 +68,8 @@ typedef struct _lv_global_t {
bool inited;
lv_ll_t disp_ll;
struct _lv_disp_t * disp_refresh;
struct _lv_disp_t * disp_default;
struct _lv_display_t * disp_refresh;
struct _lv_display_t * disp_default;
lv_ll_t style_trans_ll;
bool style_refresh;

26
src/core/lv_group.c
View File

@@ -246,8 +246,8 @@ void lv_group_focus_obj(lv_obj_t * obj)
_LV_LL_READ(&g->obj_ll, i) {
if(*i == obj) {
if(g->obj_focus != NULL && obj != *g->obj_focus) { /*Do not defocus if the same object needs to be focused again*/
lv_res_t res = lv_obj_send_event(*g->obj_focus, LV_EVENT_DEFOCUSED, get_indev(g));
if(res != LV_RES_OK) return;
lv_result_t res = lv_obj_send_event(*g->obj_focus, LV_EVENT_DEFOCUSED, get_indev(g));
if(res != LV_RESULT_OK) return;
lv_obj_invalidate(*g->obj_focus);
}
@@ -255,8 +255,8 @@ void lv_group_focus_obj(lv_obj_t * obj)
if(g->obj_focus != NULL) {
if(g->focus_cb) g->focus_cb(g);
lv_res_t res = lv_obj_send_event(*g->obj_focus, LV_EVENT_FOCUSED, get_indev(g));
if(res != LV_RES_OK) return;
lv_result_t res = lv_obj_send_event(*g->obj_focus, LV_EVENT_FOCUSED, get_indev(g));
if(res != LV_RESULT_OK) return;
lv_obj_invalidate(*g->obj_focus);
}
break;
@@ -288,12 +288,12 @@ void lv_group_focus_freeze(lv_group_t * group, bool en)
else group->frozen = 1;
}
lv_res_t lv_group_send_data(lv_group_t * group, uint32_t c)
lv_result_t lv_group_send_data(lv_group_t * group, uint32_t c)
{
lv_obj_t * act = lv_group_get_focused(group);
if(act == NULL) return LV_RES_OK;
if(act == NULL) return LV_RESULT_OK;
if(lv_obj_has_state(act, LV_STATE_DISABLED)) return LV_RES_OK;
if(lv_obj_has_state(act, LV_STATE_DISABLED)) return LV_RESULT_OK;
return lv_obj_send_event(act, LV_EVENT_KEY, &c);
}
@@ -319,8 +319,8 @@ void lv_group_set_editing(lv_group_t * group, bool edit)
lv_obj_t * focused = lv_group_get_focused(group);
if(focused) {
lv_res_t res = lv_obj_send_event(*group->obj_focus, LV_EVENT_FOCUSED, get_indev(group));
if(res != LV_RES_OK) return;
lv_result_t res = lv_obj_send_event(*group->obj_focus, LV_EVENT_FOCUSED, get_indev(group));
if(res != LV_RESULT_OK) return;
lv_obj_invalidate(focused);
}
@@ -449,15 +449,15 @@ static bool focus_next_core(lv_group_t * group, void * (*begin)(const lv_ll_t *)
if(obj_next == group->obj_focus) return focus_changed; /*There's only one visible object and it's already focused*/
if(group->obj_focus) {
lv_res_t res = lv_obj_send_event(*group->obj_focus, LV_EVENT_DEFOCUSED, get_indev(group));
if(res != LV_RES_OK) return focus_changed;
lv_result_t res = lv_obj_send_event(*group->obj_focus, LV_EVENT_DEFOCUSED, get_indev(group));
if(res != LV_RESULT_OK) return focus_changed;
lv_obj_invalidate(*group->obj_focus);
}
group->obj_focus = obj_next;
lv_res_t res = lv_obj_send_event(*group->obj_focus, LV_EVENT_FOCUSED, get_indev(group));
if(res != LV_RES_OK) return focus_changed;
lv_result_t res = lv_obj_send_event(*group->obj_focus, LV_EVENT_FOCUSED, get_indev(group));
if(res != LV_RESULT_OK) return focus_changed;
lv_obj_invalidate(*group->obj_focus);

2
src/core/lv_group.h
View File

@@ -178,7 +178,7 @@ void lv_group_focus_freeze(lv_group_t * group, bool en);
* @param c a character (use LV_KEY_.. to navigate)
* @return result of focused object in group.
*/
lv_res_t lv_group_send_data(lv_group_t * group, uint32_t c);
lv_result_t lv_group_send_data(lv_group_t * group, uint32_t c);
/**
* Set a function for a group which will be called when a new object is focused

30
src/core/lv_obj.c
View File

@@ -11,8 +11,8 @@
#include "../indev/lv_indev_private.h"
#include "lv_refr.h"
#include "lv_group.h"
#include "../disp/lv_disp.h"
#include "../disp/lv_disp_private.h"
#include "../display/lv_display.h"
#include "../display/lv_display_private.h"
#include "../themes/lv_theme.h"
#include "../misc/lv_assert.h"
#include "../misc/lv_math.h"
@@ -42,7 +42,7 @@ static void lv_obj_destructor(const lv_obj_class_t * class_p, lv_obj_t * obj);
static void lv_obj_draw(lv_event_t * e);
static void lv_obj_event(const lv_obj_class_t * class_p, lv_event_t * e);
static void draw_scrollbar(lv_obj_t * obj, lv_layer_t * layer);
static lv_res_t scrollbar_init_draw_dsc(lv_obj_t * obj, lv_draw_rect_dsc_t * dsc);
static lv_result_t scrollbar_init_draw_dsc(lv_obj_t * obj, lv_draw_rect_dsc_t * dsc);
static bool obj_valid_child(const lv_obj_t * parent, const lv_obj_t * obj_to_find);
static void lv_obj_set_state(lv_obj_t * obj, lv_state_t new_state);
@@ -259,7 +259,7 @@ const lv_obj_class_t * lv_obj_get_class(const lv_obj_t * obj)
bool lv_obj_is_valid(const lv_obj_t * obj)
{
lv_disp_t * disp = lv_disp_get_next(NULL);
lv_display_t * disp = lv_display_get_next(NULL);
while(disp) {
uint32_t i;
for(i = 0; i < disp->screen_cnt; i++) {
@@ -268,7 +268,7 @@ bool lv_obj_is_valid(const lv_obj_t * obj)
if(found) return true;
}
disp = lv_disp_get_next(disp);
disp = lv_display_get_next(disp);
}
return false;
@@ -435,8 +435,8 @@ static void draw_scrollbar(lv_obj_t * obj, lv_layer_t * layer)
if(lv_area_get_size(&hor_area) <= 0 && lv_area_get_size(&ver_area) <= 0) return;
lv_draw_rect_dsc_t draw_dsc;
lv_res_t sb_res = scrollbar_init_draw_dsc(obj, &draw_dsc);
if(sb_res != LV_RES_OK) return;
lv_result_t sb_res = scrollbar_init_draw_dsc(obj, &draw_dsc);
if(sb_res != LV_RESULT_OK) return;
if(lv_area_get_size(&hor_area) > 0) {
draw_dsc.base.id1 = 0;
@@ -452,9 +452,9 @@ static void draw_scrollbar(lv_obj_t * obj, lv_layer_t * layer)
* Initialize the draw descriptor for the scrollbar
* @param obj pointer to an object
* @param dsc the draw descriptor to initialize
* @return LV_RES_OK: the scrollbar is visible; LV_RES_INV: the scrollbar is not visible
* @return LV_RESULT_OK: the scrollbar is visible; LV_RESULT_INVALID: the scrollbar is not visible
*/
static lv_res_t scrollbar_init_draw_dsc(lv_obj_t * obj, lv_draw_rect_dsc_t * dsc)
static lv_result_t scrollbar_init_draw_dsc(lv_obj_t * obj, lv_draw_rect_dsc_t * dsc)
{
lv_draw_rect_dsc_init(dsc);
dsc->bg_opa = lv_obj_get_style_bg_opa(obj, LV_PART_SCROLLBAR);
@@ -495,10 +495,10 @@ static lv_res_t scrollbar_init_draw_dsc(lv_obj_t * obj, lv_draw_rect_dsc_t * dsc
if(dsc->bg_opa != LV_OPA_TRANSP || dsc->border_opa != LV_OPA_TRANSP || dsc->shadow_opa != LV_OPA_TRANSP) {
dsc->radius = lv_obj_get_style_radius(obj, LV_PART_SCROLLBAR);
return LV_RES_OK;
return LV_RESULT_OK;
}
else {
return LV_RES_INV;
return LV_RESULT_INVALID;
}
}
@@ -519,8 +519,8 @@ static void lv_obj_event(const lv_obj_class_t * class_p, lv_event_t * e)
if(!(lv_obj_get_state(obj) & LV_STATE_CHECKED)) lv_obj_add_state(obj, LV_STATE_CHECKED);
else lv_obj_clear_state(obj, LV_STATE_CHECKED);
lv_res_t res = lv_obj_send_event(obj, LV_EVENT_VALUE_CHANGED, NULL);
if(res != LV_RES_OK) return;
lv_result_t res = lv_obj_send_event(obj, LV_EVENT_VALUE_CHANGED, NULL);
if(res != LV_RESULT_OK) return;
}
}
else if(code == LV_EVENT_PRESS_LOST) {
@@ -545,8 +545,8 @@ static void lv_obj_event(const lv_obj_class_t * class_p, lv_event_t * e)
/*With Enter LV_EVENT_RELEASED will send VALUE_CHANGE event*/
if(c != LV_KEY_ENTER) {
lv_res_t res = lv_obj_send_event(obj, LV_EVENT_VALUE_CHANGED, NULL);
if(res != LV_RES_OK) return;
lv_result_t res = lv_obj_send_event(obj, LV_EVENT_VALUE_CHANGED, NULL);
if(res != LV_RESULT_OK) return;
}
}
else if(lv_obj_has_flag(obj, LV_OBJ_FLAG_SCROLLABLE | LV_OBJ_FLAG_SCROLL_WITH_ARROW) && !lv_obj_is_editable(obj)) {

10
src/core/lv_obj_class.c
View File

@@ -8,8 +8,8 @@
*********************/
#include "lv_obj.h"
#include "../themes/lv_theme.h"
#include "../disp/lv_disp.h"
#include "../disp/lv_disp_private.h"
#include "../display/lv_display.h"
#include "../display/lv_display_private.h"
#include "../stdlib/lv_string.h"
/*********************
@@ -56,7 +56,7 @@ lv_obj_t * lv_obj_class_create_obj(const lv_obj_class_t * class_p, lv_obj_t * pa
/*Create a screen*/
if(parent == NULL) {
LV_TRACE_OBJ_CREATE("creating a screen");
lv_disp_t * disp = lv_disp_get_default();
lv_display_t * disp = lv_display_get_default();
if(!disp) {
LV_LOG_WARN("No display created yet. No place to assign the new screen");
lv_free(obj);
@@ -74,8 +74,8 @@ lv_obj_t * lv_obj_class_create_obj(const lv_obj_class_t * class_p, lv_obj_t * pa
/*Set coordinates to full screen size*/
obj->coords.x1 = 0;
obj->coords.y1 = 0;
obj->coords.x2 = lv_disp_get_hor_res(NULL) - 1;
obj->coords.y2 = lv_disp_get_ver_res(NULL) - 1;
obj->coords.x2 = lv_display_get_horizontal_resolution(NULL) - 1;
obj->coords.y2 = lv_display_get_vertical_resolution(NULL) - 1;
}
/*Create a normal object*/
else {

6
src/core/lv_obj_draw.c
View File

@@ -8,7 +8,7 @@
*********************/
#include "lv_obj_draw.h"
#include "lv_obj.h"
#include "../disp/lv_disp.h"
#include "../display/lv_display.h"
#include "../indev/lv_indev.h"
#include "../stdlib/lv_string.h"
@@ -186,8 +186,8 @@ void lv_obj_init_draw_image_dsc(lv_obj_t * obj, uint32_t part, lv_draw_image_dsc
}
if(draw_dsc->opa <= LV_OPA_MIN) return;
draw_dsc->angle = 0;
draw_dsc->zoom = LV_ZOOM_NONE;
draw_dsc->rotation = 0;
draw_dsc->zoom = LV_SCALE_NONE;
draw_dsc->pivot.x = lv_area_get_width(&obj->coords) / 2;
draw_dsc->pivot.y = lv_area_get_height(&obj->coords) / 2;

34
src/core/lv_obj_event.c
View File

@@ -22,7 +22,7 @@
/**********************
* STATIC PROTOTYPES
**********************/
static lv_res_t event_send_core(lv_event_t * e);
static lv_result_t event_send_core(lv_event_t * e);
static bool event_is_bubbled(lv_event_t * e);
/**********************
@@ -42,9 +42,9 @@ static bool event_is_bubbled(lv_event_t * e);
* GLOBAL FUNCTIONS
**********************/
lv_res_t lv_obj_send_event(lv_obj_t * obj, lv_event_code_t event_code, void * param)
lv_result_t lv_obj_send_event(lv_obj_t * obj, lv_event_code_t event_code, void * param)
{
if(obj == NULL) return LV_RES_OK;
if(obj == NULL) return LV_RESULT_OK;
LV_ASSERT_OBJ(obj, MY_CLASS);
@@ -61,7 +61,7 @@ lv_res_t lv_obj_send_event(lv_obj_t * obj, lv_event_code_t event_code, void * pa
_lv_event_push(&e);
/*Send the event*/
lv_res_t res = event_send_core(&e);
lv_result_t res = event_send_core(&e);
/*Remove this element from the list*/
_lv_event_pop(&e);
@@ -70,7 +70,7 @@ lv_res_t lv_obj_send_event(lv_obj_t * obj, lv_event_code_t event_code, void * pa
}
lv_res_t lv_obj_event_base(const lv_obj_class_t * class_p, lv_event_t * e)
lv_result_t lv_obj_event_base(const lv_obj_class_t * class_p, lv_event_t * e)
{
const lv_obj_class_t * base;
if(class_p == NULL) base = ((lv_obj_t *)e->current_target)->class_p;
@@ -79,16 +79,16 @@ lv_res_t lv_obj_event_base(const lv_obj_class_t * class_p, lv_event_t * e)
/*Find a base in which call the ancestor's event handler_cb if set*/
while(base && base->event_cb == NULL) base = base->base_class;
if(base == NULL) return LV_RES_OK;
if(base->event_cb == NULL) return LV_RES_OK;
if(base == NULL) return LV_RESULT_OK;
if(base->event_cb == NULL) return LV_RESULT_OK;
/*Call the actual event callback*/
e->user_data = NULL;
base->event_cb(base, e);
lv_res_t res = LV_RES_OK;
lv_result_t res = LV_RESULT_OK;
/*Stop if the object is deleted*/
if(e->deleted) res = LV_RES_INV;
if(e->deleted) res = LV_RESULT_INVALID;
return res;
}
@@ -285,7 +285,7 @@ lv_draw_task_t * lv_event_get_draw_task(lv_event_t * e)
* STATIC FUNCTIONS
**********************/
static lv_res_t event_send_core(lv_event_t * e)
static lv_result_t event_send_core(lv_event_t * e)
{
EVENT_TRACE("Sending event %d to %p with %p param", e->code, (void *)e->original_target, e->param);
@@ -293,28 +293,28 @@ static lv_res_t event_send_core(lv_event_t * e)
lv_indev_t * indev_act = lv_indev_get_act();
if(indev_act) {
if(indev_act->feedback_cb) indev_act->feedback_cb(indev_act, e);
if(e->stop_processing) return LV_RES_OK;
if(e->deleted) return LV_RES_INV;
if(e->stop_processing) return LV_RESULT_OK;
if(e->deleted) return LV_RESULT_INVALID;
}
lv_obj_t * target = e->current_target;
lv_res_t res = LV_RES_OK;
lv_result_t res = LV_RESULT_OK;
lv_event_list_t * list = target->spec_attr ? &target->spec_attr->event_list : NULL;
res = lv_event_send(list, e, true);
if(res != LV_RES_OK) return res;
if(res != LV_RESULT_OK) return res;
res = lv_obj_event_base(NULL, e);
if(res != LV_RES_OK) return res;
if(res != LV_RESULT_OK) return res;
res = lv_event_send(list, e, false);
if(res != LV_RES_OK) return res;
if(res != LV_RESULT_OK) return res;
lv_obj_t * parent = lv_obj_get_parent(e->current_target);
if(parent && event_is_bubbled(e)) {
e->current_target = parent;
res = event_send_core(e);
if(res != LV_RES_OK) return res;
if(res != LV_RESULT_OK) return res;
}
return res;

8
src/core/lv_obj_event.h
View File

@@ -67,17 +67,17 @@ typedef struct {
* @param obj pointer to an object
* @param event_code the type of the event from `lv_event_t`
* @param param arbitrary data depending on the widget type and the event. (Usually `NULL`)
* @return LV_RES_OK: `obj` was not deleted in the event; LV_RES_INV: `obj` was deleted in the event_code
* @return LV_RESULT_OK: `obj` was not deleted in the event; LV_RESULT_INVALID: `obj` was deleted in the event_code
*/
lv_res_t lv_obj_send_event(struct _lv_obj_t * obj, lv_event_code_t event_code, void * param);
lv_result_t lv_obj_send_event(struct _lv_obj_t * obj, lv_event_code_t event_code, void * param);
/**
* Used by the widgets internally to call the ancestor widget types's event handler
* @param class_p pointer to the class of the widget (NOT the ancestor class)
* @param e pointer to the event descriptor
* @return LV_RES_OK: the target object was not deleted in the event; LV_RES_INV: it was deleted in the event_code
* @return LV_RESULT_OK: the target object was not deleted in the event; LV_RESULT_INVALID: it was deleted in the event_code
*/
lv_res_t lv_obj_event_base(const struct _lv_obj_class_t * class_p, lv_event_t * e);
lv_result_t lv_obj_event_base(const struct _lv_obj_class_t * class_p, lv_event_t * e);
/**
* Get the current target of the event. It's the object which event handler being called.

46
src/core/lv_obj_pos.c
View File

@@ -7,8 +7,8 @@
* INCLUDES
*********************/
#include "lv_obj.h"
#include "../disp/lv_disp.h"
#include "../disp/lv_disp_private.h"
#include "../display/lv_display.h"
#include "../display/lv_display_private.h"
#include "lv_refr.h"
#include "../core/lv_global.h"
@@ -54,12 +54,12 @@ void lv_obj_set_x(lv_obj_t * obj, lv_coord_t x)
{
LV_ASSERT_OBJ(obj, MY_CLASS);
lv_res_t res_x;
lv_result_t res_x;
lv_style_value_t v_x;
res_x = lv_obj_get_local_style_prop(obj, LV_STYLE_X, &v_x, 0);
if((res_x == LV_RES_OK && v_x.num != x) || res_x == LV_RES_INV) {
if((res_x == LV_RESULT_OK && v_x.num != x) || res_x == LV_RESULT_INVALID) {
lv_obj_set_style_x(obj, x, 0);
}
}
@@ -68,12 +68,12 @@ void lv_obj_set_y(lv_obj_t * obj, lv_coord_t y)
{
LV_ASSERT_OBJ(obj, MY_CLASS);
lv_res_t res_y;
lv_result_t res_y;
lv_style_value_t v_y;
res_y = lv_obj_get_local_style_prop(obj, LV_STYLE_Y, &v_y, 0);
if((res_y == LV_RES_OK && v_y.num != y) || res_y == LV_RES_INV) {
if((res_y == LV_RESULT_OK && v_y.num != y) || res_y == LV_RESULT_INVALID) {
lv_obj_set_style_y(obj, y, 0);
}
}
@@ -215,12 +215,12 @@ void lv_obj_set_size(lv_obj_t * obj, lv_coord_t w, lv_coord_t h)
void lv_obj_set_width(lv_obj_t * obj, lv_coord_t w)
{
LV_ASSERT_OBJ(obj, MY_CLASS);
lv_res_t res_w;
lv_result_t res_w;
lv_style_value_t v_w;
res_w = lv_obj_get_local_style_prop(obj, LV_STYLE_WIDTH, &v_w, 0);
if((res_w == LV_RES_OK && v_w.num != w) || res_w == LV_RES_INV) {
if((res_w == LV_RESULT_OK && v_w.num != w) || res_w == LV_RESULT_INVALID) {
lv_obj_set_style_width(obj, w, 0);
}
}
@@ -228,12 +228,12 @@ void lv_obj_set_width(lv_obj_t * obj, lv_coord_t w)
void lv_obj_set_height(lv_obj_t * obj, lv_coord_t h)
{
LV_ASSERT_OBJ(obj, MY_CLASS);
lv_res_t res_h;
lv_result_t res_h;
lv_style_value_t v_h;
res_h = lv_obj_get_local_style_prop(obj, LV_STYLE_HEIGHT, &v_h, 0);
if((res_h == LV_RES_OK && v_h.num != h) || res_h == LV_RES_INV) {
if((res_h == LV_RESULT_OK && v_h.num != h) || res_h == LV_RESULT_INVALID) {
lv_obj_set_style_height(obj, h, 0);
}
}
@@ -282,8 +282,8 @@ void lv_obj_mark_layout_as_dirty(lv_obj_t * obj)
scr->scr_layout_inv = 1;
/*Make the display refreshing*/
lv_disp_t * disp = lv_obj_get_disp(scr);
lv_disp_send_event(disp, LV_EVENT_REFR_REQUEST, NULL);
lv_display_t * disp = lv_obj_get_disp(scr);
lv_display_send_event(disp, LV_EVENT_REFR_REQUEST, NULL);
}
void lv_obj_update_layout(const lv_obj_t * obj)
@@ -802,8 +802,8 @@ void lv_obj_invalidate_area(const lv_obj_t * obj, const lv_area_t * area)
{
LV_ASSERT_OBJ(obj, MY_CLASS);
lv_disp_t * disp = lv_obj_get_disp(obj);
if(!lv_disp_is_invalidation_enabled(disp)) return;
lv_display_t * disp = lv_obj_get_disp(obj);
if(!lv_display_is_invalidation_enabled(disp)) return;
lv_area_t area_tmp;
lv_area_copy(&area_tmp, area);
@@ -834,12 +834,12 @@ bool lv_obj_area_is_visible(const lv_obj_t * obj, lv_area_t * area)
/*Invalidate the object only if it belongs to the current or previous or one of the layers'*/
lv_obj_t * obj_scr = lv_obj_get_screen(obj);
lv_disp_t * disp = lv_obj_get_disp(obj_scr);
if(obj_scr != lv_disp_get_scr_act(disp) &&
obj_scr != lv_disp_get_scr_prev(disp) &&
obj_scr != lv_disp_get_layer_bottom(disp) &&
obj_scr != lv_disp_get_layer_top(disp) &&
obj_scr != lv_disp_get_layer_sys(disp)) {
lv_display_t * disp = lv_obj_get_disp(obj_scr);
if(obj_scr != lv_display_get_scr_act(disp) &&
obj_scr != lv_display_get_scr_prev(disp) &&
obj_scr != lv_display_get_layer_bottom(disp) &&
obj_scr != lv_display_get_layer_top(disp) &&
obj_scr != lv_display_get_layer_sys(disp)) {
return false;
}
@@ -1118,10 +1118,10 @@ static void layout_update_core(lv_obj_t * obj)
static void transform_point(const lv_obj_t * obj, lv_point_t * p, bool inv)
{
lv_coord_t angle = lv_obj_get_style_transform_angle(obj, 0);
lv_coord_t zoom = lv_obj_get_style_transform_zoom_safe(obj, 0);
lv_coord_t angle = lv_obj_get_style_transform_rotation(obj, 0);
lv_coord_t zoom = lv_obj_get_style_transform_scale_safe(obj, 0);
if(angle == 0 && zoom == LV_ZOOM_NONE) return;
if(angle == 0 && zoom == LV_SCALE_NONE) return;
lv_point_t pivot = {
.x = lv_obj_get_style_transform_pivot_x(obj, 0),

38
src/core/lv_obj_scroll.c
View File

@@ -10,7 +10,7 @@
#include "lv_obj.h"
#include "../indev/lv_indev.h"
#include "../indev/lv_indev_scroll.h"
#include "../disp/lv_disp.h"
#include "../display/lv_display.h"
/*********************
* DEFINES
@@ -306,14 +306,14 @@ void lv_obj_scroll_by(lv_obj_t * obj, lv_coord_t dx, lv_coord_t dy, lv_anim_enab
{
if(dx == 0 && dy == 0) return;
if(anim_en == LV_ANIM_ON) {
lv_disp_t * d = lv_obj_get_disp(obj);
lv_display_t * d = lv_obj_get_disp(obj);
lv_anim_t a;
lv_anim_init(&a);
lv_anim_set_var(&a, obj);
lv_anim_set_ready_cb(&a, scroll_anim_ready_cb);
if(dx) {
uint32_t t = lv_anim_speed_to_time((lv_disp_get_hor_res(d) * 2) >> 2, 0, dx);
uint32_t t = lv_anim_speed_to_time((lv_display_get_horizontal_resolution(d) * 2) >> 2, 0, dx);
if(t < SCROLL_ANIM_TIME_MIN) t = SCROLL_ANIM_TIME_MIN;
if(t > SCROLL_ANIM_TIME_MAX) t = SCROLL_ANIM_TIME_MAX;
lv_anim_set_time(&a, t);
@@ -322,14 +322,14 @@ void lv_obj_scroll_by(lv_obj_t * obj, lv_coord_t dx, lv_coord_t dy, lv_anim_enab
lv_anim_set_exec_cb(&a, scroll_x_anim);
lv_anim_set_path_cb(&a, lv_anim_path_ease_out);
lv_res_t res;
lv_result_t res;
res = lv_obj_send_event(obj, LV_EVENT_SCROLL_BEGIN, &a);
if(res != LV_RES_OK) return;
if(res != LV_RESULT_OK) return;
lv_anim_start(&a);
}
if(dy) {
uint32_t t = lv_anim_speed_to_time((lv_disp_get_ver_res(d) * 2) >> 2, 0, dy);
uint32_t t = lv_anim_speed_to_time((lv_display_get_vertical_resolution(d) * 2) >> 2, 0, dy);
if(t < SCROLL_ANIM_TIME_MIN) t = SCROLL_ANIM_TIME_MIN;
if(t > SCROLL_ANIM_TIME_MAX) t = SCROLL_ANIM_TIME_MAX;
lv_anim_set_time(&a, t);
@@ -338,9 +338,9 @@ void lv_obj_scroll_by(lv_obj_t * obj, lv_coord_t dx, lv_coord_t dy, lv_anim_enab
lv_anim_set_exec_cb(&a, scroll_y_anim);
lv_anim_set_path_cb(&a, lv_anim_path_ease_out);
lv_res_t res;
lv_result_t res;
res = lv_obj_send_event(obj, LV_EVENT_SCROLL_BEGIN, &a);
if(res != LV_RES_OK) return;
if(res != LV_RESULT_OK) return;
lv_anim_start(&a);
}
}
@@ -349,15 +349,15 @@ void lv_obj_scroll_by(lv_obj_t * obj, lv_coord_t dx, lv_coord_t dy, lv_anim_enab
lv_anim_del(obj, scroll_y_anim);
lv_anim_del(obj, scroll_x_anim);
lv_res_t res;
lv_result_t res;
res = lv_obj_send_event(obj, LV_EVENT_SCROLL_BEGIN, NULL);
if(res != LV_RES_OK) return;
if(res != LV_RESULT_OK) return;
res = _lv_obj_scroll_by_raw(obj, dx, dy);
if(res != LV_RES_OK) return;
if(res != LV_RESULT_OK) return;
res = lv_obj_send_event(obj, LV_EVENT_SCROLL_END, NULL);
if(res != LV_RES_OK) return;
if(res != LV_RESULT_OK) return;
}
}
@@ -411,9 +411,9 @@ void lv_obj_scroll_to_view_recursive(lv_obj_t * obj, lv_anim_enable_t anim_en)
}
}
lv_res_t _lv_obj_scroll_by_raw(lv_obj_t * obj, lv_coord_t x, lv_coord_t y)
lv_result_t _lv_obj_scroll_by_raw(lv_obj_t * obj, lv_coord_t x, lv_coord_t y)
{
if(x == 0 && y == 0) return LV_RES_OK;
if(x == 0 && y == 0) return LV_RESULT_OK;
lv_obj_allocate_spec_attr(obj);
@@ -421,10 +421,10 @@ lv_res_t _lv_obj_scroll_by_raw(lv_obj_t * obj, lv_coord_t x, lv_coord_t y)
obj->spec_attr->scroll.y += y;
lv_obj_move_children_by(obj, x, y, true);
lv_res_t res = lv_obj_send_event(obj, LV_EVENT_SCROLL, NULL);
if(res != LV_RES_OK) return res;
lv_result_t res = lv_obj_send_event(obj, LV_EVENT_SCROLL, NULL);
if(res != LV_RESULT_OK) return res;
lv_obj_invalidate(obj);
return LV_RES_OK;
return LV_RESULT_OK;
}
@@ -785,9 +785,9 @@ static void scroll_area_into_view(const lv_area_t * area, lv_obj_t * child, lv_p
bool y_del = lv_anim_del(parent, scroll_y_anim);
bool x_del = lv_anim_del(parent, scroll_x_anim);
if(y_del || x_del) {
lv_res_t res;
lv_result_t res;
res = lv_obj_send_event(parent, LV_EVENT_SCROLL_END, NULL);
if(res != LV_RES_OK) return;
if(res != LV_RESULT_OK) return;
}
if((scroll_dir & LV_DIR_LEFT) == 0 && x_scroll < 0) x_scroll = 0;

6
src/core/lv_obj_scroll.h
View File

@@ -265,10 +265,10 @@ void lv_obj_scroll_to_view_recursive(struct _lv_obj_t * obj, lv_anim_enable_t an
* @param obj pointer to an object to scroll
* @param x pixels to scroll horizontally
* @param y pixels to scroll vertically
* @return `LV_RES_INV`: to object was deleted in `LV_EVENT_SCROLL`;
* `LV_RES_OK`: if the object is still valid
* @return `LV_RESULT_INVALID`: to object was deleted in `LV_EVENT_SCROLL`;
* `LV_RESULT_OK`: if the object is still valid
*/
lv_res_t _lv_obj_scroll_by_raw(struct _lv_obj_t * obj, lv_coord_t x, lv_coord_t y);
lv_result_t _lv_obj_scroll_by_raw(struct _lv_obj_t * obj, lv_coord_t x, lv_coord_t y);
/**
* Tell whether an object is being scrolled or not at this moment

28
src/core/lv_obj_style.c
View File

@@ -7,8 +7,8 @@
* INCLUDES
*********************/
#include "lv_obj.h"
#include "../disp/lv_disp.h"
#include "../disp/lv_disp_private.h"
#include "../display/lv_display.h"
#include "../display/lv_display_private.h"
#include "../misc/lv_color.h"
#include "../stdlib/lv_string.h"
#include "../core/lv_global.h"
@@ -246,14 +246,14 @@ void lv_obj_remove_style_all(struct _lv_obj_t * obj)
void lv_obj_report_style_change(lv_style_t * style)
{
if(!style_refr) return;
lv_disp_t * d = lv_disp_get_next(NULL);
lv_display_t * d = lv_display_get_next(NULL);
while(d) {
uint32_t i;
for(i = 0; i < d->screen_cnt; i++) {
report_style_change_core(style, d->screens[i]);
}
d = lv_disp_get_next(d);
d = lv_display_get_next(d);
}
}
@@ -319,9 +319,9 @@ static inline lv_style_value_t lv_style_prop_get_default_inlined(lv_style_prop_t
const lv_color_t black = LV_COLOR_MAKE(0x00, 0x00, 0x00);
const lv_color_t white = LV_COLOR_MAKE(0xff, 0xff, 0xff);
switch(prop) {
case LV_STYLE_TRANSFORM_ZOOM:
case LV_STYLE_TRANSFORM_SCALE:
return (lv_style_value_t) {
.num = LV_ZOOM_NONE
.num = LV_SCALE_NONE
};
case LV_STYLE_BG_COLOR:
return (lv_style_value_t) {
@@ -497,8 +497,8 @@ bool lv_obj_remove_local_style_prop(lv_obj_t * obj, lv_style_prop_t prop, lv_sty
/*The style is not found*/
if(i == obj->style_cnt) return false;
lv_res_t res = lv_style_remove_prop((lv_style_t *)obj->styles[i].style, prop);
if(res == LV_RES_OK) {
lv_result_t res = lv_style_remove_prop((lv_style_t *)obj->styles[i].style, prop);
if(res == LV_RESULT_OK) {
full_cache_refresh(obj, lv_obj_style_get_selector_part(selector));
lv_obj_refresh_style(obj, selector, prop);
}
@@ -606,8 +606,8 @@ _lv_style_state_cmp_t _lv_obj_style_state_compare(lv_obj_t * obj, lv_state_t sta
else if(lv_style_get_prop(style, LV_STYLE_MIN_HEIGHT, &v)) layout_diff = true;
else if(lv_style_get_prop(style, LV_STYLE_MAX_HEIGHT, &v)) layout_diff = true;
else if(lv_style_get_prop(style, LV_STYLE_BORDER_WIDTH, &v)) layout_diff = true;
else if(lv_style_get_prop(style, LV_STYLE_TRANSFORM_ANGLE, &v)) layout_diff = true;
else if(lv_style_get_prop(style, LV_STYLE_TRANSFORM_ZOOM, &v)) layout_diff = true;
else if(lv_style_get_prop(style, LV_STYLE_TRANSFORM_ROTATION, &v)) layout_diff = true;
else if(lv_style_get_prop(style, LV_STYLE_TRANSFORM_SCALE, &v)) layout_diff = true;
if(layout_diff) {
return _LV_STYLE_STATE_CMP_DIFF_LAYOUT;
@@ -616,8 +616,8 @@ _lv_style_state_cmp_t _lv_obj_style_state_compare(lv_obj_t * obj, lv_state_t sta
/*Check for draw pad changes*/
if(lv_style_get_prop(style, LV_STYLE_TRANSFORM_WIDTH, &v)) res = _LV_STYLE_STATE_CMP_DIFF_DRAW_PAD;
else if(lv_style_get_prop(style, LV_STYLE_TRANSFORM_HEIGHT, &v)) res = _LV_STYLE_STATE_CMP_DIFF_DRAW_PAD;
else if(lv_style_get_prop(style, LV_STYLE_TRANSFORM_ANGLE, &v)) res = _LV_STYLE_STATE_CMP_DIFF_DRAW_PAD;
else if(lv_style_get_prop(style, LV_STYLE_TRANSFORM_ZOOM, &v)) res = _LV_STYLE_STATE_CMP_DIFF_DRAW_PAD;
else if(lv_style_get_prop(style, LV_STYLE_TRANSFORM_ROTATION, &v)) res = _LV_STYLE_STATE_CMP_DIFF_DRAW_PAD;
else if(lv_style_get_prop(style, LV_STYLE_TRANSFORM_SCALE, &v)) res = _LV_STYLE_STATE_CMP_DIFF_DRAW_PAD;
else if(lv_style_get_prop(style, LV_STYLE_OUTLINE_OPA, &v)) res = _LV_STYLE_STATE_CMP_DIFF_DRAW_PAD;
else if(lv_style_get_prop(style, LV_STYLE_OUTLINE_PAD, &v)) res = _LV_STYLE_STATE_CMP_DIFF_DRAW_PAD;
else if(lv_style_get_prop(style, LV_STYLE_OUTLINE_WIDTH, &v)) res = _LV_STYLE_STATE_CMP_DIFF_DRAW_PAD;
@@ -1041,8 +1041,8 @@ static void trans_anim_ready_cb(lv_anim_t * a)
static lv_layer_type_t calculate_layer_type(lv_obj_t * obj)
{
if(lv_obj_get_style_transform_angle(obj, 0) != 0) return LV_LAYER_TYPE_TRANSFORM;
if(lv_obj_get_style_transform_zoom(obj, 0) != 256) return LV_LAYER_TYPE_TRANSFORM;
if(lv_obj_get_style_transform_rotation(obj, 0) != 0) return LV_LAYER_TYPE_TRANSFORM;
if(lv_obj_get_style_transform_scale(obj, 0) != 256) return LV_LAYER_TYPE_TRANSFORM;
if(lv_obj_get_style_opa_layered(obj, 0) != LV_OPA_COVER) return LV_LAYER_TYPE_SIMPLE;
if(lv_obj_get_style_blend_mode(obj, 0) != LV_BLEND_MODE_NORMAL) return LV_LAYER_TYPE_SIMPLE;
return LV_LAYER_TYPE_NONE;

4
src/core/lv_obj_style.h
View File

@@ -313,9 +313,9 @@ static inline lv_coord_t lv_obj_get_style_space_bottom(const struct _lv_obj_t *
lv_text_align_t lv_obj_calculate_style_text_align(const struct _lv_obj_t * obj, lv_part_t part, const char * txt);
static inline lv_coord_t lv_obj_get_style_transform_zoom_safe(const struct _lv_obj_t * obj, uint32_t part)
static inline lv_coord_t lv_obj_get_style_transform_scale_safe(const struct _lv_obj_t * obj, uint32_t part)
{
int16_t zoom = lv_obj_get_style_transform_zoom(obj, part);
int16_t zoom = lv_obj_get_style_transform_scale(obj, part);
return zoom != 0 ? zoom : 1;
}

8
src/core/lv_obj_style_gen.c
View File

@@ -114,20 +114,20 @@ void lv_obj_set_style_translate_y(struct _lv_obj_t * obj, lv_coord_t value, lv_s
lv_obj_set_local_style_prop(obj, LV_STYLE_TRANSLATE_Y, v, selector);
}
void lv_obj_set_style_transform_zoom(struct _lv_obj_t * obj, lv_coord_t value, lv_style_selector_t selector)
void lv_obj_set_style_transform_scale(struct _lv_obj_t * obj, lv_coord_t value, lv_style_selector_t selector)
{
lv_style_value_t v = {
.num = (int32_t)value
};
lv_obj_set_local_style_prop(obj, LV_STYLE_TRANSFORM_ZOOM, v, selector);
lv_obj_set_local_style_prop(obj, LV_STYLE_TRANSFORM_SCALE, v, selector);
}
void lv_obj_set_style_transform_angle(struct _lv_obj_t * obj, lv_coord_t value, lv_style_selector_t selector)
void lv_obj_set_style_transform_rotation(struct _lv_obj_t * obj, lv_coord_t value, lv_style_selector_t selector)
{
lv_style_value_t v = {
.num = (int32_t)value
};
lv_obj_set_local_style_prop(obj, LV_STYLE_TRANSFORM_ANGLE, v, selector);
lv_obj_set_local_style_prop(obj, LV_STYLE_TRANSFORM_ROTATION, v, selector);
}
void lv_obj_set_style_transform_pivot_x(struct _lv_obj_t * obj, lv_coord_t value, lv_style_selector_t selector)

14
src/core/lv_obj_style_gen.h
View File

@@ -92,15 +92,15 @@ static inline lv_coord_t lv_obj_get_style_translate_y(const struct _lv_obj_t * o
return (lv_coord_t)v.num;
}
static inline lv_coord_t lv_obj_get_style_transform_zoom(const struct _lv_obj_t * obj, uint32_t part)
static inline lv_coord_t lv_obj_get_style_transform_scale(const struct _lv_obj_t * obj, uint32_t part)
{
lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_TRANSFORM_ZOOM);
lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_TRANSFORM_SCALE);
return (lv_coord_t)v.num;
}
static inline lv_coord_t lv_obj_get_style_transform_angle(const struct _lv_obj_t * obj, uint32_t part)
static inline lv_coord_t lv_obj_get_style_transform_rotation(const struct _lv_obj_t * obj, uint32_t part)
{
lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_TRANSFORM_ANGLE);
lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_TRANSFORM_ROTATION);
return (lv_coord_t)v.num;
}
@@ -718,8 +718,8 @@ void lv_obj_set_style_transform_width(struct _lv_obj_t * obj, lv_coord_t value,
void lv_obj_set_style_transform_height(struct _lv_obj_t * obj, lv_coord_t value, lv_style_selector_t selector);
void lv_obj_set_style_translate_x(struct _lv_obj_t * obj, lv_coord_t value, lv_style_selector_t selector);
void lv_obj_set_style_translate_y(struct _lv_obj_t * obj, lv_coord_t value, lv_style_selector_t selector);
void lv_obj_set_style_transform_zoom(struct _lv_obj_t * obj, lv_coord_t value, lv_style_selector_t selector);
void lv_obj_set_style_transform_angle(struct _lv_obj_t * obj, lv_coord_t value, lv_style_selector_t selector);
void lv_obj_set_style_transform_scale(struct _lv_obj_t * obj, lv_coord_t value, lv_style_selector_t selector);
void lv_obj_set_style_transform_rotation(struct _lv_obj_t * obj, lv_coord_t value, lv_style_selector_t selector);
void lv_obj_set_style_transform_pivot_x(struct _lv_obj_t * obj, lv_coord_t value, lv_style_selector_t selector);
void lv_obj_set_style_transform_pivot_y(struct _lv_obj_t * obj, lv_coord_t value, lv_style_selector_t selector);
void lv_obj_set_style_pad_top(struct _lv_obj_t * obj, lv_coord_t value, lv_style_selector_t selector);
@@ -785,8 +785,6 @@ void lv_obj_set_style_radius(struct _lv_obj_t * obj, lv_coord_t value, lv_style_
void lv_obj_set_style_clip_corner(struct _lv_obj_t * obj, bool value, lv_style_selector_t selector);
void lv_obj_set_style_opa(struct _lv_obj_t * obj, lv_opa_t value, lv_style_selector_t selector);
void lv_obj_set_style_opa_layered(struct _lv_obj_t * obj, lv_opa_t value, lv_style_selector_t selector);
void lv_obj_set_style_color_filter_dsc(struct _lv_obj_t * obj, const lv_color_filter_dsc_t * value,
lv_style_selector_t selector);
void lv_obj_set_style_color_filter_dsc(struct _lv_obj_t * obj, const lv_color_filter_dsc_t * value,
lv_style_selector_t selector);
void lv_obj_set_style_color_filter_opa(struct _lv_obj_t * obj, lv_opa_t value, lv_style_selector_t selector);

24
src/core/lv_obj_tree.c
View File

@@ -11,8 +11,8 @@
#include "lv_obj.h"
#include "../indev/lv_indev.h"
#include "../indev/lv_indev_private.h"
#include "../disp/lv_disp.h"
#include "../disp/lv_disp_private.h"
#include "../display/lv_display.h"
#include "../display/lv_display_private.h"
#include "../misc/lv_anim.h"
#include "../misc/lv_async.h"
#include "../core/lv_global.h"
@@ -60,7 +60,7 @@ void lv_obj_del(lv_obj_t * obj)
lv_obj_scrollbar_invalidate(par);
}
lv_disp_t * disp = NULL;
lv_display_t * disp = NULL;
bool act_scr_del = false;
if(par == NULL) {
disp = lv_obj_get_disp(obj);
@@ -282,7 +282,7 @@ lv_obj_t * lv_obj_get_screen(const lv_obj_t * obj)
return (lv_obj_t *)act_par;
}
lv_disp_t * lv_obj_get_disp(const lv_obj_t * obj)
lv_display_t * lv_obj_get_disp(const lv_obj_t * obj)
{
LV_ASSERT_OBJ(obj, MY_CLASS);
@@ -291,7 +291,7 @@ lv_disp_t * lv_obj_get_disp(const lv_obj_t * obj)
if(obj->parent == NULL) scr = obj; /*`obj` is a screen*/
else scr = lv_obj_get_screen(obj); /*get the screen of `obj`*/
lv_disp_t * d;
lv_display_t * d;
lv_ll_t * disp_head = disp_ll_p;
_LV_LL_READ(disp_head, d) {
uint32_t i;
@@ -378,8 +378,8 @@ static void obj_del_core(lv_obj_t * obj)
obj->is_deleting = true;
/*Let the user free the resources used in `LV_EVENT_DELETE`*/
lv_res_t res = lv_obj_send_event(obj, LV_EVENT_DELETE, NULL);
if(res == LV_RES_INV) {
lv_result_t res = lv_obj_send_event(obj, LV_EVENT_DELETE, NULL);
if(res == LV_RESULT_INVALID) {
obj->is_deleting = false;
return;
}
@@ -416,8 +416,8 @@ static void obj_del_core(lv_obj_t * obj)
}
/*Delete all pending async del-s*/
lv_res_t async_cancel_res = LV_RES_OK;
while(async_cancel_res == LV_RES_OK) {
lv_result_t async_cancel_res = LV_RESULT_OK;
while(async_cancel_res == LV_RESULT_OK) {
async_cancel_res = lv_async_call_cancel(lv_obj_del_async_cb, obj);
}
@@ -426,7 +426,7 @@ static void obj_del_core(lv_obj_t * obj)
/*Remove the screen for the screen list*/
if(obj->parent == NULL) {
lv_disp_t * disp = lv_obj_get_disp(obj);
lv_display_t * disp = lv_obj_get_disp(obj);
uint32_t i;
/*Find the screen in the list*/
for(i = 0; i < disp->screen_cnt; i++) {
@@ -462,13 +462,13 @@ static lv_obj_tree_walk_res_t walk_core(lv_obj_t * obj, lv_obj_tree_walk_cb_t cb
lv_obj_tree_walk_res_t res = LV_OBJ_TREE_WALK_NEXT;
if(obj == NULL) {
lv_disp_t * disp = lv_disp_get_next(NULL);
lv_display_t * disp = lv_display_get_next(NULL);
while(disp) {
uint32_t i;
for(i = 0; i < disp->screen_cnt; i++) {
walk_core(disp->screens[i], cb, user_data);
}
disp = lv_disp_get_next(disp);
disp = lv_display_get_next(disp);
}
return LV_OBJ_TREE_WALK_END; /*The value doesn't matter as it wasn't called recursively*/
}

6
src/core/lv_obj_tree.h
View File

@@ -16,7 +16,7 @@ extern "C" {
#include <stddef.h>
#include <stdbool.h>
#include "../misc/lv_anim.h"
#include "../disp/lv_disp.h"
#include "../display/lv_display.h"
/*********************
* DEFINES
@@ -28,7 +28,7 @@ extern "C" {
**********************/
struct _lv_obj_t;
struct _lv_disp_t;
struct _lv_display_t;
struct _lv_obj_class_t;
typedef enum {
@@ -118,7 +118,7 @@ struct _lv_obj_t * lv_obj_get_screen(const struct _lv_obj_t * obj);
* @param obj pointer to an object
* @return pointer to the object's display
*/
struct _lv_disp_t * lv_obj_get_disp(const struct _lv_obj_t * obj);
struct _lv_display_t * lv_obj_get_disp(const struct _lv_obj_t * obj);
/**
* Get the parent of an object

137
src/core/lv_refr.c
View File

@@ -8,8 +8,8 @@
*********************/
#include <stddef.h>
#include "lv_refr.h"
#include "../disp/lv_disp.h"
#include "../disp/lv_disp_private.h"
#include "../display/lv_display.h"
#include "../display/lv_display_private.h"
#include "../tick/lv_tick.h"
#include "../misc/lv_timer.h"
#include "../misc/lv_math.h"
@@ -40,9 +40,9 @@ static void refr_area_part(lv_layer_t * layer);
static lv_obj_t * lv_refr_get_top_obj(const lv_area_t * area_p, lv_obj_t * obj);
static void refr_obj_and_children(lv_layer_t * layer, lv_obj_t * top_obj);
static void refr_obj(lv_layer_t * layer, lv_obj_t * obj);
static uint32_t get_max_row(lv_disp_t * disp, lv_coord_t area_w, lv_coord_t area_h);
static void draw_buf_flush(lv_disp_t * disp);
static void call_flush_cb(lv_disp_t * disp, const lv_area_t * area, uint8_t * px_map);
static uint32_t get_max_row(lv_display_t * disp, lv_coord_t area_w, lv_coord_t area_h);
static void draw_buf_flush(lv_display_t * disp);
static void call_flush_cb(lv_display_t * disp, const lv_area_t * area, uint8_t * px_map);
/**********************
* STATIC VARIABLES
@@ -68,19 +68,19 @@ void _lv_refr_init(void)
{
}
void lv_refr_now(lv_disp_t * disp)
void lv_refr_now(lv_display_t * disp)
{
lv_anim_refr_now();
if(disp) {
if(disp->refr_timer) _lv_disp_refr_timer(disp->refr_timer);
if(disp->refr_timer) _lv_display_refr_timer(disp->refr_timer);
}
else {
lv_disp_t * d;
d = lv_disp_get_next(NULL);
lv_display_t * d;
d = lv_display_get_next(NULL);
while(d) {
if(d->refr_timer) _lv_disp_refr_timer(d->refr_timer);
d = lv_disp_get_next(d);
if(d->refr_timer) _lv_display_refr_timer(d->refr_timer);
d = lv_display_get_next(d);
}
}
}
@@ -248,11 +248,11 @@ void lv_obj_redraw(lv_layer_t * layer, lv_obj_t * obj)
* @param area_p pointer to area which should be invalidated (NULL: delete the invalidated areas)
* only one display)
*/
void _lv_inv_area(lv_disp_t * disp, const lv_area_t * area_p)
void _lv_inv_area(lv_display_t * disp, const lv_area_t * area_p)
{
if(!disp) disp = lv_disp_get_default();
if(!disp) disp = lv_display_get_default();
if(!disp) return;
if(!lv_disp_is_invalidation_enabled(disp)) return;
if(!lv_display_is_invalidation_enabled(disp)) return;
LV_ASSERT_MSG(!disp->rendering_in_progress, "Invalidate area is not allowed during rendering.");
@@ -265,8 +265,8 @@ void _lv_inv_area(lv_disp_t * disp, const lv_area_t * area_p)
lv_area_t scr_area;
scr_area.x1 = 0;
scr_area.y1 = 0;
scr_area.x2 = lv_disp_get_hor_res(disp) - 1;
scr_area.y2 = lv_disp_get_ver_res(disp) - 1;
scr_area.x2 = lv_display_get_horizontal_resolution(disp) - 1;
scr_area.y2 = lv_display_get_vertical_resolution(disp) - 1;
lv_area_t com_area;
bool suc;
@@ -275,15 +275,15 @@ void _lv_inv_area(lv_disp_t * disp, const lv_area_t * area_p)
if(suc == false) return; /*Out of the screen*/
/*If there were at least 1 invalid area in full refresh mode, redraw the whole screen*/
if(disp->render_mode == LV_DISP_RENDER_MODE_FULL) {
if(disp->render_mode == LV_DISPLAY_RENDER_MODE_FULL) {
disp->inv_areas[0] = scr_area;
disp->inv_p = 1;
lv_disp_send_event(disp, LV_EVENT_REFR_REQUEST, NULL);
lv_display_send_event(disp, LV_EVENT_REFR_REQUEST, NULL);
return;
}
lv_res_t res = lv_disp_send_event(disp, LV_EVENT_INVALIDATE_AREA, &com_area);
if(res != LV_RES_OK) return;
lv_result_t res = lv_display_send_event(disp, LV_EVENT_INVALIDATE_AREA, &com_area);
if(res != LV_RESULT_OK) return;
/*Save only if this area is not in one of the saved areas*/
uint16_t i;
@@ -300,14 +300,14 @@ void _lv_inv_area(lv_disp_t * disp, const lv_area_t * area_p)
lv_area_copy(&disp->inv_areas[disp->inv_p], tmp_area_p);
disp->inv_p++;
lv_disp_send_event(disp, LV_EVENT_REFR_REQUEST, NULL);
lv_display_send_event(disp, LV_EVENT_REFR_REQUEST, NULL);
}
/**
* Get the display which is being refreshed
* @return the display being refreshed
*/
lv_disp_t * _lv_refr_get_disp_refreshing(void)
lv_display_t * _lv_refr_get_disp_refreshing(void)
{
return disp_refr;
}
@@ -316,7 +316,7 @@ lv_disp_t * _lv_refr_get_disp_refreshing(void)
* Called periodically to handle the refreshing
* @param tmr pointer to the timer itself
*/
void _lv_disp_refr_timer(lv_timer_t * tmr)
void _lv_display_refr_timer(lv_timer_t * tmr)
{
LV_PROFILER_BEGIN;
REFR_TRACE("begin");
@@ -332,7 +332,7 @@ void _lv_disp_refr_timer(lv_timer_t * tmr)
#endif
}
else {
disp_refr = lv_disp_get_default();
disp_refr = lv_display_get_default();
}
if(disp_refr == NULL) {
@@ -349,7 +349,7 @@ void _lv_disp_refr_timer(lv_timer_t * tmr)
return;
}
lv_disp_send_event(disp_refr, LV_EVENT_REFR_START, NULL);
lv_display_send_event(disp_refr, LV_EVENT_REFR_START, NULL);
/*Refresh the screen's layout if required*/
lv_obj_update_layout(disp_refr->act_scr);
@@ -374,9 +374,10 @@ void _lv_disp_refr_timer(lv_timer_t * tmr)
/*If refresh happened ...*/
/*Call monitor cb if present*/
lv_disp_send_event(disp_refr, LV_EVENT_RENDER_READY, NULL);
lv_display_send_event(disp_refr, LV_EVENT_RENDER_READY, NULL);
if(!lv_disp_is_double_buffered(disp_refr) || disp_refr->render_mode != LV_DISP_RENDER_MODE_DIRECT) goto refr_clean_up;
if(!lv_display_is_double_buffered(disp_refr) ||
disp_refr->render_mode != LV_DISPLAY_RENDER_MODE_DIRECT) goto refr_clean_up;
/*With double buffered direct mode synchronize the rendered areas to the other buffer*/
/*We need to wait for ready here to not mess up the active screen*/
@@ -389,8 +390,8 @@ void _lv_disp_refr_timer(lv_timer_t * tmr)
? disp_refr->buf_2
: disp_refr->buf_1;
lv_coord_t stride = lv_draw_buf_width_to_stride(lv_disp_get_hor_res(disp_refr),
lv_disp_get_color_format(disp_refr));
lv_coord_t stride = lv_draw_buf_width_to_stride(lv_display_get_horizontal_resolution(disp_refr),
lv_display_get_color_format(disp_refr));
uint32_t i;
for(i = 0; i < disp_refr->inv_p; i++) {
if(disp_refr->inv_area_joined[i]) continue;
@@ -413,7 +414,7 @@ refr_finish:
_lv_draw_sw_mask_cleanup();
#endif
lv_disp_send_event(disp_refr, LV_EVENT_REFR_FINISH, NULL);
lv_display_send_event(disp_refr, LV_EVENT_REFR_FINISH, NULL);
REFR_TRACE("finished");
LV_PROFILER_END;
@@ -479,7 +480,7 @@ static void refr_invalid_areas(void)
}
/*Notify the display driven rendering has started*/
lv_disp_send_event(disp_refr, LV_EVENT_RENDER_START, NULL);
lv_display_send_event(disp_refr, LV_EVENT_RENDER_START, NULL);
disp_refr->last_area = 0;
disp_refr->last_part = 0;
@@ -510,21 +511,21 @@ static void refr_area(const lv_area_t * area_p)
/*With full refresh just redraw directly into the buffer*/
/*In direct mode draw directly on the absolute coordinates of the buffer*/
if(disp_refr->render_mode != LV_DISP_RENDER_MODE_PARTIAL) {
layer->draw_buf.width = lv_disp_get_hor_res(disp_refr);
layer->draw_buf.height = lv_disp_get_ver_res(disp_refr);
if(disp_refr->render_mode != LV_DISPLAY_RENDER_MODE_PARTIAL) {
layer->draw_buf.width = lv_display_get_horizontal_resolution(disp_refr);
layer->draw_buf.height = lv_display_get_vertical_resolution(disp_refr);
layer->draw_buf_ofs.x = 0;
layer->draw_buf_ofs.y = 0;
lv_area_t disp_area;
lv_area_set(&disp_area, 0, 0, lv_disp_get_hor_res(disp_refr) - 1,
lv_disp_get_ver_res(disp_refr) - 1);
lv_area_set(&disp_area, 0, 0, lv_display_get_horizontal_resolution(disp_refr) - 1,
lv_display_get_vertical_resolution(disp_refr) - 1);
if(disp_refr->render_mode == LV_DISP_RENDER_MODE_FULL) {
if(disp_refr->render_mode == LV_DISPLAY_RENDER_MODE_FULL) {
disp_refr->last_part = 1;
layer->clip_area = disp_area;
refr_area_part(layer);
}
else if(disp_refr->render_mode == LV_DISP_RENDER_MODE_DIRECT) {
else if(disp_refr->render_mode == LV_DISPLAY_RENDER_MODE_DIRECT) {
disp_refr->last_part = disp_refr->last_area;
layer->clip_area = *area_p;
refr_area_part(layer);
@@ -536,8 +537,8 @@ static void refr_area(const lv_area_t * area_p)
/*Calculate the max row num*/
lv_coord_t w = lv_area_get_width(area_p);
lv_coord_t h = lv_area_get_height(area_p);
lv_coord_t y2 = area_p->y2 >= lv_disp_get_ver_res(disp_refr) ?
lv_disp_get_ver_res(disp_refr) - 1 : area_p->y2;
lv_coord_t y2 = area_p->y2 >= lv_display_get_vertical_resolution(disp_refr) ?
lv_display_get_vertical_resolution(disp_refr) - 1 : area_p->y2;
int32_t max_row = get_max_row(disp_refr, w, h);
@@ -586,7 +587,7 @@ static void refr_area_part(lv_layer_t * layer)
/* In single buffered mode wait here until the buffer is freed.
* Else we would draw into the buffer while it's still being transferred to the display*/
if(!lv_disp_is_double_buffered(disp_refr)) {
if(!lv_display_is_double_buffered(disp_refr)) {
while(disp_refr->flushing);
}
/*If the screen is transparent initialize it when the flushing is ready*/
@@ -598,14 +599,14 @@ static void refr_area_part(lv_layer_t * layer)
lv_obj_t * top_prev_scr = NULL;
/*Get the most top object which is not covered by others*/
top_act_scr = lv_refr_get_top_obj(&layer->clip_area, lv_disp_get_scr_act(disp_refr));
top_act_scr = lv_refr_get_top_obj(&layer->clip_area, lv_display_get_scr_act(disp_refr));
if(disp_refr->prev_scr) {
top_prev_scr = lv_refr_get_top_obj(&layer->clip_area, disp_refr->prev_scr);
}
/*Draw a bottom layer background if there is no top object*/
if(top_act_scr == NULL && top_prev_scr == NULL) {
refr_obj_and_children(layer, lv_disp_get_layer_bottom(disp_refr));
refr_obj_and_children(layer, lv_display_get_layer_bottom(disp_refr));
}
if(disp_refr->draw_prev_over_act) {
@@ -630,8 +631,8 @@ static void refr_area_part(lv_layer_t * layer)
}
/*Also refresh top and sys layer unconditionally*/
refr_obj_and_children(layer, lv_disp_get_layer_top(disp_refr));
refr_obj_and_children(layer, lv_disp_get_layer_sys(disp_refr));
refr_obj_and_children(layer, lv_display_get_layer_top(disp_refr));
refr_obj_and_children(layer, lv_display_get_layer_sys(disp_refr));
draw_buf_flush(disp_refr);
}
@@ -687,7 +688,7 @@ static void refr_obj_and_children(lv_layer_t * layer, lv_obj_t * top_obj)
/*Normally always will be a top_obj (at least the screen)
*but in special cases (e.g. if the screen has alpha) it won't.
*In this case use the screen directly*/
if(top_obj == NULL) top_obj = lv_disp_get_scr_act(disp_refr);
if(top_obj == NULL) top_obj = lv_display_get_scr_act(disp_refr);
if(top_obj == NULL) return; /*Shouldn't happen*/
/*Refresh the top object and its children*/
@@ -729,8 +730,8 @@ static void refr_obj_and_children(lv_layer_t * layer, lv_obj_t * top_obj)
}
static lv_res_t layer_get_area(lv_layer_t * layer, lv_obj_t * obj, lv_layer_type_t layer_type,
lv_area_t * layer_area_out)
static lv_result_t layer_get_area(lv_layer_t * layer, lv_obj_t * obj, lv_layer_type_t layer_type,
lv_area_t * layer_area_out)
{
lv_coord_t ext_draw_size = _lv_obj_get_ext_draw_size(obj);
lv_area_t obj_coords_ext;
@@ -744,7 +745,7 @@ static lv_res_t layer_get_area(lv_layer_t * layer, lv_obj_t * obj, lv_layer_type
lv_area_t tranf_coords = obj_coords_ext;
lv_obj_get_transformed_area(obj, &tranf_coords, false, false);
if(!_lv_area_intersect(&clip_coords_for_obj, &layer->clip_area, &tranf_coords)) {
return LV_RES_INV;
return LV_RESULT_INVALID;
}
/*Transform back (inverse) the transformed area.
@@ -753,7 +754,7 @@ static lv_res_t layer_get_area(lv_layer_t * layer, lv_obj_t * obj, lv_layer_type
lv_area_t inverse_clip_coords_for_obj = clip_coords_for_obj;
lv_obj_get_transformed_area(obj, &inverse_clip_coords_for_obj, false, true);
if(!_lv_area_intersect(&inverse_clip_coords_for_obj, &inverse_clip_coords_for_obj, &obj_coords_ext)) {
return LV_RES_INV;
return LV_RESULT_INVALID;
}
*layer_area_out = inverse_clip_coords_for_obj;
@@ -762,16 +763,16 @@ static lv_res_t layer_get_area(lv_layer_t * layer, lv_obj_t * obj, lv_layer_type
else if(layer_type == LV_LAYER_TYPE_SIMPLE) {
lv_area_t clip_coords_for_obj;
if(!_lv_area_intersect(&clip_coords_for_obj, &layer->clip_area, &obj_coords_ext)) {
return LV_RES_INV;
return LV_RESULT_INVALID;
}
*layer_area_out = clip_coords_for_obj;
}
else {
LV_LOG_WARN("Unhandled layer type");
return LV_RES_INV;
return LV_RESULT_INVALID;
}
return LV_RES_OK;
return LV_RESULT_OK;
}
static bool alpha_test_area_on_obj(lv_obj_t * obj, const lv_area_t * area)
@@ -802,8 +803,8 @@ void refr_obj(lv_layer_t * layer, lv_obj_t * obj)
if(opa < LV_OPA_MIN) return;
lv_area_t layer_area_full;
lv_res_t res = layer_get_area(layer, obj, layer_type, &layer_area_full);
if(res != LV_RES_OK) return;
lv_result_t res = layer_get_area(layer, obj, layer_type, &layer_area_full);
if(res != LV_RESULT_OK) return;
/*Simple layers can be subdivied into smaller layers*/
uint32_t max_rgb_row_height = lv_area_get_height(&layer_area_full);
@@ -842,10 +843,10 @@ void refr_obj(lv_layer_t * layer, lv_obj_t * obj)
layer_draw_dsc.pivot.y = obj->coords.y1 + lv_obj_get_style_transform_pivot_y(obj, 0) - new_layer->draw_buf_ofs.y;
layer_draw_dsc.opa = opa;
layer_draw_dsc.angle = lv_obj_get_style_transform_angle(obj, 0);
while(layer_draw_dsc.angle > 3600) layer_draw_dsc.angle -= 3600;
while(layer_draw_dsc.angle < 0) layer_draw_dsc.angle += 3600;
layer_draw_dsc.zoom = lv_obj_get_style_transform_zoom(obj, 0);
layer_draw_dsc.rotation = lv_obj_get_style_transform_rotation(obj, 0);
while(layer_draw_dsc.rotation > 3600) layer_draw_dsc.rotation -= 3600;
while(layer_draw_dsc.rotation < 0) layer_draw_dsc.rotation += 3600;
layer_draw_dsc.zoom = lv_obj_get_style_transform_scale(obj, 0);
layer_draw_dsc.blend_mode = lv_obj_get_style_blend_mode(obj, 0);
layer_draw_dsc.antialias = disp_refr->antialiasing;
layer_draw_dsc.src = new_layer;
@@ -858,7 +859,7 @@ void refr_obj(lv_layer_t * layer, lv_obj_t * obj)
}
static uint32_t get_max_row(lv_disp_t * disp, lv_coord_t area_w, lv_coord_t area_h)
static uint32_t get_max_row(lv_display_t * disp, lv_coord_t area_w, lv_coord_t area_h)
{
bool has_alpha = lv_color_format_has_alpha(disp->color_format);
uint32_t px_size_disp = lv_color_format_get_size(disp->color_format);
@@ -876,7 +877,7 @@ static uint32_t get_max_row(lv_disp_t * disp, lv_coord_t area_w, lv_coord_t area
lv_coord_t h_tmp = max_row;
do {
tmp.y2 = h_tmp - 1;
lv_disp_send_event(disp_refr, LV_EVENT_INVALIDATE_AREA, &tmp);
lv_display_send_event(disp_refr, LV_EVENT_INVALIDATE_AREA, &tmp);
/*If this height fits into `max_row` then fine*/
if(lv_area_get_height(&tmp) <= max_row) break;
@@ -900,7 +901,7 @@ static uint32_t get_max_row(lv_disp_t * disp, lv_coord_t area_w, lv_coord_t area
/**
* Flush the content of the draw buffer
*/
static void draw_buf_flush(lv_disp_t * disp)
static void draw_buf_flush(lv_display_t * disp)
{
/*Flush the rendered content to the display*/
lv_layer_t * layer = disp->layer_head;
@@ -914,7 +915,7 @@ static void draw_buf_flush(lv_disp_t * disp)
* and driver is ready to receive the new buffer.
* If we need to wait here it means that the content of one buffer is being sent to display
* and other buffer already contains the new rendered image. */
if(lv_disp_is_double_buffered(disp)) {
if(lv_display_is_double_buffered(disp)) {
while(disp->flushing);
}
@@ -927,7 +928,7 @@ static void draw_buf_flush(lv_disp_t * disp)
if(disp->flush_cb) {
/*Rotate the buffer to the display's native orientation if necessary*/
if(disp->rotation != LV_DISP_ROTATION_0 && disp->sw_rotate) {
if(disp->rotation != LV_DISPLAY_ROTATION_0 && disp->sw_rotate) {
LV_LOG_WARN("SW rotation is not supported now");
call_flush_cb(disp, &disp->refreshed_area, layer->draw_buf.buf);
}
@@ -936,7 +937,7 @@ static void draw_buf_flush(lv_disp_t * disp)
}
}
/*If there are 2 buffers swap them. With direct mode swap only on the last area*/
if(lv_disp_is_double_buffered(disp) && (disp->render_mode != LV_DISP_RENDER_MODE_DIRECT || flushing_last)) {
if(lv_display_is_double_buffered(disp) && (disp->render_mode != LV_DISPLAY_RENDER_MODE_DIRECT || flushing_last)) {
if(disp->buf_act == disp->buf_1) {
disp->buf_act = disp->buf_2;
}
@@ -946,7 +947,7 @@ static void draw_buf_flush(lv_disp_t * disp)
}
}
static void call_flush_cb(lv_disp_t * disp, const lv_area_t * area, uint8_t * px_map)
static void call_flush_cb(lv_display_t * disp, const lv_area_t * area, uint8_t * px_map)
{
LV_PROFILER_BEGIN;
REFR_TRACE("Calling flush_cb on (%d;%d)(%d;%d) area with %p image pointer",
@@ -962,9 +963,9 @@ static void call_flush_cb(lv_disp_t * disp, const lv_area_t * area, uint8_t * px
// if(disp->layer_head->buffer_convert) disp->layer_head->buffer_convert(disp->layer_head);
lv_disp_send_event(disp, LV_EVENT_FLUSH_START, &offset_area);
lv_display_send_event(disp, LV_EVENT_FLUSH_START, &offset_area);
disp->flush_cb(disp, &offset_area, px_map);
lv_disp_send_event(disp, LV_EVENT_FLUSH_FINISH, &offset_area);
lv_display_send_event(disp, LV_EVENT_FLUSH_FINISH, &offset_area);
LV_PROFILER_END;
}

10
src/core/lv_refr.h
View File

@@ -14,7 +14,7 @@ extern "C" {
* INCLUDES
*********************/
#include "lv_obj.h"
#include "../disp/lv_disp.h"
#include "../display/lv_display.h"
#include <stdbool.h>
/*********************
@@ -53,7 +53,7 @@ void _lv_refr_init(void);
* (e.g. progress bar) this function can be called when the screen should be updated.
* @param disp pointer to display to refresh. NULL to refresh all displays.
*/
void lv_refr_now(lv_disp_t * disp);
void lv_refr_now(lv_display_t * disp);
/**
* Redrawn on object an all its children using the passed draw context
@@ -68,19 +68,19 @@ void lv_obj_redraw(lv_layer_t * layer, lv_obj_t * obj);
* @param disp pointer to display where the area should be invalidated (NULL can be used if there is
* only one display)
*/
void _lv_inv_area(lv_disp_t * disp, const lv_area_t * area_p);
void _lv_inv_area(lv_display_t * disp, const lv_area_t * area_p);
/**
* Get the display which is being refreshed
* @return the display being refreshed
*/
lv_disp_t * _lv_refr_get_disp_refreshing(void);
lv_display_t * _lv_refr_get_disp_refreshing(void);
/**
* Called periodically to handle the refreshing
* @param timer pointer to the timer itself
*/
void _lv_disp_refr_timer(lv_timer_t * timer);
void _lv_display_refr_timer(lv_timer_t * timer);
/**********************
* STATIC FUNCTIONS

28
src/dev/disp/drm/lv_linux_drm.c → src/dev/display/drm/lv_linux_drm.c
View File

@@ -99,7 +99,7 @@ static int drm_setup(drm_dev_t * drm_dev, const char * device_path, int64_t conn
static int drm_allocate_dumb(drm_dev_t * drm_dev, drm_buffer_t * buf);
static int drm_setup_buffers(drm_dev_t * drm_dev);
static void drm_wait_vsync(drm_dev_t * drm_dev);
static void drm_flush(lv_disp_t * disp, const lv_area_t * area, lv_color_t * color_p);
static void drm_flush(lv_display_t * disp, const lv_area_t * area, lv_color_t * color_p);
/**********************
* STATIC VARIABLES
@@ -121,28 +121,28 @@ static void drm_flush(lv_disp_t * disp, const lv_area_t * area, lv_color_t * col
* GLOBAL FUNCTIONS
**********************/
lv_disp_t * lv_linux_drm_create(void)
lv_display_t * lv_linux_drm_create(void)
{
drm_dev_t * drm_dev = lv_malloc(sizeof(drm_dev_t));
LV_ASSERT_MALLOC(drm_dev);
if(drm_dev == NULL) return NULL;
lv_memzero(drm_dev, sizeof(drm_dev_t));
lv_disp_t * disp = lv_disp_create(800, 480);
lv_display_t * disp = lv_display_create(800, 480);
if(disp == NULL) {
lv_free(drm_dev);
return NULL;
}
drm_dev->fd = -1;
lv_disp_set_driver_data(disp, drm_dev);
lv_disp_set_flush_cb(disp, drm_flush);
lv_display_set_driver_data(disp, drm_dev);
lv_display_set_flush_cb(disp, drm_flush);
return disp;
}
void lv_linux_drm_set_file(lv_disp_t * disp, const char * file, int64_t connector_id)
void lv_linux_drm_set_file(lv_display_t * disp, const char * file, int64_t connector_id)
{
drm_dev_t * drm_dev = lv_disp_get_driver_data(disp);
drm_dev_t * drm_dev = lv_display_get_driver_data(disp);
int ret;
ret = drm_setup(drm_dev, file, connector_id, DRM_FOURCC);
@@ -168,14 +168,14 @@ void lv_linux_drm_set_file(lv_disp_t * disp, const char * file, int64_t connecto
uint32_t draw_buf_size = hor_res * ver_res / 4; /*1/4 screen sized buffer has the same performance */
lv_color_t * draw_buf = malloc(draw_buf_size * sizeof(lv_color_t));
lv_disp_set_draw_buffers(disp, draw_buf, NULL, draw_buf_size, LV_DISP_RENDER_MODE_PARTIAL);
lv_disp_set_res(disp, hor_res, ver_res);
lv_display_set_draw_buffers(disp, draw_buf, NULL, draw_buf_size, LV_DISPLAY_RENDER_MODE_PARTIAL);
lv_display_set_res(disp, hor_res, ver_res);
if(width) {
lv_disp_set_dpi(disp, DIV_ROUND_UP(hor_res * 25400, width * 1000));
lv_display_set_dpi(disp, DIV_ROUND_UP(hor_res * 25400, width * 1000));
}
LV_LOG_INFO("Resolution is set to %dx%d at %ddpi", hor_res, ver_res, lv_disp_get_dpi(disp));
LV_LOG_INFO("Resolution is set to %dx%d at %ddpi", hor_res, ver_res, lv_display_get_dpi(disp));
}
/**********************
@@ -827,9 +827,9 @@ static void drm_wait_vsync(drm_dev_t * drm_dev)
drm_dev->req = NULL;
}
static void drm_flush(lv_disp_t * disp, const lv_area_t * area, lv_color_t * color_p)
static void drm_flush(lv_display_t * disp, const lv_area_t * area, lv_color_t * color_p)
{
drm_dev_t * drm_dev = lv_disp_get_driver_data(disp);
drm_dev_t * drm_dev = lv_display_get_driver_data(disp);
drm_buffer_t * fbuf = drm_dev->cur_bufs[1];
uint32_t w = (area->x2 - area->x1 + 1);
uint32_t h = (area->y2 - area->y1 + 1);
@@ -865,7 +865,7 @@ static void drm_flush(lv_disp_t * disp, const lv_area_t * area, lv_color_t * col
drm_dev->cur_bufs[0] = fbuf;
lv_disp_flush_ready(disp);
lv_display_flush_ready(disp);
}
#endif /*LV_USE_LINUX_DRM*/

6
src/dev/disp/drm/lv_linux_drm.h → src/dev/display/drm/lv_linux_drm.h
View File

@@ -14,7 +14,7 @@ extern "C" {
* INCLUDES
*********************/
#include "../../../disp/lv_disp.h"
#include "../../../display/lv_display.h"
#if LV_USE_LINUX_DRM
@@ -29,9 +29,9 @@ extern "C" {
/**********************
* GLOBAL PROTOTYPES
**********************/
lv_disp_t * lv_linux_drm_create(void);
lv_display_t * lv_linux_drm_create(void);
void lv_linux_drm_set_file(lv_disp_t * disp, const char * file, int64_t connector_id);
void lv_linux_drm_set_file(lv_display_t * disp, const char * file, int64_t connector_id);
/**********************
* MACROS

34
src/dev/disp/fb/lv_linux_fbdev.c → src/dev/display/fb/lv_linux_fbdev.c
View File

@@ -69,7 +69,7 @@ typedef struct {
* STATIC PROTOTYPES
**********************/
static void flush_cb(lv_disp_t * disp, const lv_area_t * area, uint8_t * color_p);
static void flush_cb(lv_display_t * disp, const lv_area_t * area, uint8_t * color_p);
/**********************
* STATIC VARIABLES
@@ -91,33 +91,33 @@ static void flush_cb(lv_disp_t * disp, const lv_area_t * area, uint8_t * color_p
* GLOBAL FUNCTIONS
**********************/
lv_disp_t * lv_linux_fbdev_create(void)
lv_display_t * lv_linux_fbdev_create(void)
{
lv_linux_fb_t * dsc = lv_malloc(sizeof(lv_linux_fb_t));
LV_ASSERT_MALLOC(dsc);
if(dsc == NULL) return NULL;
lv_memzero(dsc, sizeof(lv_linux_fb_t));
lv_disp_t * disp = lv_disp_create(800, 480);
lv_display_t * disp = lv_display_create(800, 480);
if(disp == NULL) {
lv_free(dsc);
return NULL;
}
dsc->fbfd = -1;
lv_disp_set_driver_data(disp, dsc);
lv_disp_set_flush_cb(disp, flush_cb);
lv_display_set_driver_data(disp, dsc);
lv_display_set_flush_cb(disp, flush_cb);
return disp;
}
void lv_linux_fbdev_set_file(lv_disp_t * disp, const char * file)
void lv_linux_fbdev_set_file(lv_display_t * disp, const char * file)
{
char * devname = lv_malloc(lv_strlen(file) + 1);
LV_ASSERT_MALLOC(devname);
if(devname == NULL) return;
lv_strcpy(devname, file);
lv_linux_fb_t * dsc = lv_disp_get_driver_data(disp);
lv_linux_fb_t * dsc = lv_display_get_driver_data(disp);
dsc->devname = devname;
if(dsc->fbfd > 0) close(dsc->fbfd);
@@ -209,39 +209,39 @@ void lv_linux_fbdev_set_file(lv_disp_t * disp, const char * file)
if(LV_LINUX_FBDEV_BUFFER_COUNT == 2) {
draw_buf_2 = lv_malloc(draw_buf_size);
}
lv_disp_set_draw_buffers(disp, draw_buf, draw_buf_2, draw_buf_size, LV_LINUX_FBDEV_RENDER_MODE);
lv_disp_set_res(disp, hor_res, ver_res);
lv_display_set_draw_buffers(disp, draw_buf, draw_buf_2, draw_buf_size, LV_LINUX_FBDEV_RENDER_MODE);
lv_display_set_resolution(disp, hor_res, ver_res);
if(width) {
lv_disp_set_dpi(disp, DIV_ROUND_UP(hor_res * 254, width * 10));
lv_display_set_dpi(disp, DIV_ROUND_UP(hor_res * 254, width * 10));
}
LV_LOG_INFO("Resolution is set to %dx%d at %ddpi", hor_res, ver_res, lv_disp_get_dpi(disp));
LV_LOG_INFO("Resolution is set to %dx%d at %ddpi", hor_res, ver_res, lv_display_get_dpi(disp));
}
/**********************
* STATIC FUNCTIONS
**********************/
static void flush_cb(lv_disp_t * disp, const lv_area_t * area, uint8_t * color_p)
static void flush_cb(lv_display_t * disp, const lv_area_t * area, uint8_t * color_p)
{
lv_linux_fb_t * dsc = lv_disp_get_driver_data(disp);
lv_linux_fb_t * dsc = lv_display_get_driver_data(disp);
if(dsc->fbp == NULL ||
area->x2 < 0 || area->y2 < 0 ||
area->x1 > (int32_t)dsc->vinfo.xres - 1 || area->y1 > (int32_t)dsc->vinfo.yres - 1) {
lv_disp_flush_ready(disp);
lv_display_flush_ready(disp);
return;
}
lv_coord_t w = lv_area_get_width(area);
uint32_t px_size = lv_color_format_get_size(lv_disp_get_color_format(disp));
uint32_t px_size = lv_color_format_get_size(lv_display_get_color_format(disp));
uint32_t color_pos = (area->x1 + dsc->vinfo.xoffset) * px_size + area->y1 * dsc->finfo.line_length;
uint32_t fb_pos = color_pos + dsc->vinfo.yoffset * dsc->finfo.line_length;
uint8_t * fbp = (uint8_t *)dsc->fbp;
int32_t y;
if(LV_LINUX_FBDEV_RENDER_MODE == LV_DISP_RENDER_MODE_DIRECT) {
if(LV_LINUX_FBDEV_RENDER_MODE == LV_DISPLAY_RENDER_MODE_DIRECT) {
for(y = area->y1; y <= area->y2; y++) {
lv_memcpy(&fbp[fb_pos], &color_p[color_pos], w * px_size);
fb_pos += dsc->finfo.line_length;
@@ -266,7 +266,7 @@ static void flush_cb(lv_disp_t * disp, const lv_area_t * area, uint8_t * color_p
ioctl(dsc->fbfd, FBIO_UPDATE, (unsigned long)((uintptr_t)&fb_area));
#endif
lv_disp_flush_ready(disp);
lv_display_flush_ready(disp);
}
#endif /*LV_USE_LINUX_FBDEV*/

6
src/dev/disp/fb/lv_linux_fbdev.h → src/dev/display/fb/lv_linux_fbdev.h
View File

@@ -14,7 +14,7 @@ extern "C" {
* INCLUDES
*********************/
#include "../../../disp/lv_disp.h"
#include "../../../display/lv_display.h"
#if LV_USE_LINUX_FBDEV
@@ -29,9 +29,9 @@ extern "C" {
/**********************
* GLOBAL PROTOTYPES
**********************/
lv_disp_t * lv_linux_fbdev_create(void);
lv_display_t * lv_linux_fbdev_create(void);
void lv_linux_fbdev_set_file(lv_disp_t * disp, const char * file);
void lv_linux_fbdev_set_file(lv_display_t * disp, const char * file);
/**********************
* MACROS

28
src/dev/disp/lcd/lv_nuttx_lcd.c → src/dev/display/lcd/lv_nuttx_lcd.c
View File

@@ -32,7 +32,7 @@
typedef struct {
int fd;
lv_disp_t * disp;
lv_display_t * disp;
struct lcddev_area_s area;
struct lcddev_area_align_s align_info;
} lv_nuttx_lcd_t;
@@ -43,9 +43,9 @@ typedef struct {
static lv_coord_t align_round_up(lv_coord_t v, uint16_t align);
static void rounder_cb(lv_event_t * e);
static void flush_cb(lv_disp_t * disp, const lv_area_t * area_p,
static void flush_cb(lv_display_t * disp, const lv_area_t * area_p,
uint8_t * color_p);
static lv_disp_t * lcd_init(int fd, int hor_res, int ver_res);
static lv_display_t * lcd_init(int fd, int hor_res, int ver_res);
/**********************
* STATIC VARIABLES
@@ -59,11 +59,11 @@ static lv_disp_t * lcd_init(int fd, int hor_res, int ver_res);
* GLOBAL FUNCTIONS
**********************/
lv_disp_t * lv_nuttx_lcd_create(const char * dev_path)
lv_display_t * lv_nuttx_lcd_create(const char * dev_path)
{
struct fb_videoinfo_s vinfo;
struct lcd_planeinfo_s pinfo;
lv_disp_t * disp;
lv_display_t * disp;
int fd;
int ret;
@@ -130,7 +130,7 @@ static void rounder_cb(lv_event_t * e)
area->y2 = area->y1 + h - 1;
}
static void flush_cb(lv_disp_t * disp, const lv_area_t * area_p,
static void flush_cb(lv_display_t * disp, const lv_area_t * area_p,
uint8_t * color_p)
{
lv_nuttx_lcd_t * lcd = disp->user_data;
@@ -141,10 +141,10 @@ static void flush_cb(lv_disp_t * disp, const lv_area_t * area_p,
lcd->area.col_end = area_p->x2;
lcd->area.data = (uint8_t *)color_p;
ioctl(lcd->fd, LCDDEVIO_PUTAREA, (unsigned long) & (lcd->area));
lv_disp_flush_ready(disp);
lv_display_flush_ready(disp);
}
static lv_disp_t * lcd_init(int fd, int hor_res, int ver_res)
static lv_display_t * lcd_init(int fd, int hor_res, int ver_res)
{
lv_color_t * draw_buf = NULL;
lv_color_t * draw_buf_2 = NULL;
@@ -156,19 +156,19 @@ static lv_disp_t * lcd_init(int fd, int hor_res, int ver_res)
}
lv_memzero(lcd, sizeof(lv_nuttx_lcd_t));
lv_disp_t * disp = lv_disp_create(hor_res, ver_res);
lv_display_t * disp = lv_display_create(hor_res, ver_res);
if(disp == NULL) {
lv_free(lcd);
return NULL;
}
uint32_t px_size = lv_color_format_get_size(lv_disp_get_color_format(disp));
uint32_t px_size = lv_color_format_get_size(lv_display_get_color_format(disp));
#if LV_NUTTX_LCD_BUFFER_COUNT > 0
uint32_t buf_size = hor_res * ver_res * px_size;
lv_disp_render_mode_t render_mode = LV_DISP_RENDER_MODE_FULL;
lv_display_render_mode_t render_mode = LV_DISPLAY_RENDER_MODE_FULL;
#else
uint32_t buf_size = hor_res * LV_NUTTX_LCD_BUFFER_SIZE * px_size;
lv_disp_render_mode_t render_mode = LV_DISP_RENDER_MODE_PARTIAL;
lv_display_render_mode_t render_mode = LV_DISPLAY_RENDER_MODE_PARTIAL;
#endif
draw_buf = lv_malloc(buf_size);
@@ -194,8 +194,8 @@ static lv_disp_t * lcd_init(int fd, int hor_res, int ver_res)
}
lcd->disp = disp;
lv_disp_set_draw_buffers(lcd->disp, draw_buf, draw_buf_2, buf_size, render_mode);
lv_disp_set_flush_cb(lcd->disp, flush_cb);
lv_display_set_draw_buffers(lcd->disp, draw_buf, draw_buf_2, buf_size, render_mode);
lv_display_set_flush_cb(lcd->disp, flush_cb);
lv_event_add(&lcd->disp->event_list, rounder_cb, LV_EVENT_INVALIDATE_AREA, lcd);
lcd->disp->user_data = lcd;

4
src/dev/disp/lcd/lv_nuttx_lcd.h → src/dev/display/lcd/lv_nuttx_lcd.h
View File

@@ -14,7 +14,7 @@ extern "C" {
* INCLUDES
*********************/
#include "../../../disp/lv_disp.h"
#include "../../../display/lv_display.h"
#if LV_USE_NUTTX_LCD
@@ -30,7 +30,7 @@ extern "C" {
* GLOBAL PROTOTYPES
**********************/
lv_disp_t * lv_nuttx_lcd_create(const char * dev_path);
lv_display_t * lv_nuttx_lcd_create(const char * dev_path);
/**********************
* MACROS

0
src/dev/disp/tft_espi/lv_tft_espi.cpp → src/dev/display/tft_espi/lv_tft_espi.cpp
View File

4
src/dev/disp/tft_espi/lv_tft_espi.h → src/dev/display/tft_espi/lv_tft_espi.h
View File

@@ -13,7 +13,7 @@ extern "C" {
/*********************
* INCLUDES
*********************/
#include "../../../disp/lv_disp.h"
#include "../../../display/lv_display.h"
#if LV_USE_TFT_ESPI
@@ -28,7 +28,7 @@ extern "C" {
/**********************
* GLOBAL PROTOTYPES
**********************/
lv_disp_t * lv_tft_espi_create(uint32_t hor_res, uint32_t ver_res, void * buf, uint32_t buf_size_bytes);
lv_display_t * lv_tft_espi_create(uint32_t hor_res, uint32_t ver_res, void * buf, uint32_t buf_size_bytes);
/**********************
* MACROS

2
src/dev/input/touchscreen/lv_nuttx_touchscreen.c
View File

@@ -96,7 +96,7 @@ static void touchscreen_read(lv_indev_t * drv, lv_indev_data_t * data)
uint8_t touch_flags = sample.point[0].flags;
if(touch_flags & TOUCH_DOWN || touch_flags & TOUCH_MOVE) {
const lv_disp_t * disp_drv = drv->disp;
const lv_display_t * disp_drv = drv->disp;
lv_coord_t ver_max = disp_drv->ver_res - 1;
lv_coord_t hor_max = disp_drv->hor_res - 1;

2
src/dev/sdl/lv_sdl_keyboard.c
View File

@@ -101,7 +101,7 @@ void _lv_sdl_keyboard_handler(SDL_Event * event)
return;
}
lv_disp_t * disp = _lv_sdl_get_disp_from_win_id(win_id);
lv_display_t * disp = _lv_sdl_get_disp_from_win_id(win_id);
/*Find a suitable indev*/
lv_indev_t * indev = lv_indev_get_next(NULL);

6
src/dev/sdl/lv_sdl_mouse.c
View File

@@ -99,7 +99,7 @@ void _lv_sdl_mouse_handler(SDL_Event * event)
return;
}
lv_disp_t * disp = _lv_sdl_get_disp_from_win_id(win_id);
lv_display_t * disp = _lv_sdl_get_disp_from_win_id(win_id);
/*Find a suitable indev*/
lv_indev_t * indev = lv_indev_get_next(NULL);
@@ -114,8 +114,8 @@ void _lv_sdl_mouse_handler(SDL_Event * event)
lv_sdl_mouse_t * indev_dev = lv_indev_get_driver_data(indev);
if(indev_dev == NULL) return;
lv_coord_t hor_res = lv_disp_get_hor_res(disp);
lv_coord_t ver_res = lv_disp_get_ver_res(disp);
lv_coord_t hor_res = lv_display_get_horizontal_resolution(disp);
lv_coord_t ver_res = lv_display_get_vertical_resolution(disp);
uint8_t zoom = lv_sdl_window_get_zoom(disp);
switch(event->type) {

2
src/dev/sdl/lv_sdl_mousewheel.c
View File

@@ -84,7 +84,7 @@ void _lv_sdl_mousewheel_handler(SDL_Event * event)
return;
}
lv_disp_t * disp = _lv_sdl_get_disp_from_win_id(win_id);
lv_display_t * disp = _lv_sdl_get_disp_from_win_id(win_id);
/*Find a suitable indev*/
lv_indev_t * indev = lv_indev_get_next(NULL);

128
src/dev/sdl/lv_sdl_window.c
View File

@@ -36,18 +36,18 @@ typedef struct {
/**********************
* STATIC PROTOTYPES
**********************/
static void flush_cb(lv_disp_t * disp, const lv_area_t * area, uint8_t * color_p);
static void window_create(lv_disp_t * disp);
static void window_update(lv_disp_t * disp);
static void clean_up(lv_disp_t * disp);
static void texture_resize(lv_disp_t * disp);
static void flush_cb(lv_display_t * disp, const lv_area_t * area, uint8_t * color_p);
static void window_create(lv_display_t * disp);
static void window_update(lv_display_t * disp);
static void clean_up(lv_display_t * disp);
static void texture_resize(lv_display_t * disp);
static void sdl_event_handler(lv_timer_t * t);
static void release_disp_cb(lv_event_t * e);
/***********************
* GLOBAL PROTOTYPES
***********************/
lv_disp_t * _lv_sdl_get_disp_from_win_id(uint32_t win_id);
lv_display_t * _lv_sdl_get_disp_from_win_id(uint32_t win_id);
void _lv_sdl_mouse_handler(SDL_Event * event);
void _lv_sdl_mousewheel_handler(SDL_Event * event);
void _lv_sdl_keyboard_handler(SDL_Event * event);
@@ -68,7 +68,7 @@ static lv_timer_t * event_handler_timer;
* GLOBAL FUNCTIONS
**********************/
lv_disp_t * lv_sdl_window_create(lv_coord_t hor_res, lv_coord_t ver_res)
lv_display_t * lv_sdl_window_create(lv_coord_t hor_res, lv_coord_t ver_res)
{
if(!inited) {
SDL_Init(SDL_INIT_VIDEO);
@@ -83,67 +83,69 @@ lv_disp_t * lv_sdl_window_create(lv_coord_t hor_res, lv_coord_t ver_res)
if(dsc == NULL) return NULL;
lv_memzero(dsc, sizeof(lv_sdl_window_t));
lv_disp_t * disp = lv_disp_create(hor_res, ver_res);
lv_display_t * disp = lv_display_create(hor_res, ver_res);
if(disp == NULL) {
lv_free(dsc);
return NULL;
}
lv_disp_add_event(disp, release_disp_cb, LV_EVENT_DELETE, disp);
lv_disp_set_driver_data(disp, dsc);
lv_display_add_event(disp, release_disp_cb, LV_EVENT_DELETE, disp);
lv_display_set_driver_data(disp, dsc);
window_create(disp);
lv_disp_set_flush_cb(disp, flush_cb);
if(LV_SDL_RENDER_MODE == LV_DISP_RENDER_MODE_PARTIAL) {
lv_display_set_flush_cb(disp, flush_cb);
if(LV_SDL_RENDER_MODE == LV_DISPLAY_RENDER_MODE_PARTIAL) {
uint8_t * buf1 = malloc(32 * 1024);
uint8_t * buf2 = NULL;
#if LV_SDL_BUF_COUNT == 2
buf2 = malloc(32 * 1024);
#endif
lv_disp_set_draw_buffers(disp, buf1, buf2,
32 * 1024, LV_DISP_RENDER_MODE_PARTIAL);
lv_display_set_draw_buffers(disp, buf1, buf2,
32 * 1024, LV_DISPLAY_RENDER_MODE_PARTIAL);
}
/*LV_DISP_RENDER_MODE_DIRECT or FULL */
/*LV_DISPLAY_RENDER_MODE_DIRECT or FULL */
else {
uint32_t stride = lv_draw_buf_width_to_stride(lv_disp_get_hor_res(disp), lv_disp_get_color_format(disp));
lv_disp_set_draw_buffers(disp, dsc->fb1, dsc->fb2, stride * lv_disp_get_ver_res(disp), LV_SDL_RENDER_MODE);
uint32_t stride = lv_draw_buf_width_to_stride(lv_display_get_horizontal_resolution(disp),
lv_display_get_color_format(disp));
lv_display_set_draw_buffers(disp, dsc->fb1, dsc->fb2, stride * lv_display_get_vertical_resolution(disp),
LV_SDL_RENDER_MODE);
}
lv_disp_add_event(disp, res_chg_event_cb, LV_EVENT_RESOLUTION_CHANGED, NULL);
lv_display_add_event(disp, res_chg_event_cb, LV_EVENT_RESOLUTION_CHANGED, NULL);
return disp;
}
void lv_sdl_window_set_zoom(lv_disp_t * disp, uint8_t zoom)
void lv_sdl_window_set_zoom(lv_display_t * disp, uint8_t zoom)
{
lv_sdl_window_t * dsc = lv_disp_get_driver_data(disp);
lv_sdl_window_t * dsc = lv_display_get_driver_data(disp);
dsc->zoom = zoom;
lv_disp_send_event(disp, LV_EVENT_RESOLUTION_CHANGED, NULL);
lv_display_send_event(disp, LV_EVENT_RESOLUTION_CHANGED, NULL);
lv_refr_now(disp);
}
uint8_t lv_sdl_window_get_zoom(lv_disp_t * disp)
uint8_t lv_sdl_window_get_zoom(lv_display_t * disp)
{
lv_sdl_window_t * dsc = lv_disp_get_driver_data(disp);
lv_sdl_window_t * dsc = lv_display_get_driver_data(disp);
return dsc->zoom;
}
lv_disp_t * _lv_sdl_get_disp_from_win_id(uint32_t win_id)
lv_display_t * _lv_sdl_get_disp_from_win_id(uint32_t win_id)
{
lv_disp_t * disp = lv_disp_get_next(NULL);
lv_display_t * disp = lv_display_get_next(NULL);
if(win_id == UINT32_MAX) return disp;
while(disp) {
lv_sdl_window_t * dsc = lv_disp_get_driver_data(disp);
lv_sdl_window_t * dsc = lv_display_get_driver_data(disp);
if(SDL_GetWindowID(dsc->window) == win_id) {
return disp;
}
disp = lv_disp_get_next(disp);
disp = lv_display_get_next(disp);
}
return NULL;
}
void lv_sdl_window_set_title(lv_disp_t * disp, const char * title)
void lv_sdl_window_set_title(lv_display_t * disp, const char * title)
{
lv_sdl_window_t * dsc = lv_disp_get_driver_data(disp);
lv_sdl_window_t * dsc = lv_display_get_driver_data(disp);
SDL_SetWindowTitle(dsc->window, title);
}
@@ -161,15 +163,15 @@ void lv_sdl_quit()
**********************/
static void flush_cb(lv_disp_t * disp, const lv_area_t * area, uint8_t * px_map)
static void flush_cb(lv_display_t * disp, const lv_area_t * area, uint8_t * px_map)
{
lv_sdl_window_t * dsc = lv_disp_get_driver_data(disp);
if(LV_SDL_RENDER_MODE == LV_DISP_RENDER_MODE_PARTIAL) {
lv_sdl_window_t * dsc = lv_display_get_driver_data(disp);
if(LV_SDL_RENDER_MODE == LV_DISPLAY_RENDER_MODE_PARTIAL) {
int32_t y;
uint8_t * fb_tmp = dsc->fb_act;
uint32_t px_size = lv_color_format_get_size(lv_disp_get_color_format(disp));
uint32_t px_size = lv_color_format_get_size(lv_display_get_color_format(disp));
uint32_t px_map_stride = lv_area_get_width(area) * px_size;
lv_coord_t fb_stride = lv_disp_get_hor_res(disp) * px_size;
lv_coord_t fb_stride = lv_display_get_horizontal_resolution(disp) * px_size;
fb_tmp += area->y1 * fb_stride;
fb_tmp += area->x1 * px_size;
for(y = area->y1; y <= area->y2; y++) {
@@ -181,15 +183,15 @@ static void flush_cb(lv_disp_t * disp, const lv_area_t * area, uint8_t * px_map)
/* TYPICALLY YOU DO NOT NEED THIS
* If it was the last part to refresh update the texture of the window.*/
if(lv_disp_flush_is_last(disp)) {
if(LV_SDL_RENDER_MODE != LV_DISP_RENDER_MODE_PARTIAL) {
if(lv_display_flush_is_last(disp)) {
if(LV_SDL_RENDER_MODE != LV_DISPLAY_RENDER_MODE_PARTIAL) {
dsc->fb_act = px_map;
}
window_update(disp);
}
/*IMPORTANT! It must be called to tell the system the flush is ready*/
lv_disp_flush_ready(disp);
lv_display_flush_ready(disp);
}
/**
@@ -208,9 +210,9 @@ static void sdl_event_handler(lv_timer_t * t)
_lv_sdl_keyboard_handler(&event);
if(event.type == SDL_WINDOWEVENT) {
lv_disp_t * disp = _lv_sdl_get_disp_from_win_id(event.window.windowID);
lv_display_t * disp = _lv_sdl_get_disp_from_win_id(event.window.windowID);
if(disp == NULL) continue;
lv_sdl_window_t * dsc = lv_disp_get_driver_data(disp);
lv_sdl_window_t * dsc = lv_display_get_driver_data(disp);
switch(event.window.event) {
#if SDL_VERSION_ATLEAST(2, 0, 5)
@@ -221,7 +223,7 @@ static void sdl_event_handler(lv_timer_t * t)
break;
case SDL_WINDOWEVENT_RESIZED:
dsc->ignore_size_chg = 1;
lv_disp_set_res(disp, event.window.data1 / dsc->zoom, event.window.data2 / dsc->zoom);
lv_display_set_resolution(disp, event.window.data1 / dsc->zoom, event.window.data2 / dsc->zoom);
dsc->ignore_size_chg = 0;
lv_refr_now(disp);
break;
@@ -243,9 +245,9 @@ static void sdl_event_handler(lv_timer_t * t)
}
}
static void clean_up(lv_disp_t * disp)
static void clean_up(lv_display_t * disp)
{
lv_sdl_window_t * dsc = lv_disp_get_driver_data(disp);
lv_sdl_window_t * dsc = lv_display_get_driver_data(disp);
SDL_DestroyTexture(dsc->texture);
SDL_DestroyRenderer(dsc->renderer);
SDL_DestroyWindow(dsc->window);
@@ -253,9 +255,9 @@ static void clean_up(lv_disp_t * disp)
lv_free(dsc);
}
static void window_create(lv_disp_t * disp)
static void window_create(lv_display_t * disp)
{
lv_sdl_window_t * dsc = lv_disp_get_driver_data(disp);
lv_sdl_window_t * dsc = lv_display_get_driver_data(disp);
dsc->zoom = 1;
int flag = SDL_WINDOW_RESIZABLE;
@@ -263,15 +265,15 @@ static void window_create(lv_disp_t * disp)
flag |= SDL_WINDOW_FULLSCREEN;
#endif
lv_coord_t hor_res = lv_disp_get_hor_res(disp);
lv_coord_t ver_res = lv_disp_get_ver_res(disp);
lv_coord_t hor_res = lv_display_get_horizontal_resolution(disp);
lv_coord_t ver_res = lv_display_get_vertical_resolution(disp);
dsc->window = SDL_CreateWindow("LVGL Simulator",
SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED,
hor_res * dsc->zoom, ver_res * dsc->zoom, flag); /*last param. SDL_WINDOW_BORDERLESS to hide borders*/
dsc->renderer = SDL_CreateRenderer(dsc->window, -1, SDL_RENDERER_SOFTWARE);
texture_resize(disp);
uint32_t px_size = lv_color_format_get_size(lv_disp_get_color_format(disp));
uint32_t px_size = lv_color_format_get_size(lv_display_get_color_format(disp));
lv_memset(dsc->fb1, 0xff, hor_res * ver_res * px_size);
#if LV_SDL_DIRECT_MODE_2_BUF
lv_memset(dsc->fb2, 0xff, hor_res * ver_res * px_size);
@@ -281,11 +283,11 @@ static void window_create(lv_disp_t * disp)
texture_resize(disp);
}
static void window_update(lv_disp_t * disp)
static void window_update(lv_display_t * disp)
{
lv_sdl_window_t * dsc = lv_disp_get_driver_data(disp);
lv_coord_t hor_res = lv_disp_get_hor_res(disp);
uint32_t stride = lv_draw_buf_width_to_stride(hor_res, lv_disp_get_color_format(disp));
lv_sdl_window_t * dsc = lv_display_get_driver_data(disp);
lv_coord_t hor_res = lv_display_get_horizontal_resolution(disp);
uint32_t stride = lv_draw_buf_width_to_stride(hor_res, lv_display_get_color_format(disp));
SDL_UpdateTexture(dsc->texture, NULL, dsc->fb_act, stride);
SDL_RenderClear(dsc->renderer);
@@ -295,17 +297,17 @@ static void window_update(lv_disp_t * disp)
SDL_RenderPresent(dsc->renderer);
}
static void texture_resize(lv_disp_t * disp)
static void texture_resize(lv_display_t * disp)
{
lv_coord_t hor_res = lv_disp_get_hor_res(disp);
lv_coord_t ver_res = lv_disp_get_ver_res(disp);
uint32_t stride = lv_draw_buf_width_to_stride(hor_res, lv_disp_get_color_format(disp));
lv_sdl_window_t * dsc = lv_disp_get_driver_data(disp);
lv_coord_t hor_res = lv_display_get_horizontal_resolution(disp);
lv_coord_t ver_res = lv_display_get_vertical_resolution(disp);
uint32_t stride = lv_draw_buf_width_to_stride(hor_res, lv_display_get_color_format(disp));
lv_sdl_window_t * dsc = lv_display_get_driver_data(disp);
dsc->fb1 = realloc(dsc->fb1, stride * ver_res);
memset(dsc->fb1, 0x00, stride * ver_res);
if(LV_SDL_RENDER_MODE == LV_DISP_RENDER_MODE_PARTIAL) {
if(LV_SDL_RENDER_MODE == LV_DISPLAY_RENDER_MODE_PARTIAL) {
dsc->fb_act = dsc->fb1;
}
else {
@@ -313,7 +315,7 @@ static void texture_resize(lv_disp_t * disp)
dsc->fb2 = realloc(dsc->fb2, stride * ver_res);
memset(dsc->fb2, 0x00, stride * ver_res);
#endif
lv_disp_set_draw_buffers(disp, dsc->fb1, dsc->fb2, stride * ver_res, LV_SDL_RENDER_MODE);
lv_display_set_draw_buffers(disp, dsc->fb1, dsc->fb2, stride * ver_res, LV_SDL_RENDER_MODE);
}
if(dsc->texture) SDL_DestroyTexture(dsc->texture);
@@ -335,11 +337,11 @@ static void texture_resize(lv_disp_t * disp)
static void res_chg_event_cb(lv_event_t * e)
{
lv_disp_t * disp = lv_event_get_target(e);
lv_display_t * disp = lv_event_get_target(e);
int32_t hor_res = lv_disp_get_hor_res(disp);
int32_t ver_res = lv_disp_get_ver_res(disp);
lv_sdl_window_t * dsc = lv_disp_get_driver_data(disp);
int32_t hor_res = lv_display_get_horizontal_resolution(disp);
int32_t ver_res = lv_display_get_vertical_resolution(disp);
lv_sdl_window_t * dsc = lv_display_get_driver_data(disp);
if(dsc->ignore_size_chg == false) {
SDL_SetWindowSize(dsc->window, hor_res * dsc->zoom, ver_res * dsc->zoom);
}
@@ -349,7 +351,7 @@ static void res_chg_event_cb(lv_event_t * e)
static void release_disp_cb(lv_event_t * e)
{
lv_disp_t * disp = (lv_disp_t *) lv_event_get_user_data(e);
lv_display_t * disp = (lv_display_t *) lv_event_get_user_data(e);
clean_up(disp);
}

12
src/dev/sdl/lv_sdl_window.h
View File

@@ -14,7 +14,7 @@ extern "C" {
* INCLUDES
*********************/
#include "../../disp/lv_disp.h"
#include "../../display/lv_display.h"
#include "../../indev/lv_indev.h"
#if LV_USE_SDL
@@ -31,15 +31,15 @@ extern "C" {
* GLOBAL PROTOTYPES
**********************/
lv_disp_t * lv_sdl_window_create(lv_coord_t hor_res, lv_coord_t ver_res);
lv_display_t * lv_sdl_window_create(lv_coord_t hor_res, lv_coord_t ver_res);
void lv_sdl_window_set_zoom(lv_disp_t * disp, uint8_t zoom);
void lv_sdl_window_set_zoom(lv_display_t * disp, uint8_t zoom);
uint8_t lv_sdl_window_get_zoom(lv_disp_t * disp);
uint8_t lv_sdl_window_get_zoom(lv_display_t * disp);
lv_disp_t * _lv_sdl_get_disp_from_win_id(uint32_t win_id);
lv_display_t * _lv_sdl_get_disp_from_win_id(uint32_t win_id);
void lv_sdl_window_set_title(lv_disp_t * disp, const char * title);
void lv_sdl_window_set_title(lv_display_t * disp, const char * title);
void lv_sdl_quit();

292
src/disp/lv_disp.c → src/display/lv_display.c
View File

@@ -6,10 +6,10 @@
/*********************
* INCLUDES
*********************/
#include "lv_disp.h"
#include "lv_display.h"
#include "../misc/lv_math.h"
#include "../core/lv_refr.h"
#include "../disp/lv_disp_private.h"
#include "../display/lv_display_private.h"
#include "../stdlib/lv_string.h"
#include "../themes/lv_theme.h"
#include "../core/lv_global.h"
@@ -33,7 +33,7 @@
* STATIC PROTOTYPES
**********************/
static lv_obj_tree_walk_res_t invalidate_layout_cb(lv_obj_t * obj, void * user_data);
static void update_resolution(lv_disp_t * disp);
static void update_resolution(lv_display_t * disp);
static void scr_load_internal(lv_obj_t * scr);
static void scr_load_anim_start(lv_anim_t * a);
static void opa_scale_anim(void * obj, int32_t v);
@@ -55,13 +55,13 @@ static void disp_event_cb(lv_event_t * e);
* GLOBAL FUNCTIONS
**********************/
lv_disp_t * lv_disp_create(lv_coord_t hor_res, lv_coord_t ver_res)
lv_display_t * lv_display_create(lv_coord_t hor_res, lv_coord_t ver_res)
{
lv_disp_t * disp = _lv_ll_ins_head(disp_ll_p);
lv_display_t * disp = _lv_ll_ins_head(disp_ll_p);
LV_ASSERT_MALLOC(disp);
if(!disp) return NULL;
lv_memzero(disp, sizeof(lv_disp_t));
lv_memzero(disp, sizeof(lv_display_t));
disp->hor_res = hor_res;
disp->ver_res = ver_res;
@@ -84,11 +84,11 @@ lv_disp_t * lv_disp_create(lv_coord_t hor_res, lv_coord_t ver_res)
disp->inv_en_cnt = 1;
lv_disp_t * disp_def_tmp = disp_def;
lv_display_t * disp_def_tmp = disp_def;
disp_def = disp; /*Temporarily change the default screen to create the default screens on the
new display*/
/*Create a refresh timer*/
disp->refr_timer = lv_timer_create(_lv_disp_refr_timer, LV_DEF_REFR_PERIOD, disp);
disp->refr_timer = lv_timer_create(_lv_display_refr_timer, LV_DEF_REFR_PERIOD, disp);
LV_ASSERT_MALLOC(disp->refr_timer);
if(disp->refr_timer == NULL) {
lv_free(disp);
@@ -124,7 +124,7 @@ lv_disp_t * lv_disp_create(lv_coord_t hor_res, lv_coord_t ver_res)
disp_def = disp_def_tmp; /*Revert the default display*/
if(disp_def == NULL) disp_def = disp; /*Initialize the default display*/
lv_disp_add_event(disp, disp_event_cb, LV_EVENT_REFR_REQUEST, NULL);
lv_display_add_event(disp, disp_event_cb, LV_EVENT_REFR_REQUEST, NULL);
lv_timer_ready(disp->refr_timer); /*Be sure the screen will be refreshed immediately on start up*/
@@ -132,12 +132,12 @@ lv_disp_t * lv_disp_create(lv_coord_t hor_res, lv_coord_t ver_res)
}
void lv_disp_remove(lv_disp_t * disp)
void lv_display_remove(lv_display_t * disp)
{
bool was_default = false;
if(disp == lv_disp_get_default()) was_default = true;
if(disp == lv_display_get_default()) was_default = true;
lv_disp_send_event(disp, LV_EVENT_DELETE, NULL);
lv_display_send_event(disp, LV_EVENT_DELETE, NULL);
lv_event_remove_all(&(disp->event_list));
/*Detach the input devices*/
@@ -173,20 +173,20 @@ void lv_disp_remove(lv_disp_t * disp)
if(disp->refr_timer) lv_timer_del(disp->refr_timer);
lv_free(disp);
if(was_default) lv_disp_set_default(_lv_ll_get_head(disp_ll_p));
if(was_default) lv_display_set_default(_lv_ll_get_head(disp_ll_p));
}
void lv_disp_set_default(lv_disp_t * disp)
void lv_display_set_default(lv_display_t * disp)
{
disp_def = disp;
}
lv_disp_t * lv_disp_get_default(void)
lv_display_t * lv_display_get_default(void)
{
return disp_def;
}
lv_disp_t * lv_disp_get_next(lv_disp_t * disp)
lv_display_t * lv_display_get_next(lv_display_t * disp)
{
if(disp == NULL)
return _lv_ll_get_head(disp_ll_p);
@@ -198,9 +198,9 @@ lv_disp_t * lv_disp_get_next(lv_disp_t * disp)
* RESOLUTION
*--------------------*/
void lv_disp_set_res(lv_disp_t * disp, lv_coord_t hor_res, lv_coord_t ver_res)
void lv_display_set_resolution(lv_display_t * disp, lv_coord_t hor_res, lv_coord_t ver_res)
{
if(disp == NULL) disp = lv_disp_get_default();
if(disp == NULL) disp = lv_display_get_default();
if(disp == NULL) return;
if(disp->hor_res == hor_res && disp->ver_res == ver_res) return;
@@ -211,9 +211,9 @@ void lv_disp_set_res(lv_disp_t * disp, lv_coord_t hor_res, lv_coord_t ver_res)
update_resolution(disp);
}
void lv_disp_set_physical_res(lv_disp_t * disp, lv_coord_t hor_res, lv_coord_t ver_res)
void lv_display_set_physical_resolution(lv_display_t * disp, lv_coord_t hor_res, lv_coord_t ver_res)
{
if(disp == NULL) disp = lv_disp_get_default();
if(disp == NULL) disp = lv_display_get_default();
if(disp == NULL) return;
disp->physical_hor_res = hor_res;
@@ -223,9 +223,9 @@ void lv_disp_set_physical_res(lv_disp_t * disp, lv_coord_t hor_res, lv_coord_t v
}
void lv_disp_set_offset(lv_disp_t * disp, lv_coord_t x, lv_coord_t y)
void lv_display_set_offset(lv_display_t * disp, lv_coord_t x, lv_coord_t y)
{
if(disp == NULL) disp = lv_disp_get_default();
if(disp == NULL) disp = lv_display_get_default();
if(disp == NULL) return;
disp->offset_x = x;
@@ -235,25 +235,25 @@ void lv_disp_set_offset(lv_disp_t * disp, lv_coord_t x, lv_coord_t y)
}
void lv_disp_set_dpi(lv_disp_t * disp, lv_coord_t dpi)
void lv_display_set_dpi(lv_display_t * disp, lv_coord_t dpi)
{
if(disp == NULL) disp = lv_disp_get_default();
if(disp == NULL) disp = lv_display_get_default();
if(disp == NULL) return;
disp->dpi = dpi;
}
lv_coord_t lv_disp_get_hor_res(const lv_disp_t * disp)
lv_coord_t lv_display_get_horizontal_resolution(const lv_display_t * disp)
{
if(disp == NULL) disp = lv_disp_get_default();
if(disp == NULL) disp = lv_display_get_default();
if(disp == NULL) {
return 0;
}
else {
switch(disp->rotation) {
case LV_DISP_ROTATION_90:
case LV_DISP_ROTATION_270:
case LV_DISPLAY_ROTATION_90:
case LV_DISPLAY_ROTATION_270:
return disp->ver_res;
default:
return disp->hor_res;
@@ -261,17 +261,17 @@ lv_coord_t lv_disp_get_hor_res(const lv_disp_t * disp)
}
}
lv_coord_t lv_disp_get_ver_res(const lv_disp_t * disp)
lv_coord_t lv_display_get_vertical_resolution(const lv_display_t * disp)
{
if(disp == NULL) disp = lv_disp_get_default();
if(disp == NULL) disp = lv_display_get_default();
if(disp == NULL) {
return 0;
}
else {
switch(disp->rotation) {
case LV_DISP_ROTATION_90:
case LV_DISP_ROTATION_270:
case LV_DISPLAY_ROTATION_90:
case LV_DISPLAY_ROTATION_270:
return disp->hor_res;
default:
return disp->ver_res;
@@ -279,17 +279,17 @@ lv_coord_t lv_disp_get_ver_res(const lv_disp_t * disp)
}
}
lv_coord_t lv_disp_get_physical_hor_res(const lv_disp_t * disp)
lv_coord_t lv_display_get_physical_horizontal_resolution(const lv_display_t * disp)
{
if(disp == NULL) disp = lv_disp_get_default();
if(disp == NULL) disp = lv_display_get_default();
if(disp == NULL) {
return 0;
}
else {
switch(disp->rotation) {
case LV_DISP_ROTATION_90:
case LV_DISP_ROTATION_270:
case LV_DISPLAY_ROTATION_90:
case LV_DISPLAY_ROTATION_270:
return disp->physical_ver_res > 0 ? disp->physical_ver_res : disp->ver_res;
default:
return disp->physical_hor_res > 0 ? disp->physical_hor_res : disp->hor_res;
@@ -297,17 +297,17 @@ lv_coord_t lv_disp_get_physical_hor_res(const lv_disp_t * disp)
}
}
lv_coord_t lv_disp_get_physical_ver_res(const lv_disp_t * disp)
lv_coord_t lv_display_get_physical_vertical_resolution(const lv_display_t * disp)
{
if(disp == NULL) disp = lv_disp_get_default();
if(disp == NULL) disp = lv_display_get_default();
if(disp == NULL) {
return 0;
}
else {
switch(disp->rotation) {
case LV_DISP_ROTATION_90:
case LV_DISP_ROTATION_270:
case LV_DISPLAY_ROTATION_90:
case LV_DISPLAY_ROTATION_270:
return disp->physical_hor_res > 0 ? disp->physical_hor_res : disp->hor_res;
default:
return disp->physical_ver_res > 0 ? disp->physical_ver_res : disp->ver_res;
@@ -315,51 +315,51 @@ lv_coord_t lv_disp_get_physical_ver_res(const lv_disp_t * disp)
}
}
lv_coord_t lv_disp_get_offset_x(const lv_disp_t * disp)
lv_coord_t lv_display_get_offset_x(const lv_display_t * disp)
{
if(disp == NULL) disp = lv_disp_get_default();
if(disp == NULL) disp = lv_display_get_default();
if(disp == NULL) {
return 0;
}
else {
switch(disp->rotation) {
case LV_DISP_ROTATION_90:
case LV_DISPLAY_ROTATION_90:
return disp->offset_y;
case LV_DISP_ROTATION_180:
return lv_disp_get_physical_hor_res(disp) - disp->offset_x;
case LV_DISP_ROTATION_270:
return lv_disp_get_physical_hor_res(disp) - disp->offset_y;
case LV_DISPLAY_ROTATION_180:
return lv_display_get_physical_horizontal_resolution(disp) - disp->offset_x;
case LV_DISPLAY_ROTATION_270:
return lv_display_get_physical_horizontal_resolution(disp) - disp->offset_y;
default:
return disp->offset_x;
}
}
}
lv_coord_t lv_disp_get_offset_y(const lv_disp_t * disp)
lv_coord_t lv_display_get_offset_y(const lv_display_t * disp)
{
if(disp == NULL) disp = lv_disp_get_default();
if(disp == NULL) disp = lv_display_get_default();
if(disp == NULL) {
return 0;
}
else {
switch(disp->rotation) {
case LV_DISP_ROTATION_90:
case LV_DISPLAY_ROTATION_90:
return disp->offset_x;
case LV_DISP_ROTATION_180:
return lv_disp_get_physical_ver_res(disp) - disp->offset_y;
case LV_DISP_ROTATION_270:
return lv_disp_get_physical_ver_res(disp) - disp->offset_x;
case LV_DISPLAY_ROTATION_180:
return lv_display_get_physical_vertical_resolution(disp) - disp->offset_y;
case LV_DISPLAY_ROTATION_270:
return lv_display_get_physical_vertical_resolution(disp) - disp->offset_x;
default:
return disp->offset_y;
}
}
}
lv_coord_t lv_disp_get_dpi(const lv_disp_t * disp)
lv_coord_t lv_display_get_dpi(const lv_display_t * disp)
{
if(disp == NULL) disp = lv_disp_get_default();
if(disp == NULL) disp = lv_display_get_default();
if(disp == NULL) return LV_DPI_DEF; /*Do not return 0 because it might be a divider*/
return disp->dpi;
}
@@ -368,10 +368,10 @@ lv_coord_t lv_disp_get_dpi(const lv_disp_t * disp)
* BUFFERING
*--------------------*/
void lv_disp_set_draw_buffers(lv_disp_t * disp, void * buf1, void * buf2, uint32_t buf_size_in_bytes,
lv_disp_render_mode_t render_mode)
void lv_display_set_draw_buffers(lv_display_t * disp, void * buf1, void * buf2, uint32_t buf_size_in_bytes,
lv_display_render_mode_t render_mode)
{
if(disp == NULL) disp = lv_disp_get_default();
if(disp == NULL) disp = lv_display_get_default();
if(disp == NULL) return;
disp->buf_1 = buf1;
@@ -381,60 +381,60 @@ void lv_disp_set_draw_buffers(lv_disp_t * disp, void * buf1, void * buf2, uint32
disp->render_mode = render_mode;
}
void lv_disp_set_flush_cb(lv_disp_t * disp, lv_disp_flush_cb_t flush_cb)
void lv_display_set_flush_cb(lv_display_t * disp, lv_display_flush_cb_t flush_cb)
{
if(disp == NULL) disp = lv_disp_get_default();
if(disp == NULL) disp = lv_display_get_default();
if(disp == NULL) return;
disp->flush_cb = flush_cb;
}
void lv_disp_set_color_format(lv_disp_t * disp, lv_color_format_t color_format)
void lv_display_set_color_format(lv_display_t * disp, lv_color_format_t color_format)
{
if(disp == NULL) disp = lv_disp_get_default();
if(disp == NULL) disp = lv_display_get_default();
if(disp == NULL) return;
disp->color_format = color_format;
disp->layer_head->draw_buf.color_format = color_format;
}
lv_color_format_t lv_disp_get_color_format(lv_disp_t * disp)
lv_color_format_t lv_display_get_color_format(lv_display_t * disp)
{
if(disp == NULL) disp = lv_disp_get_default();
if(disp == NULL) disp = lv_display_get_default();
if(disp == NULL) return LV_COLOR_FORMAT_UNKNOWN;
return disp->color_format;
}
void lv_disp_set_antialiasing(lv_disp_t * disp, bool en)
void lv_display_set_antialiasing(lv_display_t * disp, bool en)
{
if(disp == NULL) disp = lv_disp_get_default();
if(disp == NULL) disp = lv_display_get_default();
if(disp == NULL) return;
disp->antialiasing = en;
}
bool lv_disp_get_antialiasing(lv_disp_t * disp)
bool lv_display_get_antialiasing(lv_display_t * disp)
{
if(disp == NULL) disp = lv_disp_get_default();
if(disp == NULL) disp = lv_display_get_default();
if(disp == NULL) return false;
return disp->antialiasing;
}
LV_ATTRIBUTE_FLUSH_READY void lv_disp_flush_ready(lv_disp_t * disp)
LV_ATTRIBUTE_FLUSH_READY void lv_display_flush_ready(lv_display_t * disp)
{
disp->flushing = 0;
disp->flushing_last = 0;
}
LV_ATTRIBUTE_FLUSH_READY bool lv_disp_flush_is_last(lv_disp_t * disp)
LV_ATTRIBUTE_FLUSH_READY bool lv_display_flush_is_last(lv_display_t * disp)
{
return disp->flushing_last;
}
bool lv_disp_is_double_buffered(lv_disp_t * disp)
bool lv_display_is_double_buffered(lv_display_t * disp)
{
return disp->buf_2 != NULL;
}
@@ -443,9 +443,9 @@ bool lv_disp_is_double_buffered(lv_disp_t * disp)
* SCREENS
*--------------------*/
lv_obj_t * lv_disp_get_scr_act(lv_disp_t * disp)
lv_obj_t * lv_display_get_scr_act(lv_display_t * disp)
{
if(!disp) disp = lv_disp_get_default();
if(!disp) disp = lv_display_get_default();
if(!disp) {
LV_LOG_WARN("no display registered to get its active screen");
return NULL;
@@ -454,9 +454,9 @@ lv_obj_t * lv_disp_get_scr_act(lv_disp_t * disp)
return disp->act_scr;
}
lv_obj_t * lv_disp_get_scr_prev(lv_disp_t * disp)
lv_obj_t * lv_display_get_scr_prev(lv_display_t * disp)
{
if(!disp) disp = lv_disp_get_default();
if(!disp) disp = lv_display_get_default();
if(!disp) {
LV_LOG_WARN("no display registered to get its previous screen");
return NULL;
@@ -465,14 +465,14 @@ lv_obj_t * lv_disp_get_scr_prev(lv_disp_t * disp)
return disp->prev_scr;
}
void lv_disp_load_scr(lv_obj_t * scr)
void lv_display_load_scr(lv_obj_t * scr)
{
lv_scr_load_anim(scr, LV_SCR_LOAD_ANIM_NONE, 0, 0, false);
}
lv_obj_t * lv_disp_get_layer_top(lv_disp_t * disp)
lv_obj_t * lv_display_get_layer_top(lv_display_t * disp)
{
if(!disp) disp = lv_disp_get_default();
if(!disp) disp = lv_display_get_default();
if(!disp) {
LV_LOG_WARN("lv_layer_top: no display registered to get its top layer");
return NULL;
@@ -481,9 +481,9 @@ lv_obj_t * lv_disp_get_layer_top(lv_disp_t * disp)
return disp->top_layer;
}
lv_obj_t * lv_disp_get_layer_sys(lv_disp_t * disp)
lv_obj_t * lv_display_get_layer_sys(lv_display_t * disp)
{
if(!disp) disp = lv_disp_get_default();
if(!disp) disp = lv_display_get_default();
if(!disp) {
LV_LOG_WARN("lv_layer_sys: no display registered to get its sys. layer");
return NULL;
@@ -492,9 +492,9 @@ lv_obj_t * lv_disp_get_layer_sys(lv_disp_t * disp)
return disp->sys_layer;
}
lv_obj_t * lv_disp_get_layer_bottom(lv_disp_t * disp)
lv_obj_t * lv_display_get_layer_bottom(lv_display_t * disp)
{
if(!disp) disp = lv_disp_get_default();
if(!disp) disp = lv_display_get_default();
if(!disp) {
LV_LOG_WARN("lv_layer_bottom: no display registered to get its bottom layer");
return NULL;
@@ -505,7 +505,7 @@ lv_obj_t * lv_disp_get_layer_bottom(lv_disp_t * disp)
void lv_scr_load_anim(lv_obj_t * new_scr, lv_scr_load_anim_t anim_type, uint32_t time, uint32_t delay, bool auto_del)
{
lv_disp_t * d = lv_obj_get_disp(new_scr);
lv_display_t * d = lv_obj_get_disp(new_scr);
lv_obj_t * act_scr = lv_scr_act();
if(act_scr == new_scr || d->scr_to_load == new_scr) {
@@ -578,47 +578,47 @@ void lv_scr_load_anim(lv_obj_t * new_scr, lv_scr_load_anim_t anim_type, uint32_t
break;
case LV_SCR_LOAD_ANIM_OVER_LEFT:
lv_anim_set_exec_cb(&a_new, set_x_anim);
lv_anim_set_values(&a_new, lv_disp_get_hor_res(d), 0);
lv_anim_set_values(&a_new, lv_display_get_horizontal_resolution(d), 0);
break;
case LV_SCR_LOAD_ANIM_OVER_RIGHT:
lv_anim_set_exec_cb(&a_new, set_x_anim);
lv_anim_set_values(&a_new, -lv_disp_get_hor_res(d), 0);
lv_anim_set_values(&a_new, -lv_display_get_horizontal_resolution(d), 0);
break;
case LV_SCR_LOAD_ANIM_OVER_TOP:
lv_anim_set_exec_cb(&a_new, set_y_anim);
lv_anim_set_values(&a_new, lv_disp_get_ver_res(d), 0);
lv_anim_set_values(&a_new, lv_display_get_vertical_resolution(d), 0);
break;
case LV_SCR_LOAD_ANIM_OVER_BOTTOM:
lv_anim_set_exec_cb(&a_new, set_y_anim);
lv_anim_set_values(&a_new, -lv_disp_get_ver_res(d), 0);
lv_anim_set_values(&a_new, -lv_display_get_vertical_resolution(d), 0);
break;
case LV_SCR_LOAD_ANIM_MOVE_LEFT:
lv_anim_set_exec_cb(&a_new, set_x_anim);
lv_anim_set_values(&a_new, lv_disp_get_hor_res(d), 0);
lv_anim_set_values(&a_new, lv_display_get_horizontal_resolution(d), 0);
lv_anim_set_exec_cb(&a_old, set_x_anim);
lv_anim_set_values(&a_old, 0, -lv_disp_get_hor_res(d));
lv_anim_set_values(&a_old, 0, -lv_display_get_horizontal_resolution(d));
break;
case LV_SCR_LOAD_ANIM_MOVE_RIGHT:
lv_anim_set_exec_cb(&a_new, set_x_anim);
lv_anim_set_values(&a_new, -lv_disp_get_hor_res(d), 0);
lv_anim_set_values(&a_new, -lv_display_get_horizontal_resolution(d), 0);
lv_anim_set_exec_cb(&a_old, set_x_anim);
lv_anim_set_values(&a_old, 0, lv_disp_get_hor_res(d));
lv_anim_set_values(&a_old, 0, lv_display_get_horizontal_resolution(d));
break;
case LV_SCR_LOAD_ANIM_MOVE_TOP:
lv_anim_set_exec_cb(&a_new, set_y_anim);
lv_anim_set_values(&a_new, lv_disp_get_ver_res(d), 0);
lv_anim_set_values(&a_new, lv_display_get_vertical_resolution(d), 0);
lv_anim_set_exec_cb(&a_old, set_y_anim);
lv_anim_set_values(&a_old, 0, -lv_disp_get_ver_res(d));
lv_anim_set_values(&a_old, 0, -lv_display_get_vertical_resolution(d));
break;
case LV_SCR_LOAD_ANIM_MOVE_BOTTOM:
lv_anim_set_exec_cb(&a_new, set_y_anim);
lv_anim_set_values(&a_new, -lv_disp_get_ver_res(d), 0);
lv_anim_set_values(&a_new, -lv_display_get_vertical_resolution(d), 0);
lv_anim_set_exec_cb(&a_old, set_y_anim);
lv_anim_set_values(&a_old, 0, lv_disp_get_ver_res(d));
lv_anim_set_values(&a_old, 0, lv_display_get_vertical_resolution(d));
break;
case LV_SCR_LOAD_ANIM_FADE_IN:
lv_anim_set_exec_cb(&a_new, opa_scale_anim);
@@ -630,19 +630,19 @@ void lv_scr_load_anim(lv_obj_t * new_scr, lv_scr_load_anim_t anim_type, uint32_t
break;
case LV_SCR_LOAD_ANIM_OUT_LEFT:
lv_anim_set_exec_cb(&a_old, set_x_anim);
lv_anim_set_values(&a_old, 0, -lv_disp_get_hor_res(d));
lv_anim_set_values(&a_old, 0, -lv_display_get_horizontal_resolution(d));
break;
case LV_SCR_LOAD_ANIM_OUT_RIGHT:
lv_anim_set_exec_cb(&a_old, set_x_anim);
lv_anim_set_values(&a_old, 0, lv_disp_get_hor_res(d));
lv_anim_set_values(&a_old, 0, lv_display_get_horizontal_resolution(d));
break;
case LV_SCR_LOAD_ANIM_OUT_TOP:
lv_anim_set_exec_cb(&a_old, set_y_anim);
lv_anim_set_values(&a_old, 0, -lv_disp_get_ver_res(d));
lv_anim_set_values(&a_old, 0, -lv_display_get_vertical_resolution(d));
break;
case LV_SCR_LOAD_ANIM_OUT_BOTTOM:
lv_anim_set_exec_cb(&a_old, set_y_anim);
lv_anim_set_values(&a_old, 0, lv_disp_get_ver_res(d));
lv_anim_set_values(&a_old, 0, lv_display_get_vertical_resolution(d));
break;
}
@@ -656,35 +656,35 @@ void lv_scr_load_anim(lv_obj_t * new_scr, lv_scr_load_anim_t anim_type, uint32_t
* OTHERS
*--------------------*/
void lv_disp_add_event(lv_disp_t * disp, lv_event_cb_t event_cb, lv_event_code_t filter, void * user_data)
void lv_display_add_event(lv_display_t * disp, lv_event_cb_t event_cb, lv_event_code_t filter, void * user_data)
{
LV_ASSERT_NULL(disp);
lv_event_add(&disp->event_list, event_cb, filter, user_data);
}
uint32_t lv_disp_get_event_count(lv_disp_t * disp)
uint32_t lv_display_get_event_count(lv_display_t * disp)
{
LV_ASSERT_NULL(disp);
return lv_event_get_count(&disp->event_list);
}
lv_event_dsc_t * lv_disp_get_event_dsc(lv_disp_t * disp, uint32_t index)
lv_event_dsc_t * lv_display_get_event_dsc(lv_display_t * disp, uint32_t index)
{
LV_ASSERT_NULL(disp);
return lv_event_get_dsc(&disp->event_list, index);
}
bool lv_disp_remove_event(lv_disp_t * disp, uint32_t index)
bool lv_display_remove_event(lv_display_t * disp, uint32_t index)
{
LV_ASSERT_NULL(disp);
return lv_event_remove(&disp->event_list, index);
}
lv_res_t lv_disp_send_event(lv_disp_t * disp, lv_event_code_t code, void * param)
lv_result_t lv_display_send_event(lv_display_t * disp, lv_event_code_t code, void * param)
{
lv_event_t e;
@@ -693,19 +693,19 @@ lv_res_t lv_disp_send_event(lv_disp_t * disp, lv_event_code_t code, void * param
e.current_target = disp;
e.original_target = disp;
e.param = param;
lv_res_t res;
lv_result_t res;
res = lv_event_send(&disp->event_list, &e, true);
if(res != LV_RES_OK) return res;
if(res != LV_RESULT_OK) return res;
res = lv_event_send(&disp->event_list, &e, false);
if(res != LV_RES_OK) return res;
if(res != LV_RESULT_OK) return res;
return res;
}
void lv_disp_set_rotation(lv_disp_t * disp, lv_disp_rotation_t rotation, bool sw_rotate)
void lv_display_set_rotation(lv_display_t * disp, lv_display_rotation_t rotation, bool sw_rotate)
{
if(disp == NULL) disp = lv_disp_get_default();
if(disp == NULL) disp = lv_display_get_default();
if(disp == NULL) return;
disp->rotation = rotation;
@@ -713,16 +713,16 @@ void lv_disp_set_rotation(lv_disp_t * disp, lv_disp_rotation_t rotation, bool sw
update_resolution(disp);
}
lv_disp_rotation_t lv_disp_get_rotation(lv_disp_t * disp)
lv_display_rotation_t lv_display_get_rotation(lv_display_t * disp)
{
if(disp == NULL) disp = lv_disp_get_default();
if(disp == NULL) return LV_DISP_ROTATION_0;
if(disp == NULL) disp = lv_display_get_default();
if(disp == NULL) return LV_DISPLAY_ROTATION_0;
return disp->rotation;
}
void lv_disp_set_theme(lv_disp_t * disp, lv_theme_t * th)
void lv_display_set_theme(lv_display_t * disp, lv_theme_t * th)
{
if(!disp) disp = lv_disp_get_default();
if(!disp) disp = lv_display_get_default();
if(!disp) {
LV_LOG_WARN("no display registered");
return;
@@ -738,42 +738,42 @@ void lv_disp_set_theme(lv_disp_t * disp, lv_theme_t * th)
}
}
lv_theme_t * lv_disp_get_theme(lv_disp_t * disp)
lv_theme_t * lv_display_get_theme(lv_display_t * disp)
{
if(disp == NULL) disp = lv_disp_get_default();
if(disp == NULL) disp = lv_display_get_default();
return disp->theme;
}
uint32_t lv_disp_get_inactive_time(const lv_disp_t * disp)
uint32_t lv_display_get_inactive_time(const lv_display_t * disp)
{
if(disp) return lv_tick_elaps(disp->last_activity_time);
lv_disp_t * d;
lv_display_t * d;
uint32_t t = UINT32_MAX;
d = lv_disp_get_next(NULL);
d = lv_display_get_next(NULL);
while(d) {
uint32_t elaps = lv_tick_elaps(d->last_activity_time);
t = LV_MIN(t, elaps);
d = lv_disp_get_next(d);
d = lv_display_get_next(d);
}
return t;
}
void lv_disp_trig_activity(lv_disp_t * disp)
void lv_display_trig_activity(lv_display_t * disp)
{
if(!disp) disp = lv_disp_get_default();
if(!disp) disp = lv_display_get_default();
if(!disp) {
LV_LOG_WARN("lv_disp_trig_activity: no display registered");
LV_LOG_WARN("lv_display_trig_activity: no display registered");
return;
}
disp->last_activity_time = lv_tick_get();
}
void lv_disp_enable_invalidation(lv_disp_t * disp, bool en)
void lv_display_enable_invalidation(lv_display_t * disp, bool en)
{
if(!disp) disp = lv_disp_get_default();
if(!disp) disp = lv_display_get_default();
if(!disp) {
LV_LOG_WARN("no display registered");
return;
@@ -782,9 +782,9 @@ void lv_disp_enable_invalidation(lv_disp_t * disp, bool en)
disp->inv_en_cnt += en ? 1 : -1;
}
bool lv_disp_is_invalidation_enabled(lv_disp_t * disp)
bool lv_display_is_invalidation_enabled(lv_display_t * disp)
{
if(!disp) disp = lv_disp_get_default();
if(!disp) disp = lv_display_get_default();
if(!disp) {
LV_LOG_WARN("no display registered");
return false;
@@ -793,39 +793,39 @@ bool lv_disp_is_invalidation_enabled(lv_disp_t * disp)
return (disp->inv_en_cnt > 0);
}
lv_timer_t * _lv_disp_get_refr_timer(lv_disp_t * disp)
lv_timer_t * _lv_display_get_refr_timer(lv_display_t * disp)
{
if(!disp) disp = lv_disp_get_default();
if(!disp) disp = lv_display_get_default();
if(!disp) return NULL;
return disp->refr_timer;
}
void lv_disp_set_user_data(lv_disp_t * disp, void * user_data)
void lv_display_set_user_data(lv_display_t * disp, void * user_data)
{
if(!disp) disp = lv_disp_get_default();
if(!disp) disp = lv_display_get_default();
if(!disp) return;
disp->user_data = user_data;
}
void lv_disp_set_driver_data(lv_disp_t * disp, void * driver_data)
void lv_display_set_driver_data(lv_display_t * disp, void * driver_data)
{
if(!disp) disp = lv_disp_get_default();
if(!disp) disp = lv_display_get_default();
if(!disp) return;
disp->driver_data = driver_data;
}
void * lv_disp_get_user_data(lv_disp_t * disp)
void * lv_display_get_user_data(lv_display_t * disp)
{
if(!disp) disp = lv_disp_get_default();
if(!disp) disp = lv_display_get_default();
if(!disp) return NULL;
return disp->user_data;
}
void * lv_disp_get_driver_data(lv_disp_t * disp)
void * lv_display_get_driver_data(lv_display_t * disp)
{
if(!disp) disp = lv_disp_get_default();
if(!disp) disp = lv_display_get_default();
if(!disp) return NULL;
return disp->driver_data;
@@ -835,10 +835,10 @@ void * lv_disp_get_driver_data(lv_disp_t * disp)
* STATIC FUNCTIONS
**********************/
static void update_resolution(lv_disp_t * disp)
static void update_resolution(lv_display_t * disp)
{
lv_coord_t hor_res = lv_disp_get_hor_res(disp);
lv_coord_t ver_res = lv_disp_get_ver_res(disp);
lv_coord_t hor_res = lv_display_get_horizontal_resolution(disp);
lv_coord_t ver_res = lv_display_get_vertical_resolution(disp);
lv_area_t prev_coords;
lv_obj_get_coords(disp->sys_layer, &prev_coords);
@@ -868,7 +868,7 @@ static void update_resolution(lv_disp_t * disp)
lv_obj_tree_walk(NULL, invalidate_layout_cb, NULL);
lv_disp_send_event(disp, LV_EVENT_RESOLUTION_CHANGED, NULL);
lv_display_send_event(disp, LV_EVENT_RESOLUTION_CHANGED, NULL);
}
static lv_obj_tree_walk_res_t invalidate_layout_cb(lv_obj_t * obj, void * user_data)
@@ -880,7 +880,7 @@ static lv_obj_tree_walk_res_t invalidate_layout_cb(lv_obj_t * obj, void * user_d
static void scr_load_internal(lv_obj_t * scr)
{
lv_disp_t * d = lv_obj_get_disp(scr);
lv_display_t * d = lv_obj_get_disp(scr);
if(!d) return; /*Shouldn't happen, just to be sure*/
lv_obj_t * old_scr = d->act_scr;
@@ -898,7 +898,7 @@ static void scr_load_internal(lv_obj_t * scr)
static void scr_load_anim_start(lv_anim_t * a)
{
lv_disp_t * d = lv_obj_get_disp(a->var);
lv_display_t * d = lv_obj_get_disp(a->var);
d->prev_scr = lv_scr_act();
d->act_scr = a->var;
@@ -923,7 +923,7 @@ static void set_y_anim(void * obj, int32_t v)
static void scr_anim_ready(lv_anim_t * a)
{
lv_disp_t * d = lv_obj_get_disp(a->var);
lv_display_t * d = lv_obj_get_disp(a->var);
lv_obj_send_event(d->act_scr, LV_EVENT_SCREEN_LOADED, NULL);
lv_obj_send_event(d->prev_scr, LV_EVENT_SCREEN_UNLOADED, NULL);
@@ -948,7 +948,7 @@ static bool is_out_anim(lv_scr_load_anim_t anim_type)
static void disp_event_cb(lv_event_t * e)
{
lv_event_code_t code = lv_event_get_code(e);
lv_disp_t * disp = lv_event_get_target(e);
lv_display_t * disp = lv_event_get_target(e);
switch(code) {
case LV_EVENT_REFR_REQUEST:
if(disp->refr_timer) lv_timer_resume(disp->refr_timer);

158
src/disp/lv_disp.h → src/display/lv_display.h
View File

@@ -3,8 +3,8 @@
*
*/
#ifndef LV_DISP_H
#define LV_DISP_H
#ifndef LV_DISPLAY_H
#define LV_DISPLAY_H
#ifdef __cplusplus
extern "C" {
@@ -32,36 +32,36 @@ extern "C" {
struct _lv_obj_t;
struct _lv_theme_t;
struct _lv_disp_t;
typedef struct _lv_disp_t lv_disp_t;
struct _lv_display_t;
typedef struct _lv_display_t lv_display_t;
typedef enum {
LV_DISP_ROTATION_0 = 0,
LV_DISP_ROTATION_90,
LV_DISP_ROTATION_180,
LV_DISP_ROTATION_270
} lv_disp_rotation_t;
LV_DISPLAY_ROTATION_0 = 0,
LV_DISPLAY_ROTATION_90,
LV_DISPLAY_ROTATION_180,
LV_DISPLAY_ROTATION_270
} lv_display_rotation_t;
typedef enum {
/**
* Use the buffer(s) to render the screen is smaller parts.
* This way the buffers can be smaller then the display to save RAM. At least 1/10 screen size buffer(s) are recommended.
*/
LV_DISP_RENDER_MODE_PARTIAL,
LV_DISPLAY_RENDER_MODE_PARTIAL,
/**
* The buffer(s) has to be screen sized and LVGL will render into the correct location of the buffer.
* This way the buffer always contain the whole image. Only the changed ares will be updated.
* With 2 buffers the buffers' content are kept in sync automatically and in flush_cb only address change is required.
*/
LV_DISP_RENDER_MODE_DIRECT,
LV_DISPLAY_RENDER_MODE_DIRECT,
/**
* Always redraw the whole screen even if only one pixel has been changed.
* With 2 buffers in flush_cb only and address change is required.
*/
LV_DISP_RENDER_MODE_FULL,
} lv_disp_render_mode_t;
LV_DISPLAY_RENDER_MODE_FULL,
} lv_display_render_mode_t;
typedef enum {
@@ -84,7 +84,7 @@ typedef enum {
} lv_scr_load_anim_t;
typedef void (*lv_disp_flush_cb_t)(struct _lv_disp_t * disp, const lv_area_t * area, uint8_t * px_map);
typedef void (*lv_display_flush_cb_t)(struct _lv_display_t * disp, const lv_area_t * area, uint8_t * px_map);
/**********************
* GLOBAL PROTOTYPES
@@ -96,32 +96,32 @@ typedef void (*lv_disp_flush_cb_t)(struct _lv_disp_t * disp, const lv_area_t * a
* @param ver_res vertical resolution in pixels
* @return pointer to a display object or `NULL` on error
*/
lv_disp_t * lv_disp_create(lv_coord_t hor_res, lv_coord_t ver_res);
lv_display_t * lv_display_create(lv_coord_t hor_res, lv_coord_t ver_res);
/**
* Remove a display
* @param disp pointer to display
*/
void lv_disp_remove(lv_disp_t * disp);
void lv_display_remove(lv_display_t * disp);
/**
* Set a default display. The new screens will be created on it by default.
* @param disp pointer to a display
*/
void lv_disp_set_default(lv_disp_t * disp);
void lv_display_set_default(lv_display_t * disp);
/**
* Get the default display
* @return pointer to the default display
*/
lv_disp_t * lv_disp_get_default(void);
lv_display_t * lv_display_get_default(void);
/**
* Get the next display.
* @param disp pointer to the current display. NULL to initialize.
* @return the next display or NULL if no more. Gives the first display when the parameter is NULL.
*/
lv_disp_t * lv_disp_get_next(lv_disp_t * disp);
lv_display_t * lv_display_get_next(lv_display_t * disp);
/*---------------------
* RESOLUTION
@@ -130,12 +130,12 @@ lv_disp_t * lv_disp_get_next(lv_disp_t * disp);
/**
* Sets the resolution of a display. `LV_EVENT_RESOLUTION_CHANGED` event will be sent.
* Here the native resolution of the device should be set. If the display will be rotated later with
* `lv_disp_set_rotation` LVGL will swap the hor. and ver. resolution automatically.
* `lv_display_set_rotation` LVGL will swap the hor. and ver. resolution automatically.
* @param disp pointer to a display
* @param hor_res the new horizontal resolution
* @param ver_res the new vertical resolution
*/
void lv_disp_set_res(lv_disp_t * disp, lv_coord_t hor_res, lv_coord_t ver_res);
void lv_display_set_resolution(lv_display_t * disp, lv_coord_t hor_res, lv_coord_t ver_res);
/**
* It's not mandatory to use the whole display for LVGL, however in some cases physical resolution is important.
@@ -145,7 +145,7 @@ void lv_disp_set_res(lv_disp_t * disp, lv_coord_t hor_res, lv_coord_t ver_res);
* @param hor_res the new physical horizontal resolution, or -1 to assume it's the same as the normal hor. res.
* @param ver_res the new physical vertical resolution, or -1 to assume it's the same as the normal hor. res.
*/
void lv_disp_set_physical_res(lv_disp_t * disp, lv_coord_t hor_res, lv_coord_t ver_res);
void lv_display_set_physical_resolution(lv_display_t * disp, lv_coord_t hor_res, lv_coord_t ver_res);
/**
* If physical resolution is not the same as the normal resolution
@@ -154,16 +154,16 @@ void lv_disp_set_physical_res(lv_disp_t * disp, lv_coord_t hor_res, lv_coord_t v
* @param x X offset
* @param y Y offset
*/
void lv_disp_set_offset(lv_disp_t * disp, lv_coord_t x, lv_coord_t y);
void lv_display_set_offset(lv_display_t * disp, lv_coord_t x, lv_coord_t y);
/**
* Set the rotation of this display. LVGL will swap the horizontal and vertical resolutions internally.
* @param disp pointer to a display (NULL to use the default display)
* @param rotation `LV_DISP_ROTATION_0/90/180/270`
* @param rotation `LV_DISPLAY_ROTATION_0/90/180/270`
* @param sw_rotate true: make LVGL rotate the rendered image;
* false: the display driver should rotate the rendered image
*/
void lv_disp_set_rotation(lv_disp_t * disp, lv_disp_rotation_t rotation, bool sw_rotate);
void lv_display_set_rotation(lv_display_t * disp, lv_display_rotation_t rotation, bool sw_rotate);
/**
* Set the DPI (dot per inch) of the display.
@@ -171,63 +171,63 @@ void lv_disp_set_rotation(lv_disp_t * disp, lv_disp_rotation_t rotation, bool sw
* @param disp pointer to a display
* @param dpi the new DPI
*/
void lv_disp_set_dpi(lv_disp_t * disp, lv_coord_t dpi);
void lv_display_set_dpi(lv_display_t * disp, lv_coord_t dpi);
/**
* Get the horizontal resolution of a display.
* @param disp pointer to a display (NULL to use the default display)
* @return the horizontal resolution of the display.
*/
lv_coord_t lv_disp_get_hor_res(const lv_disp_t * disp);
lv_coord_t lv_display_get_horizontal_resolution(const lv_display_t * disp);
/**
* Get the vertical resolution of a display
* @param disp pointer to a display (NULL to use the default display)
* @return the vertical resolution of the display
*/
lv_coord_t lv_disp_get_ver_res(const lv_disp_t * disp);
lv_coord_t lv_display_get_vertical_resolution(const lv_display_t * disp);
/**
* Get the physical horizontal resolution of a display
* @param disp pointer to a display (NULL to use the default display)
* @return the physical horizontal resolution of the display
*/
lv_coord_t lv_disp_get_physical_hor_res(const lv_disp_t * disp);
lv_coord_t lv_display_get_physical_horizontal_resolution(const lv_display_t * disp);
/**
* Get the physical vertical resolution of a display
* @param disp pointer to a display (NULL to use the default display)
* @return the physical vertical resolution of the display
*/
lv_coord_t lv_disp_get_physical_ver_res(const lv_disp_t * disp);
lv_coord_t lv_display_get_physical_vertical_resolution(const lv_display_t * disp);
/**
* Get the horizontal offset from the full / physical display
* @param disp pointer to a display (NULL to use the default display)
* @return the horizontal offset from the physical display
*/
lv_coord_t lv_disp_get_offset_x(const lv_disp_t * disp);
lv_coord_t lv_display_get_offset_x(const lv_display_t * disp);
/**
* Get the vertical offset from the full / physical display
* @param disp pointer to a display (NULL to use the default display)
* @return the horizontal offset from the physical display
*/
lv_coord_t lv_disp_get_offset_y(const lv_disp_t * disp);
lv_coord_t lv_display_get_offset_y(const lv_display_t * disp);
/**
* Get the current rotation of this display.
* @param disp pointer to a display (NULL to use the default display)
* @return the current rotation
*/
lv_disp_rotation_t lv_disp_get_rotation(lv_disp_t * disp);
lv_display_rotation_t lv_display_get_rotation(lv_display_t * disp);
/**
* Get the DPI of the display
* @param disp pointer to a display (NULL to use the default display)
* @return dpi of the display
*/
lv_coord_t lv_disp_get_dpi(const lv_disp_t * disp);
lv_coord_t lv_display_get_dpi(const lv_display_t * disp);
/*---------------------
* BUFFERING
@@ -238,17 +238,17 @@ lv_coord_t lv_disp_get_dpi(const lv_disp_t * disp);
* @param disp pointer to a display
* @param buf1 first buffer
* @param buf2 second buffer (can be `NULL`)
* @param render_mode LV_DISP_RENDER_MODE_PARTIAL/DIRECT/FULL
* @param render_mode LV_DISPLAY_RENDER_MODE_PARTIAL/DIRECT/FULL
*/
void lv_disp_set_draw_buffers(lv_disp_t * disp, void * buf1, void * buf2, uint32_t buf_size_in_bytes,
lv_disp_render_mode_t render_mode);
void lv_display_set_draw_buffers(lv_display_t * disp, void * buf1, void * buf2, uint32_t buf_size_in_bytes,
lv_display_render_mode_t render_mode);
/**
* Set the flush callback which will be called to copy the rendered image to the display.
* @param disp pointer to a display
* @param flush_cb the flush callback (`px_map` contains the rendered image as raw pixel map and it should be copied to `area` on the display)
*/
void lv_disp_set_flush_cb(lv_disp_t * disp, lv_disp_flush_cb_t flush_cb);
void lv_display_set_flush_cb(lv_display_t * disp, lv_display_flush_cb_t flush_cb);
/**
* Set the color format of the display.
* If set to other than `LV_COLOR_FORMAT_NATIVE` the layer's `buffer_convert` function will be used
@@ -258,28 +258,28 @@ void lv_disp_set_flush_cb(lv_disp_t * disp, lv_disp_flush_cb_t flush_cb);
* `LV_COLOR_FORMAT_NATIVE_REVERSE` to change endianness.
*
*/
void lv_disp_set_color_format(lv_disp_t * disp, lv_color_format_t color_format);
void lv_display_set_color_format(lv_display_t * disp, lv_color_format_t color_format);
/**
* Get the color format of the display
* @param disp pointer to a display
* @return the color format
*/
lv_color_format_t lv_disp_get_color_format(lv_disp_t * disp);
lv_color_format_t lv_display_get_color_format(lv_display_t * disp);
/**
* Enable anti-aliasing for the render engine
* @param disp pointer to a display
* @param en true/false
*/
void lv_disp_set_antialiasing(lv_disp_t * disp, bool en);
void lv_display_set_antialiasing(lv_display_t * disp, bool en);
/**
* Get if anti-aliasing is enabled for a display or not
* @param disp pointer to a display (NULL to use the default display)
* @return true/false
*/
bool lv_disp_get_antialiasing(lv_disp_t * disp);
bool lv_display_get_antialiasing(lv_display_t * disp);
//! @cond Doxygen_Suppress
@@ -288,7 +288,7 @@ bool lv_disp_get_antialiasing(lv_disp_t * disp);
* Call from the display driver when the flushing is finished
* @param disp pointer to display whose `flush_cb` was called
*/
LV_ATTRIBUTE_FLUSH_READY void lv_disp_flush_ready(lv_disp_t * disp);
LV_ATTRIBUTE_FLUSH_READY void lv_display_flush_ready(lv_display_t * disp);
/**
* Tell if it's the last area of the refreshing process.
@@ -297,12 +297,12 @@ LV_ATTRIBUTE_FLUSH_READY void lv_disp_flush_ready(lv_disp_t * disp);
* @return true: it's the last area to flush;
* false: there are other areas too which will be refreshed soon
*/
LV_ATTRIBUTE_FLUSH_READY bool lv_disp_flush_is_last(lv_disp_t * disp);
LV_ATTRIBUTE_FLUSH_READY bool lv_display_flush_is_last(lv_display_t * disp);
//! @endcond
bool lv_disp_is_double_buffered(lv_disp_t * disp);
bool lv_display_is_double_buffered(lv_display_t * disp);
/*---------------------
* SCREENS
@@ -314,7 +314,7 @@ bool lv_disp_is_double_buffered(lv_disp_t * disp);
* (NULL to use the default screen)
* @return pointer to the active screen object (loaded by 'lv_scr_load()')
*/
struct _lv_obj_t * lv_disp_get_scr_act(lv_disp_t * disp);
struct _lv_obj_t * lv_display_get_scr_act(lv_display_t * disp);
/**
* Return with a pointer to the previous screen. Only used during screen transitions.
@@ -322,27 +322,27 @@ struct _lv_obj_t * lv_disp_get_scr_act(lv_disp_t * disp);
* (NULL to use the default screen)
* @return pointer to the previous screen object or NULL if not used now
*/
struct _lv_obj_t * lv_disp_get_scr_prev(lv_disp_t * disp);
struct _lv_obj_t * lv_display_get_scr_prev(lv_display_t * disp);
/**
* Make a screen active
* @param scr pointer to a screen
*/
void lv_disp_load_scr(struct _lv_obj_t * scr);
void lv_display_load_scr(struct _lv_obj_t * scr);
/**
* Return the top layer. The top layer is the same on all screens and it is above the normal screen layer.
* @param disp pointer to display which top layer should be get. (NULL to use the default screen)
* @return pointer to the top layer object
*/
struct _lv_obj_t * lv_disp_get_layer_top(lv_disp_t * disp);
struct _lv_obj_t * lv_display_get_layer_top(lv_display_t * disp);
/**
* Return the sys. layer. The system layer is the same on all screen and it is above the normal screen and the top layer.
* @param disp pointer to display which sys. layer should be retrieved. (NULL to use the default screen)
* @return pointer to the sys layer object
*/
struct _lv_obj_t * lv_disp_get_layer_sys(lv_disp_t * disp);
struct _lv_obj_t * lv_display_get_layer_sys(lv_display_t * disp);
/**
@@ -351,7 +351,7 @@ struct _lv_obj_t * lv_disp_get_layer_sys(lv_disp_t * disp);
* @param disp pointer to display (NULL to use the default screen)
* @return pointer to the bottom layer object
*/
struct _lv_obj_t * lv_disp_get_layer_bottom(lv_disp_t * disp);
struct _lv_obj_t * lv_display_get_layer_bottom(lv_display_t * disp);
/**
@@ -371,7 +371,7 @@ void lv_scr_load_anim(struct _lv_obj_t * scr, lv_scr_load_anim_t anim_type, uint
*/
static inline struct _lv_obj_t * lv_scr_act(void)
{
return lv_disp_get_scr_act(lv_disp_get_default());
return lv_display_get_scr_act(lv_display_get_default());
}
/**
@@ -380,7 +380,7 @@ static inline struct _lv_obj_t * lv_scr_act(void)
*/
static inline struct _lv_obj_t * lv_layer_top(void)
{
return lv_disp_get_layer_top(lv_disp_get_default());
return lv_display_get_layer_top(lv_display_get_default());
}
/**
@@ -389,7 +389,7 @@ static inline struct _lv_obj_t * lv_layer_top(void)
*/
static inline struct _lv_obj_t * lv_layer_sys(void)
{
return lv_disp_get_layer_sys(lv_disp_get_default());
return lv_display_get_layer_sys(lv_display_get_default());
}
/**
@@ -398,7 +398,7 @@ static inline struct _lv_obj_t * lv_layer_sys(void)
*/
static inline struct _lv_obj_t * lv_layer_bottom(void)
{
return lv_disp_get_layer_bottom(lv_disp_get_default());
return lv_display_get_layer_bottom(lv_display_get_default());
}
/**
@@ -407,7 +407,7 @@ static inline struct _lv_obj_t * lv_layer_bottom(void)
*/
static inline void lv_scr_load(struct _lv_obj_t * scr)
{
lv_disp_load_scr(scr);
lv_display_load_scr(scr);
}
@@ -422,63 +422,63 @@ static inline void lv_scr_load(struct _lv_obj_t * scr)
* @param filter event code to react or `LV_EVENT_ALL`
* @param user_data optional user_data
*/
void lv_disp_add_event(lv_disp_t * disp, lv_event_cb_t event_cb, lv_event_code_t filter, void * user_data);
void lv_display_add_event(lv_display_t * disp, lv_event_cb_t event_cb, lv_event_code_t filter, void * user_data);
uint32_t lv_disp_get_event_count(lv_disp_t * disp);
uint32_t lv_display_get_event_count(lv_display_t * disp);
lv_event_dsc_t * lv_disp_get_event_dsc(lv_disp_t * disp, uint32_t index);
lv_event_dsc_t * lv_display_get_event_dsc(lv_display_t * disp, uint32_t index);
bool lv_disp_remove_event(lv_disp_t * disp, uint32_t index);
bool lv_display_remove_event(lv_display_t * disp, uint32_t index);
/**
* Send amn event to a display
* @param disp pointer to a display
* @param code an event code. LV_EVENT_...
* @param param optional param
* @return LV_RES_OK: disp wasn't deleted in the event.
* @return LV_RESULT_OK: disp wasn't deleted in the event.
*/
lv_res_t lv_disp_send_event(lv_disp_t * disp, lv_event_code_t code, void * param);
lv_result_t lv_display_send_event(lv_display_t * disp, lv_event_code_t code, void * param);
/**
* Set the theme of a display. If there are no user created widgets yet the screens' theme will be updated
* @param disp pointer to a display
* @param th pointer to a theme
*/
void lv_disp_set_theme(lv_disp_t * disp, struct _lv_theme_t * th);
void lv_display_set_theme(lv_display_t * disp, struct _lv_theme_t * th);
/**
* Get the theme of a display
* @param disp pointer to a display
* @return the display's theme (can be NULL)
*/
struct _lv_theme_t * lv_disp_get_theme(lv_disp_t * disp);
struct _lv_theme_t * lv_display_get_theme(lv_display_t * disp);
/**
* Get elapsed time since last user activity on a display (e.g. click)
* @param disp pointer to a display (NULL to get the overall smallest inactivity)
* @return elapsed ticks (milliseconds) since the last activity
*/
uint32_t lv_disp_get_inactive_time(const lv_disp_t * disp);
uint32_t lv_display_get_inactive_time(const lv_display_t * disp);
/**
* Manually trigger an activity on a display
* @param disp pointer to a display (NULL to use the default display)
*/
void lv_disp_trig_activity(lv_disp_t * disp);
void lv_display_trig_activity(lv_display_t * disp);
/**
* Temporarily enable and disable the invalidation of the display.
* @param disp pointer to a display (NULL to use the default display)
* @param en true: enable invalidation; false: invalidation
*/
void lv_disp_enable_invalidation(lv_disp_t * disp, bool en);
void lv_display_enable_invalidation(lv_display_t * disp, bool en);
/**
* Get display invalidation is enabled.
* @param disp pointer to a display (NULL to use the default display)
* @return return true if invalidation is enabled
*/
bool lv_disp_is_invalidation_enabled(lv_disp_t * disp);
bool lv_display_is_invalidation_enabled(lv_display_t * disp);
/**
* Get a pointer to the screen refresher timer to
@@ -486,12 +486,12 @@ bool lv_disp_is_invalidation_enabled(lv_disp_t * disp);
* @param disp pointer to a display
* @return pointer to the display refresher timer. (NULL on error)
*/
lv_timer_t * _lv_disp_get_refr_timer(lv_disp_t * disp);
lv_timer_t * _lv_display_get_refr_timer(lv_display_t * disp);
void lv_disp_set_user_data(lv_disp_t * disp, void * user_data);
void lv_disp_set_driver_data(lv_disp_t * disp, void * driver_data);
void * lv_disp_get_user_data(lv_disp_t * disp);
void * lv_disp_get_driver_data(lv_disp_t * disp);
void lv_display_set_user_data(lv_display_t * disp, void * user_data);
void lv_display_set_driver_data(lv_display_t * disp, void * driver_data);
void * lv_display_get_user_data(lv_display_t * disp);
void * lv_display_get_driver_data(lv_display_t * disp);
/**********************
* MACROS
@@ -506,14 +506,14 @@ void * lv_disp_get_driver_data(lv_disp_t * disp);
/**
* The horizontal resolution of the currently active display.
*/
#define LV_HOR_RES lv_disp_get_hor_res(lv_disp_get_default())
#define LV_HOR_RES lv_display_get_horizontal_resolution(lv_display_get_default())
#endif
#ifndef LV_VER_RES
/**
* The vertical resolution of the currently active display.
*/
#define LV_VER_RES lv_disp_get_ver_res(lv_disp_get_default())
#define LV_VER_RES lv_display_get_vertical_resolution(lv_display_get_default())
#endif
@@ -524,7 +524,7 @@ void * lv_disp_get_driver_data(lv_disp_t * disp);
* https://stackoverflow.com/questions/2025282/what-is-the-difference-between-px-dip-dp-and-sp
*/
#define _LV_DPX_CALC(dpi, n) ((n) == 0 ? 0 :LV_MAX((( (dpi) * (n) + 80) / 160), 1)) /*+80 for rounding*/
#define LV_DPX(n) _LV_DPX_CALC(lv_disp_get_dpi(NULL), n)
#define LV_DPX(n) _LV_DPX_CALC(lv_display_get_dpi(NULL), n)
/**
* Scale the given number of pixels (a distance or size) relative to a 160 DPI display
@@ -548,9 +548,9 @@ static inline lv_coord_t lv_dpx(lv_coord_t n)
* @param n the number of pixels to scale
* @return `n x current_dpi/160`
*/
static inline lv_coord_t lv_disp_dpx(const lv_disp_t * disp, lv_coord_t n)
static inline lv_coord_t lv_display_dpx(const lv_display_t * disp, lv_coord_t n)
{
return _LV_DPX_CALC(lv_disp_get_dpi(disp), n);
return _LV_DPX_CALC(lv_display_get_dpi(disp), n);
}
@@ -558,4 +558,4 @@ static inline lv_coord_t lv_disp_dpx(const lv_disp_t * disp, lv_coord_t n)
} /*extern "C"*/
#endif
#endif /*LV_DISP_H*/
#endif /*LV_DISPLAY_H*/

32
src/disp/lv_disp_private.h → src/display/lv_display_private.h
View File

@@ -1,10 +1,10 @@
/**
* @file lv_disp_private.h
* @file lv_display_private.h
*
*/
#ifndef LV_DISP_PRIVATE_H
#define LV_DISP_PRIVATE_H
#ifndef LV_DISPLAY_PRIVATE_H
#define LV_DISPLAY_PRIVATE_H
#ifdef __cplusplus
extern "C" {
@@ -15,7 +15,7 @@ extern "C" {
*********************/
#include "../core/lv_obj.h"
#include "../draw/lv_draw.h"
#include "lv_disp.h"
#include "lv_display.h"
/*********************
* DEFINES
@@ -28,9 +28,9 @@ extern "C" {
* TYPEDEFS
**********************/
struct _lv_disp_t;
struct _lv_display_t;
struct _lv_disp_t {
struct _lv_display_t {
/*---------------------
* Resolution
@@ -66,9 +66,9 @@ struct _lv_disp_t {
uint8_t * buf_act;
uint32_t buf_size_in_bytes;
/** MANDATORY: Write the internal buffer (draw_buf) to the display. 'lv_disp_flush_ready()' has to be
/** MANDATORY: Write the internal buffer (draw_buf) to the display. 'lv_display_flush_ready()' has to be
* called when finished*/
lv_disp_flush_cb_t flush_cb;
lv_display_flush_cb_t flush_cb;
/*1: flushing is in progress. (It can't be a bit field because when it's cleared from IRQ Read-Modify-Write issue might occur)*/
volatile int flushing;
@@ -78,7 +78,7 @@ struct _lv_disp_t {
volatile uint32_t last_area : 1; /*1: the last area is being rendered*/
volatile uint32_t last_part : 1; /*1: the last part of the current area is being rendered*/
lv_disp_render_mode_t render_mode;
lv_display_render_mode_t render_mode;
uint32_t antialiasing : 1; /**< 1: anti-aliasing is enabled on this display.*/
/** 1: The current screen rendering is in progress*/
@@ -96,8 +96,8 @@ struct _lv_disp_t {
* Layer
*--------------------*/
lv_layer_t * layer_head;
void (*layer_init)(struct _lv_disp_t * disp, lv_layer_t * layer);
void (*layer_deinit)(struct _lv_disp_t * disp, lv_layer_t * layer);
void (*layer_init)(struct _lv_display_t * disp, lv_layer_t * layer);
void (*layer_deinit)(struct _lv_display_t * disp, lv_layer_t * layer);
/*---------------------
* Screens
@@ -108,9 +108,9 @@ struct _lv_disp_t {
struct _lv_obj_t * act_scr; /**< Currently active screen on this display*/
struct _lv_obj_t * prev_scr; /**< Previous screen. Used during screen animations*/
struct _lv_obj_t * scr_to_load; /**< The screen prepared to load in lv_scr_load_anim*/
struct _lv_obj_t * bottom_layer; /**< @see lv_disp_get_layer_bottom*/
struct _lv_obj_t * top_layer; /**< @see lv_disp_get_layer_top*/
struct _lv_obj_t * sys_layer; /**< @see lv_disp_get_layer_sys*/
struct _lv_obj_t * bottom_layer; /**< @see lv_display_get_layer_bottom*/
struct _lv_obj_t * top_layer; /**< @see lv_display_get_layer_top*/
struct _lv_obj_t * sys_layer; /**< @see lv_display_get_layer_sys*/
uint32_t screen_cnt;
uint8_t draw_prev_over_act : 1;/** 1: Draw previous screen over active screen*/
uint8_t del_prev : 1; /** 1: Automatically delete the previous screen when the screen load animation is ready*/
@@ -126,7 +126,7 @@ struct _lv_disp_t {
lv_event_list_t event_list;
uint32_t sw_rotate : 1; /**< 1: use software rotation (slower)*/
uint32_t rotation : 2; /**< Element of @lv_disp_rotation_t*/
uint32_t rotation : 2; /**< Element of @lv_display_rotation_t*/
/**< The theme assigned to the screen*/
struct _lv_theme_t * theme;
@@ -153,4 +153,4 @@ struct _lv_disp_t {
} /*extern "C"*/
#endif
#endif /*LV_DISP_PRIVATE_H*/
#endif /*LV_DISPLAY_PRIVATE_H*/

14
src/draw/lv_draw.c
View File

@@ -8,7 +8,7 @@
*********************/
#include "lv_draw.h"
#include "sw/lv_draw_sw.h"
#include "../disp/lv_disp_private.h"
#include "../display/lv_display_private.h"
#include "../core/lv_global.h"
#include "../core/lv_refr.h"
#include "../stdlib/lv_string.h"
@@ -122,7 +122,7 @@ void lv_draw_dispatch(void)
{
LV_PROFILER_BEGIN;
bool one_taken = false;
lv_disp_t * disp = lv_disp_get_next(NULL);
lv_display_t * disp = lv_display_get_next(NULL);
while(disp) {
lv_layer_t * layer = disp->layer_head;
while(layer) {
@@ -134,12 +134,12 @@ void lv_draw_dispatch(void)
if(!one_taken) {
lv_draw_dispatch_request();
}
disp = lv_disp_get_next(disp);
disp = lv_display_get_next(disp);
}
LV_PROFILER_END;
}
bool lv_draw_dispatch_layer(struct _lv_disp_t * disp, lv_layer_t * layer)
bool lv_draw_dispatch_layer(struct _lv_display_t * disp, lv_layer_t * layer)
{
/*Remove the finished tasks first*/
lv_draw_task_t * t_prev = NULL;
@@ -269,8 +269,8 @@ lv_draw_task_t * lv_draw_get_next_available_task(lv_layer_t * layer, lv_draw_tas
LV_PROFILER_BEGIN;
/*If the first task is screen sized, there cannot be independent areas*/
if(layer->draw_task_head) {
lv_coord_t hor_res = lv_disp_get_hor_res(_lv_refr_get_disp_refreshing());
lv_coord_t ver_res = lv_disp_get_ver_res(_lv_refr_get_disp_refreshing());
lv_coord_t hor_res = lv_display_get_horizontal_resolution(_lv_refr_get_disp_refreshing());
lv_coord_t ver_res = lv_display_get_vertical_resolution(_lv_refr_get_disp_refreshing());
lv_draw_task_t * t = layer->draw_task_head;
if(t->state != LV_DRAW_TASK_STATE_QUEUED &&
t->area.x1 <= 0 && t->area.x2 >= hor_res - 1 &&
@@ -298,7 +298,7 @@ lv_draw_task_t * lv_draw_get_next_available_task(lv_layer_t * layer, lv_draw_tas
lv_layer_t * lv_draw_layer_create(lv_layer_t * parent_layer, lv_color_format_t color_format, const lv_area_t * area)
{
lv_disp_t * disp = _lv_refr_get_disp_refreshing();
lv_display_t * disp = _lv_refr_get_disp_refreshing();
lv_layer_t * new_layer = lv_malloc(sizeof(lv_layer_t));
LV_ASSERT_MALLOC(new_layer);
if(new_layer == NULL) return NULL;

6
src/draw/lv_draw.h
View File

@@ -16,7 +16,7 @@ extern "C" {
#include "../lv_conf_internal.h"
#include "../misc/lv_style.h"
#include "../misc/lv_txt.h"
#include "../misc/lv_text.h"
#include "../misc/lv_profiler.h"
#include "../misc/lv_cache.h"
#include "lv_image_decoder.h"
@@ -33,7 +33,7 @@ extern "C" {
**********************/
struct _lv_draw_image_dsc_t;
struct _lv_disp_t;
struct _lv_display_t;
typedef enum {
LV_DRAW_TASK_TYPE_FILL,
@@ -196,7 +196,7 @@ void lv_draw_finalize_task_creation(lv_layer_t * layer, lv_draw_task_t * t);
void lv_draw_dispatch(void);
bool lv_draw_dispatch_layer(struct _lv_disp_t * disp, lv_layer_t * layer);
bool lv_draw_dispatch_layer(struct _lv_display_t * disp, lv_layer_t * layer);
/**
* Wait for a new dispatch request.

8
src/draw/lv_draw_image.c
View File

@@ -7,7 +7,7 @@
* INCLUDES
*********************/
#include "lv_draw_image.h"
#include "../disp/lv_disp.h"
#include "../display/lv_display.h"
#include "../misc/lv_log.h"
#include "../misc/lv_math.h"
#include "../core/lv_refr.h"
@@ -43,7 +43,7 @@ void lv_draw_image_dsc_init(lv_draw_image_dsc_t * dsc)
lv_memzero(dsc, sizeof(lv_draw_image_dsc_t));
dsc->recolor = lv_color_black();
dsc->opa = LV_OPA_COVER;
dsc->zoom = LV_ZOOM_NONE;
dsc->zoom = LV_SCALE_NONE;
dsc->antialias = LV_COLOR_DEPTH > 8 ? 1 : 0;
}
@@ -77,8 +77,8 @@ void lv_draw_image(lv_layer_t * layer, const lv_draw_image_dsc_t * dsc, const lv
lv_draw_image_dsc_t * new_image_dsc = lv_malloc(sizeof(*dsc));
lv_memcpy(new_image_dsc, dsc, sizeof(*dsc));
lv_res_t res = lv_image_decoder_get_info(new_image_dsc->src, &new_image_dsc->header);
if(res != LV_RES_OK) {
lv_result_t res = lv_image_decoder_get_info(new_image_dsc->src, &new_image_dsc->header);
if(res != LV_RESULT_OK) {
LV_LOG_WARN("Couldn't get info about the image");
lv_free(new_image_dsc);
return;

2
src/draw/lv_draw_image.h
View File

@@ -43,7 +43,7 @@ typedef struct _lv_draw_image_dsc_t {
lv_image_header_t header;
lv_coord_t angle;
lv_coord_t rotation;
lv_coord_t zoom;
lv_point_t pivot;

28
src/draw/lv_draw_label.c
View File

@@ -146,8 +146,8 @@ void lv_draw_label_interate_letters(lv_draw_unit_t * draw_unit, const lv_draw_la
else {
/*If EXPAND is enabled then not limit the text's width to the object's width*/
lv_point_t p;
lv_txt_get_size(&p, dsc->text, dsc->font, dsc->letter_space, dsc->line_space, LV_COORD_MAX,
dsc->flag);
lv_text_get_size(&p, dsc->text, dsc->font, dsc->letter_space, dsc->line_space, LV_COORD_MAX,
dsc->flag);
w = p.x;
}
@@ -184,14 +184,14 @@ void lv_draw_label_interate_letters(lv_draw_unit_t * draw_unit, const lv_draw_la
pos.y += dsc->hint->y;
}
uint32_t line_end = line_start + _lv_txt_get_next_line(&dsc->text[line_start], font, dsc->letter_space, w, NULL,
dsc->flag);
uint32_t line_end = line_start + _lv_text_get_next_line(&dsc->text[line_start], font, dsc->letter_space, w, NULL,
dsc->flag);
/*Go the first visible line*/
while(pos.y + line_height_font < draw_unit->clip_area->y1) {
/*Go to next line*/
line_start = line_end;
line_end += _lv_txt_get_next_line(&dsc->text[line_start], font, dsc->letter_space, w, NULL, dsc->flag);
line_end += _lv_text_get_next_line(&dsc->text[line_start], font, dsc->letter_space, w, NULL, dsc->flag);
pos.y += line_height;
/*Save at the threshold coordinate*/
@@ -206,14 +206,14 @@ void lv_draw_label_interate_letters(lv_draw_unit_t * draw_unit, const lv_draw_la
/*Align to middle*/
if(align == LV_TEXT_ALIGN_CENTER) {
line_width = lv_txt_get_width(&dsc->text[line_start], line_end - line_start, font, dsc->letter_space);
line_width = lv_text_get_width(&dsc->text[line_start], line_end - line_start, font, dsc->letter_space);
pos.x += (lv_area_get_width(coords) - line_width) / 2;
}
/*Align to the right*/
else if(align == LV_TEXT_ALIGN_RIGHT) {
line_width = lv_txt_get_width(&dsc->text[line_start], line_end - line_start, font, dsc->letter_space);
line_width = lv_text_get_width(&dsc->text[line_start], line_end - line_start, font, dsc->letter_space);
pos.x += lv_area_get_width(coords) - line_width;
}
@@ -259,17 +259,17 @@ void lv_draw_label_interate_letters(lv_draw_unit_t * draw_unit, const lv_draw_la
uint32_t logical_char_pos = 0;
if(sel_start != 0xFFFF && sel_end != 0xFFFF) {
#if LV_USE_BIDI
logical_char_pos = _lv_txt_encoded_get_char_id(dsc->text, line_start);
uint32_t t = _lv_txt_encoded_get_char_id(bidi_txt, i);
logical_char_pos = _lv_text_encoded_get_char_id(dsc->text, line_start);
uint32_t t = _lv_text_encoded_get_char_id(bidi_txt, i);
logical_char_pos += _lv_bidi_get_logical_pos(bidi_txt, NULL, line_end - line_start, base_dir, t, NULL);
#else
logical_char_pos = _lv_txt_encoded_get_char_id(dsc->text, line_start + i);
logical_char_pos = _lv_text_encoded_get_char_id(dsc->text, line_start + i);
#endif
}
uint32_t letter;
uint32_t letter_next;
_lv_txt_encoded_letter_next_2(bidi_txt, &letter, &letter_next, &i);
_lv_text_encoded_letter_next_2(bidi_txt, &letter, &letter_next, &i);
letter_w = lv_font_get_glyph_width(font, letter, letter_next);
@@ -327,20 +327,20 @@ void lv_draw_label_interate_letters(lv_draw_unit_t * draw_unit, const lv_draw_la
#endif
/*Go to next line*/
line_start = line_end;
line_end += _lv_txt_get_next_line(&dsc->text[line_start], font, dsc->letter_space, w, NULL, dsc->flag);
line_end += _lv_text_get_next_line(&dsc->text[line_start], font, dsc->letter_space, w, NULL, dsc->flag);
pos.x = coords->x1;
/*Align to middle*/
if(align == LV_TEXT_ALIGN_CENTER) {
line_width =
lv_txt_get_width(&dsc->text[line_start], line_end - line_start, font, dsc->letter_space);
lv_text_get_width(&dsc->text[line_start], line_end - line_start, font, dsc->letter_space);
pos.x += (lv_area_get_width(coords) - line_width) / 2;
}
/*Align to the right*/
else if(align == LV_TEXT_ALIGN_RIGHT) {
line_width =
lv_txt_get_width(&dsc->text[line_start], line_end - line_start, font, dsc->letter_space);
lv_text_get_width(&dsc->text[line_start], line_end - line_start, font, dsc->letter_space);
pos.x += lv_area_get_width(coords) - line_width;
}

2
src/draw/lv_draw_label.h
View File

@@ -15,7 +15,7 @@ extern "C" {
*********************/
#include "lv_draw.h"
#include "../misc/lv_bidi.h"
#include "../misc/lv_txt.h"
#include "../misc/lv_text.h"
#include "../misc/lv_color.h"
#include "../misc/lv_style.h"

6
src/draw/lv_draw_rect.c
View File

@@ -176,19 +176,19 @@ void lv_draw_rect(lv_layer_t * layer, const lv_draw_rect_dsc_t * dsc, const lv_a
lv_image_src_t src_type = lv_image_src_get_type(dsc->bg_image_src);
lv_res_t res = LV_RES_OK;
lv_result_t res = LV_RESULT_OK;
lv_image_header_t header;
if(src_type == LV_IMAGE_SRC_VARIABLE || src_type == LV_IMAGE_SRC_FILE) {
res = lv_image_decoder_get_info(dsc->bg_image_src, &header);
}
else if(src_type == LV_IMAGE_SRC_UNKNOWN) {
res = LV_RES_INV;
res = LV_RESULT_INVALID;
}
else {
lv_memzero(&header, sizeof(header));
}
if(res == LV_RES_OK) {
if(res == LV_RESULT_OK) {
lv_draw_bg_image_dsc_t * bg_image_dsc = lv_malloc(sizeof(lv_draw_bg_image_dsc_t));
t->draw_dsc = bg_image_dsc;
bg_image_dsc->base = dsc->base;

2
src/draw/lv_image_buf.c
View File

@@ -62,7 +62,7 @@ void lv_image_buf_free(lv_image_dsc_t * dsc)
void _lv_image_buf_get_transformed_area(lv_area_t * res, lv_coord_t w, lv_coord_t h, lv_coord_t angle, uint16_t zoom,
const lv_point_t * pivot)
{
if(angle == 0 && zoom == LV_ZOOM_NONE) {
if(angle == 0 && zoom == LV_SCALE_NONE) {
res->x1 = 0;
res->y1 = 0;
res->x2 = w - 1;

125
src/draw/lv_image_decoder.c
View File

@@ -32,9 +32,9 @@ typedef struct {
/**********************
* STATIC PROTOTYPES
**********************/
static lv_res_t decode_indexed_line(lv_color_format_t color_format, const lv_color32_t * palette, lv_coord_t x,
lv_coord_t y,
lv_coord_t w_px, const uint8_t * in, lv_color32_t * out);
static lv_result_t decode_indexed_line(lv_color_format_t color_format, const lv_color32_t * palette, lv_coord_t x,
lv_coord_t y,
lv_coord_t w_px, const uint8_t * in, lv_color32_t * out);
static uint32_t img_width_to_stride(lv_image_header_t * header);
static lv_fs_res_t fs_read_file_at(lv_fs_file_t * f, uint32_t pos, uint8_t * buff, uint32_t btr, uint32_t * br);
@@ -79,26 +79,26 @@ void _lv_image_decoder_init(void)
* Try the created image decoder one by one. Once one is able to get info that info will be used.
* @param src the image source. E.g. file name or variable.
* @param header the image info will be stored here
* @return LV_RES_OK: success; LV_RES_INV: wasn't able to get info about the image
* @return LV_RESULT_OK: success; LV_RESULT_INVALID: wasn't able to get info about the image
*/
lv_res_t lv_image_decoder_get_info(const void * src, lv_image_header_t * header)
lv_result_t lv_image_decoder_get_info(const void * src, lv_image_header_t * header)
{
lv_memzero(header, sizeof(lv_image_header_t));
if(src == NULL) return LV_RES_INV;
if(src == NULL) return LV_RESULT_INVALID;
lv_image_src_t src_type = lv_image_src_get_type(src);
if(src_type == LV_IMAGE_SRC_VARIABLE) {
const lv_image_dsc_t * img_dsc = src;
if(img_dsc->data == NULL) return LV_RES_INV;
if(img_dsc->data == NULL) return LV_RESULT_INVALID;
}
lv_res_t res = LV_RES_INV;
lv_result_t res = LV_RESULT_INVALID;
lv_image_decoder_t * d;
_LV_LL_READ(img_decoder_ll_p, d) {
if(d->info_cb) {
res = d->info_cb(d, src, header);
if(res == LV_RES_OK) {
if(res == LV_RESULT_OK) {
if(header->stride == 0) header->stride = img_width_to_stride(header);
break;
}
@@ -108,15 +108,15 @@ lv_res_t lv_image_decoder_get_info(const void * src, lv_image_header_t * header)
return res;
}
lv_res_t lv_image_decoder_open(lv_image_decoder_dsc_t * dsc, const void * src, lv_color_t color, int32_t frame_id)
lv_result_t lv_image_decoder_open(lv_image_decoder_dsc_t * dsc, const void * src, lv_color_t color, int32_t frame_id)
{
lv_memzero(dsc, sizeof(lv_image_decoder_dsc_t));
if(src == NULL) return LV_RES_INV;
if(src == NULL) return LV_RESULT_INVALID;
lv_image_src_t src_type = lv_image_src_get_type(src);
if(src_type == LV_IMAGE_SRC_VARIABLE) {
const lv_image_dsc_t * img_dsc = src;
if(img_dsc->data == NULL) return LV_RES_INV;
if(img_dsc->data == NULL) return LV_RESULT_INVALID;
}
dsc->color = color;
@@ -129,7 +129,7 @@ lv_res_t lv_image_decoder_open(lv_image_decoder_dsc_t * dsc, const void * src, l
LV_ASSERT_MALLOC(dsc->src);
if(dsc->src == NULL) {
LV_LOG_WARN("out of memory");
return LV_RES_INV;
return LV_RESULT_INVALID;
}
lv_strcpy((char *)dsc->src, src);
}
@@ -137,7 +137,7 @@ lv_res_t lv_image_decoder_open(lv_image_decoder_dsc_t * dsc, const void * src, l
dsc->src = src;
}
lv_res_t res = LV_RES_INV;
lv_result_t res = LV_RESULT_INVALID;
lv_image_decoder_t * decoder;
_LV_LL_READ(img_decoder_ll_p, decoder) {
@@ -145,7 +145,7 @@ lv_res_t lv_image_decoder_open(lv_image_decoder_dsc_t * dsc, const void * src, l
if(decoder->info_cb == NULL || decoder->open_cb == NULL) continue;
res = decoder->info_cb(decoder, src, &dsc->header);
if(res != LV_RES_OK) continue;
if(res != LV_RESULT_OK) continue;
if(dsc->header.stride == 0) dsc->header.stride = img_width_to_stride(&dsc->header);
@@ -153,7 +153,7 @@ lv_res_t lv_image_decoder_open(lv_image_decoder_dsc_t * dsc, const void * src, l
res = decoder->open_cb(decoder, dsc);
/*Opened successfully. It is a good decoder for this image source*/
if(res == LV_RES_OK) return res;
if(res == LV_RESULT_OK) return res;
/*Prepare for the next loop*/
lv_memzero(&dsc->header, sizeof(lv_image_header_t));
@@ -177,11 +177,12 @@ lv_res_t lv_image_decoder_open(lv_image_decoder_dsc_t * dsc, const void * src, l
* @param y start Y coordinate (from top)
* @param len number of pixels to read
* @param buf store the data here
* @return LV_RES_OK: success; LV_RES_INV: an error occurred
* @return LV_RESULT_OK: success; LV_RESULT_INVALID: an error occurred
*/
lv_res_t lv_image_decoder_get_area(lv_image_decoder_dsc_t * dsc, const lv_area_t * full_area, lv_area_t * decoded_area)
lv_result_t lv_image_decoder_get_area(lv_image_decoder_dsc_t * dsc, const lv_area_t * full_area,
lv_area_t * decoded_area)
{
lv_res_t res = LV_RES_INV;
lv_result_t res = LV_RESULT_INVALID;
if(dsc->decoder->get_area_cb) res = dsc->decoder->get_area_cb(dsc->decoder, dsc, full_area, decoded_area);
return res;
@@ -274,9 +275,9 @@ void lv_image_decoder_set_close_cb(lv_image_decoder_t * decoder, lv_image_decode
* @param decoder the decoder where this function belongs
* @param src the image source: pointer to an `lv_image_dsc_t` variable, a file path or a symbol
* @param header store the image data here
* @return LV_RES_OK: the info is successfully stored in `header`; LV_RES_INV: unknown format or other error.
* @return LV_RESULT_OK: the info is successfully stored in `header`; LV_RESULT_INVALID: unknown format or other error.
*/
lv_res_t lv_image_decoder_built_in_info(lv_image_decoder_t * decoder, const void * src, lv_image_header_t * header)
lv_result_t lv_image_decoder_built_in_info(lv_image_decoder_t * decoder, const void * src, lv_image_header_t * header)
{
LV_UNUSED(decoder); /*Unused*/
@@ -289,7 +290,7 @@ lv_res_t lv_image_decoder_built_in_info(lv_image_decoder_t * decoder, const void
}
else if(src_type == LV_IMAGE_SRC_FILE) {
/*Support only "*.bin" files*/
if(strcmp(lv_fs_get_ext(src), "bin")) return LV_RES_INV;
if(strcmp(lv_fs_get_ext(src), "bin")) return LV_RESULT_INVALID;
lv_fs_file_t f;
lv_fs_res_t res = lv_fs_open(&f, src, LV_FS_MODE_RD);
@@ -299,7 +300,7 @@ lv_res_t lv_image_decoder_built_in_info(lv_image_decoder_t * decoder, const void
lv_fs_close(&f);
if(res != LV_FS_RES_OK || rn != sizeof(lv_image_header_t)) {
LV_LOG_WARN("Image get info get read file header");
return LV_RES_INV;
return LV_RESULT_INVALID;
}
}
}
@@ -314,9 +315,9 @@ lv_res_t lv_image_decoder_built_in_info(lv_image_decoder_t * decoder, const void
}
else {
LV_LOG_WARN("Image get info found unknown src type");
return LV_RES_INV;
return LV_RESULT_INVALID;
}
return LV_RES_OK;
return LV_RESULT_OK;
}
static lv_image_decoder_built_in_data_t * get_decoder_data(lv_image_decoder_dsc_t * dsc)
@@ -341,27 +342,27 @@ static lv_image_decoder_built_in_data_t * get_decoder_data(lv_image_decoder_dsc_
* Open a built in image
* @param decoder the decoder where this function belongs
* @param dsc pointer to decoder descriptor. `src`, `color` are already initialized in it.
* @return LV_RES_OK: the info is successfully stored in `header`; LV_RES_INV: unknown format or other error.
* @return LV_RESULT_OK: the info is successfully stored in `header`; LV_RESULT_INVALID: unknown format or other error.
*/
lv_res_t lv_image_decoder_built_in_open(lv_image_decoder_t * decoder, lv_image_decoder_dsc_t * dsc)
lv_result_t lv_image_decoder_built_in_open(lv_image_decoder_t * decoder, lv_image_decoder_dsc_t * dsc)
{
LV_UNUSED(decoder);
/*Open the file if it's a file*/
if(dsc->src_type == LV_IMAGE_SRC_FILE) {
/*Support only "*.bin" files*/
if(strcmp(lv_fs_get_ext(dsc->src), "bin")) return LV_RES_INV;
if(strcmp(lv_fs_get_ext(dsc->src), "bin")) return LV_RESULT_INVALID;
lv_fs_file_t f;
lv_fs_res_t res = lv_fs_open(&f, dsc->src, LV_FS_MODE_RD);
if(res != LV_FS_RES_OK) {
LV_LOG_WARN("Built-in image decoder can't open the file");
return LV_RES_INV;
return LV_RESULT_INVALID;
}
/*If the file was open successfully save the file descriptor*/
lv_image_decoder_built_in_data_t * decoder_data = get_decoder_data(dsc);
if(decoder_data == NULL) {
return LV_RES_INV;
return LV_RESULT_INVALID;
}
lv_memcpy(&decoder_data->f, &f, sizeof(f));
@@ -375,7 +376,7 @@ lv_res_t lv_image_decoder_built_in_open(lv_image_decoder_t * decoder, lv_image_d
if(palette == NULL) {
LV_LOG_ERROR("out of memory");
lv_fs_close(&f);
return LV_RES_INV;
return LV_RESULT_INVALID;
}
uint32_t rn;
@@ -384,7 +385,7 @@ lv_res_t lv_image_decoder_built_in_open(lv_image_decoder_t * decoder, lv_image_d
LV_LOG_WARN("Built-in image decoder can't read the palette");
lv_free(palette);
lv_fs_close(&f);
return LV_RES_INV;
return LV_RESULT_INVALID;
}
dsc->palette = palette;
@@ -393,7 +394,7 @@ lv_res_t lv_image_decoder_built_in_open(lv_image_decoder_t * decoder, lv_image_d
decoder_data->palette = palette; /*Free decoder data on close*/
/*It needs to be read by get_area_cb later*/
return LV_RES_OK;
return LV_RESULT_OK;
}
if(dsc->header.cf == LV_COLOR_FORMAT_A8) {
@@ -404,7 +405,7 @@ lv_res_t lv_image_decoder_built_in_open(lv_image_decoder_t * decoder, lv_image_d
if(data == NULL) {
LV_LOG_ERROR("out of memory");
lv_fs_close(&f);
return LV_RES_INV;
return LV_RESULT_INVALID;
}
uint32_t rn;
@@ -413,23 +414,23 @@ lv_res_t lv_image_decoder_built_in_open(lv_image_decoder_t * decoder, lv_image_d
LV_LOG_WARN("Built-in image decoder can't read the palette");
lv_free(data);
lv_fs_close(&f);
return LV_RES_INV;
return LV_RESULT_INVALID;
}
decoder_data->img_data = data;
dsc->img_data = data;
return LV_RES_OK;
return LV_RESULT_OK;
}
/*It needs to be read by get_area_cb later*/
return LV_RES_OK;
return LV_RESULT_OK;
}
if(dsc->src_type == LV_IMAGE_SRC_VARIABLE) {
/*The variables should have valid data*/
lv_image_dsc_t * img_dsc = (lv_image_dsc_t *)dsc->src;
if(img_dsc->data == NULL) {
return LV_RES_INV;
return LV_RESULT_INVALID;
}
lv_color_format_t cf = img_dsc->header.cf;
@@ -437,13 +438,13 @@ lv_res_t lv_image_decoder_built_in_open(lv_image_decoder_t * decoder, lv_image_d
/*Need decoder data to store converted image*/
lv_image_decoder_built_in_data_t * decoder_data = get_decoder_data(dsc);
if(decoder_data == NULL) {
return LV_RES_INV;
return LV_RESULT_INVALID;
}
uint8_t * img_data = lv_malloc(sizeof(lv_color32_t) * img_dsc->header.w * img_dsc->header.h);
LV_ASSERT_NULL(img_data);
if(img_data == NULL) {
return LV_RES_INV;
return LV_RESULT_INVALID;
}
decoder_data->img_data = img_data; /*Put to decoder data for later free*/
@@ -469,10 +470,10 @@ lv_res_t lv_image_decoder_built_in_open(lv_image_decoder_t * decoder, lv_image_d
dsc->img_data = ((lv_image_dsc_t *)dsc->src)->data;
}
return LV_RES_OK;
return LV_RESULT_OK;
}
return LV_RES_INV;
return LV_RESULT_INVALID;
}
/**
@@ -495,8 +496,8 @@ void lv_image_decoder_built_in_close(lv_image_decoder_t * decoder, lv_image_deco
}
}
lv_res_t lv_image_decoder_built_in_get_area(lv_image_decoder_t * decoder, lv_image_decoder_dsc_t * dsc,
const lv_area_t * full_area, lv_area_t * decoded_area)
lv_result_t lv_image_decoder_built_in_get_area(lv_image_decoder_t * decoder, lv_image_decoder_dsc_t * dsc,
const lv_area_t * full_area, lv_area_t * decoded_area)
{
LV_UNUSED(decoder); /*Unused*/
@@ -508,10 +509,10 @@ lv_res_t lv_image_decoder_built_in_get_area(lv_image_decoder_t * decoder, lv_ima
|| cf == LV_COLOR_FORMAT_RGB565 || cf == LV_COLOR_FORMAT_RGB565A8;
if(!supported) {
LV_LOG_WARN("CF: %d is not supported", cf);
return LV_RES_INV;
return LV_RESULT_INVALID;
}
lv_res_t res = LV_RES_INV;
lv_result_t res = LV_RESULT_INVALID;
lv_image_decoder_built_in_data_t * decoder_data = dsc->user_data;
lv_fs_file_t * f = &decoder_data->f;
uint32_t bpp = lv_color_format_get_bpp(cf);
@@ -527,7 +528,7 @@ lv_res_t lv_image_decoder_built_in_get_area(lv_image_decoder_t * decoder, lv_ima
img_data = lv_malloc(len);
LV_ASSERT_NULL(img_data);
if(img_data == NULL)
return LV_RES_INV;
return LV_RESULT_INVALID;
*decoded_area = *full_area;
decoded_area->y2 = decoded_area->y1;
@@ -540,7 +541,7 @@ lv_res_t lv_image_decoder_built_in_get_area(lv_image_decoder_t * decoder, lv_ima
}
if(decoded_area->y1 > full_area->y2) {
return LV_RES_INV;
return LV_RESULT_INVALID;
}
if(LV_COLOR_FORMAT_IS_INDEXED(cf)) {
@@ -549,7 +550,7 @@ lv_res_t lv_image_decoder_built_in_get_area(lv_image_decoder_t * decoder, lv_ima
uint8_t * buf = lv_malloc(len);
LV_ASSERT_NULL(buf);
if(buf == NULL)
return LV_RES_INV;
return LV_RESULT_INVALID;
offset += dsc->palette_size * 4; /*Skip palette*/
offset += decoded_area->y1 * ((dsc->header.w * bpp + 7) / 8); /*Move to y1*/
@@ -557,14 +558,14 @@ lv_res_t lv_image_decoder_built_in_get_area(lv_image_decoder_t * decoder, lv_ima
res = fs_read_file_at(f, offset, buf, len, NULL);
if(res != LV_FS_RES_OK) {
lv_free(buf);
return LV_RES_INV;
return LV_RESULT_INVALID;
}
decode_indexed_line(cf, dsc->palette, x_fraction, 0, w_px, buf, (lv_color32_t *)img_data);
lv_free(buf);
dsc->img_data = img_data; /*Return decoded image*/
return LV_RES_OK;
return LV_RESULT_OK;
}
if(cf == LV_COLOR_FORMAT_ARGB8888 || cf == LV_COLOR_FORMAT_XRGB8888 || cf == LV_COLOR_FORMAT_RGB888
@@ -574,11 +575,11 @@ lv_res_t lv_image_decoder_built_in_get_area(lv_image_decoder_t * decoder, lv_ima
offset += decoded_area->x1 * bpp / 8; /*Move to x1*/
res = fs_read_file_at(f, offset, img_data, len, NULL);
if(res != LV_FS_RES_OK) {
return LV_RES_INV;
return LV_RESULT_INVALID;
}
dsc->img_data = img_data; /*Return decoded image*/
return LV_RES_OK;
return LV_RESULT_OK;
}
@@ -589,7 +590,7 @@ lv_res_t lv_image_decoder_built_in_get_area(lv_image_decoder_t * decoder, lv_ima
offset += decoded_area->x1 * bpp / 8; /*Move to x1*/
res = fs_read_file_at(f, offset, img_data, len, NULL);
if(res != LV_FS_RES_OK) {
return LV_RES_INV;
return LV_RESULT_INVALID;
}
/*Now the A8 mask*/
@@ -599,23 +600,23 @@ lv_res_t lv_image_decoder_built_in_get_area(lv_image_decoder_t * decoder, lv_ima
offset += decoded_area->x1 * 1; /*Move to x1*/
res = fs_read_file_at(f, offset, img_data + len, w_px * 1, NULL);
if(res != LV_FS_RES_OK) {
return LV_RES_INV;
return LV_RESULT_INVALID;
}
dsc->img_data = img_data; /*Return decoded image*/
return LV_RES_OK;
return LV_RESULT_OK;
}
return LV_RES_INV;
return LV_RESULT_INVALID;
}
/**********************
* STATIC FUNCTIONS
**********************/
static lv_res_t decode_indexed_line(lv_color_format_t color_format, const lv_color32_t * palette, lv_coord_t x,
lv_coord_t y,
lv_coord_t w_px, const uint8_t * in, lv_color32_t * out)
static lv_result_t decode_indexed_line(lv_color_format_t color_format, const lv_color32_t * palette, lv_coord_t x,
lv_coord_t y,
lv_coord_t w_px, const uint8_t * in, lv_color32_t * out)
{
uint8_t px_size;
uint16_t mask;
@@ -654,7 +655,7 @@ static lv_res_t decode_indexed_line(lv_color_format_t color_format, const lv_col
shift = 0;
break;
default:
return LV_RES_INV;
return LV_RESULT_INVALID;
}
mask = (1 << px_size) - 1; /*E.g. px_size = 2; mask = 0x03*/
@@ -670,7 +671,7 @@ static lv_res_t decode_indexed_line(lv_color_format_t color_format, const lv_col
in++;
}
}
return LV_RES_OK;
return LV_RESULT_OK;
}
static uint32_t img_width_to_stride(lv_image_header_t * header)

48
src/draw/lv_image_decoder.h
View File

@@ -53,18 +53,18 @@ struct _lv_image_decoder_t;
* @param src the image source. Can be a pointer to a C array or a file name (Use
* `lv_image_src_get_type` to determine the type)
* @param header store the info here
* @return LV_RES_OK: info written correctly; LV_RES_INV: failed
* @return LV_RESULT_OK: info written correctly; LV_RESULT_INVALID: failed
*/
typedef lv_res_t (*lv_image_decoder_info_f_t)(struct _lv_image_decoder_t * decoder, const void * src,
lv_image_header_t * header);
typedef lv_result_t (*lv_image_decoder_info_f_t)(struct _lv_image_decoder_t * decoder, const void * src,
lv_image_header_t * header);
/**
* Open an image for decoding. Prepare it as it is required to read it later
* @param decoder pointer to the decoder the function associated with
* @param dsc pointer to decoder descriptor. `src`, `color` are already initialized in it.
*/
typedef lv_res_t (*lv_image_decoder_open_f_t)(struct _lv_image_decoder_t * decoder,
struct _lv_image_decoder_dsc_t * dsc);
typedef lv_result_t (*lv_image_decoder_open_f_t)(struct _lv_image_decoder_t * decoder,
struct _lv_image_decoder_dsc_t * dsc);
/**
* Decode `len` pixels starting from the given `x`, `y` coordinates and store them in `buf`.
@@ -75,11 +75,11 @@ typedef lv_res_t (*lv_image_decoder_open_f_t)(struct _lv_image_decoder_t * decod
* @param y start y coordinate
* @param len number of pixels to decode
* @param buf a buffer to store the decoded pixels
* @return LV_RES_OK: ok; LV_RES_INV: failed
* @return LV_RESULT_OK: ok; LV_RESULT_INVALID: failed
*/
typedef lv_res_t (*lv_image_decoder_get_area_cb_t)(struct _lv_image_decoder_t * decoder,
struct _lv_image_decoder_dsc_t * dsc,
const lv_area_t * full_area, lv_area_t * decoded_area);
typedef lv_result_t (*lv_image_decoder_get_area_cb_t)(struct _lv_image_decoder_t * decoder,
struct _lv_image_decoder_dsc_t * dsc,
const lv_area_t * full_area, lv_area_t * decoded_area);
/**
* Close the pending decoding. Free resources etc.
@@ -153,9 +153,9 @@ void _lv_image_decoder_init(void);
* 2) Variable: Pointer to an `lv_image_dsc_t` variable
* 3) Symbol: E.g. `LV_SYMBOL_OK`
* @param header the image info will be stored here
* @return LV_RES_OK: success; LV_RES_INV: wasn't able to get info about the image
* @return LV_RESULT_OK: success; LV_RESULT_INVALID: wasn't able to get info about the image
*/
lv_res_t lv_image_decoder_get_info(const void * src, lv_image_header_t * header);
lv_result_t lv_image_decoder_get_info(const void * src, lv_image_header_t * header);
/**
* Open an image.
@@ -167,10 +167,10 @@ lv_res_t lv_image_decoder_get_info(const void * src, lv_image_header_t * header)
* 3) Symbol: E.g. `LV_SYMBOL_OK`
* @param color The color of the image with `LV_IMAGE_CF_ALPHA_...`
* @param frame_id the index of the frame. Used only with animated images, set 0 for normal images
* @return LV_RES_OK: opened the image. `dsc->img_data` and `dsc->header` are set.
* LV_RES_INV: none of the registered image decoders were able to open the image.
* @return LV_RESULT_OK: opened the image. `dsc->img_data` and `dsc->header` are set.
* LV_RESULT_INVALID: none of the registered image decoders were able to open the image.
*/
lv_res_t lv_image_decoder_open(lv_image_decoder_dsc_t * dsc, const void * src, lv_color_t color, int32_t frame_id);
lv_result_t lv_image_decoder_open(lv_image_decoder_dsc_t * dsc, const void * src, lv_color_t color, int32_t frame_id);
/**
* Read a line from an opened image
@@ -179,9 +179,10 @@ lv_res_t lv_image_decoder_open(lv_image_decoder_dsc_t * dsc, const void * src, l
* @param y start Y coordinate (from top)
* @param len number of pixels to read
* @param buf store the data here
* @return LV_RES_OK: success; LV_RES_INV: an error occurred
* @return LV_RESULT_OK: success; LV_RESULT_INVALID: an error occurred
*/
lv_res_t lv_image_decoder_get_area(lv_image_decoder_dsc_t * dsc, const lv_area_t * full_area, lv_area_t * decoded_area);
lv_result_t lv_image_decoder_get_area(lv_image_decoder_dsc_t * dsc, const lv_area_t * full_area,
lv_area_t * decoded_area);
/**
* Close a decoding session
@@ -234,23 +235,20 @@ void lv_image_decoder_set_close_cb(lv_image_decoder_t * decoder, lv_image_decode
* @param decoder the decoder where this function belongs
* @param src the image source: pointer to an `lv_image_dsc_t` variable, a file path or a symbol
* @param header store the image data here
* @return LV_RES_OK: the info is successfully stored in `header`; LV_RES_INV: unknown format or other error.
* @return LV_RESULT_OK: the info is successfully stored in `header`; LV_RESULT_INVALID: unknown format or other error.
*/
lv_res_t lv_image_decoder_built_in_info(lv_image_decoder_t * decoder, const void * src, lv_image_header_t * header);
lv_result_t lv_image_decoder_built_in_info(lv_image_decoder_t * decoder, const void * src, lv_image_header_t * header);
lv_res_t lv_image_decoder_built_in_get_area(lv_image_decoder_t * decoder, lv_image_decoder_dsc_t * dsc,
const lv_area_t * full_area, lv_area_t * decoded_area);
lv_res_t lv_img_decoder_built_in_get_area(lv_image_decoder_t * decoder, lv_image_decoder_dsc_t * dsc,
const lv_area_t * full_area, lv_area_t * decoded_area);
lv_result_t lv_image_decoder_built_in_get_area(lv_image_decoder_t * decoder, lv_image_decoder_dsc_t * dsc,
const lv_area_t * full_area, lv_area_t * decoded_area);
/**
* Open a built in image
* @param decoder the decoder where this function belongs
* @param dsc pointer to decoder descriptor. `src`, `style` are already initialized in it.
* @return LV_RES_OK: the info is successfully stored in `header`; LV_RES_INV: unknown format or other error.
* @return LV_RESULT_OK: the info is successfully stored in `header`; LV_RESULT_INVALID: unknown format or other error.
*/
lv_res_t lv_image_decoder_built_in_open(lv_image_decoder_t * decoder, lv_image_decoder_dsc_t * dsc);
lv_result_t lv_image_decoder_built_in_open(lv_image_decoder_t * decoder, lv_image_decoder_dsc_t * dsc);
/**
* Close the pending decoding. Free resources etc.

2
src/draw/sw/blend/lv_draw_sw_blend_to_argb8888.c
View File

@@ -11,7 +11,7 @@
#include "lv_draw_sw_blend.h"
#include "../../../misc/lv_math.h"
#include "../../../disp/lv_disp.h"
#include "../../../display/lv_display.h"
#include "../../../core/lv_refr.h"
#include "../../../misc/lv_color.h"
#include "../../../stdlib/lv_string.h"

2
src/draw/sw/blend/lv_draw_sw_blend_to_rgb565.c
View File

@@ -11,7 +11,7 @@
#include "lv_draw_sw_blend.h"
#include "../../../misc/lv_math.h"
#include "../../../disp/lv_disp.h"
#include "../../../display/lv_display.h"
#include "../../../core/lv_refr.h"
#include "../../../misc/lv_color.h"
#include "../../../stdlib/lv_string.h"

2
src/draw/sw/blend/lv_draw_sw_blend_to_rgb888.c
View File

@@ -11,7 +11,7 @@
#include "lv_draw_sw_blend.h"
#include "../../../misc/lv_math.h"
#include "../../../disp/lv_disp.h"
#include "../../../display/lv_display.h"
#include "../../../core/lv_refr.h"
#include "../../../misc/lv_color.h"
#include "../../../stdlib/lv_string.h"

6
src/draw/sw/lv_draw_sw.c
View File

@@ -11,7 +11,7 @@
#include "../../core/lv_refr.h"
#include "lv_draw_sw.h"
#include "../../disp/lv_disp_private.h"
#include "../../display/lv_display_private.h"
#include "../../stdlib/lv_string.h"
/*********************
@@ -182,7 +182,7 @@ static void execute_drawing(lv_draw_sw_unit_t * u)
if(!_lv_area_intersect(&draw_area, &t->area, u->base_unit.clip_area)) return;
int32_t idx = 0;
lv_disp_t * disp = _lv_refr_get_disp_refreshing();
lv_display_t * disp = _lv_refr_get_disp_refreshing();
lv_draw_unit_t * draw_unit_tmp = disp->draw_unit_head;
while(draw_unit_tmp != (lv_draw_unit_t *)u) {
draw_unit_tmp = draw_unit_tmp->next;
@@ -198,7 +198,7 @@ static void execute_drawing(lv_draw_sw_unit_t * u)
lv_draw_sw_fill((lv_draw_unit_t *)u, &rect_dsc, &draw_area);
lv_point_t txt_size;
lv_txt_get_size(&txt_size, "W", LV_FONT_DEFAULT, 0, 0, 100, LV_TEXT_FLAG_NONE);
lv_text_get_size(&txt_size, "W", LV_FONT_DEFAULT, 0, 0, 100, LV_TEXT_FLAG_NONE);
lv_area_t txt_area;
txt_area.x1 = draw_area.x1;

2
src/draw/sw/lv_draw_sw.h
View File

@@ -18,7 +18,7 @@ extern "C" {
#include "../../misc/lv_area.h"
#include "../../misc/lv_color.h"
#include "../../disp/lv_disp.h"
#include "../../display/lv_display.h"
#include "../../osal/lv_os.h"
/*********************

4
src/draw/sw/lv_draw_sw_bg_img.c
View File

@@ -11,7 +11,7 @@
#include "blend/lv_draw_sw_blend.h"
#include "../../misc/lv_math.h"
#include "../../misc/lv_txt_ap.h"
#include "../../misc/lv_text_ap.h"
#include "../../core/lv_refr.h"
#include "../../misc/lv_assert.h"
#include "../lv_draw_mask.h"
@@ -56,7 +56,7 @@ void lv_draw_sw_bg_image(lv_draw_unit_t * draw_unit, const lv_draw_bg_image_dsc_
lv_image_src_t src_type = lv_image_src_get_type(dsc->src);
if(src_type == LV_IMAGE_SRC_SYMBOL) {
lv_point_t size;
lv_txt_get_size(&size, dsc->src, dsc->font, 0, 0, LV_COORD_MAX, LV_TEXT_FLAG_NONE);
lv_text_get_size(&size, dsc->src, dsc->font, 0, 0, LV_COORD_MAX, LV_TEXT_FLAG_NONE);
lv_area_t a;
a.x1 = coords->x1 + lv_area_get_width(coords) / 2 - size.x / 2;
a.x2 = a.x1 + size.x - 1;

2
src/draw/sw/lv_draw_sw_border.c
View File

@@ -11,7 +11,7 @@
#include "blend/lv_draw_sw_blend.h"
#include "../../misc/lv_math.h"
#include "../../misc/lv_txt_ap.h"
#include "../../misc/lv_text_ap.h"
#include "../../core/lv_refr.h"
#include "../../misc/lv_assert.h"
#include "../../stdlib/lv_string.h"

2
src/draw/sw/lv_draw_sw_fill.c
View File

@@ -12,7 +12,7 @@
#include "blend/lv_draw_sw_blend.h"
#include "lv_draw_sw_gradient.h"
#include "../../misc/lv_math.h"
#include "../../misc/lv_txt_ap.h"
#include "../../misc/lv_text_ap.h"
#include "../../core/lv_refr.h"
#include "../../misc/lv_assert.h"
#include "../../stdlib/lv_string.h"

2
src/draw/sw/lv_draw_sw_gradient.c
View File

@@ -29,7 +29,7 @@
/**********************
* STATIC PROTOTYPES
**********************/
typedef lv_res_t (*op_cache_t)(lv_grad_t * c, void * ctx);
typedef lv_result_t (*op_cache_t)(lv_grad_t * c, void * ctx);
static lv_grad_t * allocate_item(const lv_grad_dsc_t * g, lv_coord_t w, lv_coord_t h);
/**********************

30
src/draw/sw/lv_draw_sw_img.c
View File

@@ -9,8 +9,8 @@
#include "lv_draw_sw.h"
#if LV_USE_DRAW_SW
#include "../../disp/lv_disp.h"
#include "../../disp/lv_disp_private.h"
#include "../../display/lv_display.h"
#include "../../display/lv_display_private.h"
#include "../../misc/lv_log.h"
#include "../../core/lv_refr.h"
#include "../../stdlib/lv_mem.h"
@@ -22,7 +22,7 @@
/*********************
* DEFINES
*********************/
#define MAX_BUF_SIZE (uint32_t) 4 * lv_draw_buf_width_to_stride(lv_disp_get_hor_res(_lv_refr_get_disp_refreshing()), lv_disp_get_color_format(_lv_refr_get_disp_refreshing()))
#define MAX_BUF_SIZE (uint32_t) 4 * lv_draw_buf_width_to_stride(lv_display_get_horizontal_resolution(_lv_refr_get_disp_refreshing()), lv_display_get_color_format(_lv_refr_get_disp_refreshing()))
/**********************
* TYPEDEFS
@@ -71,11 +71,11 @@ void lv_draw_sw_layer(lv_draw_unit_t * draw_unit, const lv_draw_image_dsc_t * dr
#if LV_USE_LAYER_DEBUG || LV_USE_PARALLEL_DRAW_DEBUG
lv_area_t area_rot;
lv_area_copy(&area_rot, coords);
if(draw_dsc->angle || draw_dsc->zoom != LV_ZOOM_NONE) {
if(draw_dsc->rotation || draw_dsc->zoom != LV_SCALE_NONE) {
int32_t w = lv_area_get_width(coords);
int32_t h = lv_area_get_height(coords);
_lv_image_buf_get_transformed_area(&area_rot, w, h, draw_dsc->angle, draw_dsc->zoom, &draw_dsc->pivot);
_lv_image_buf_get_transformed_area(&area_rot, w, h, draw_dsc->rotation, draw_dsc->zoom, &draw_dsc->pivot);
area_rot.x1 += coords->x1;
area_rot.y1 += coords->y1;
@@ -104,7 +104,7 @@ void lv_draw_sw_layer(lv_draw_unit_t * draw_unit, const lv_draw_image_dsc_t * dr
#if LV_USE_PARALLEL_DRAW_DEBUG
uint32_t idx = 0;
lv_disp_t * disp = _lv_refr_get_disp_refreshing();
lv_display_t * disp = _lv_refr_get_disp_refreshing();
lv_draw_unit_t * draw_unit_tmp = disp->draw_unit_head;
while(draw_unit_tmp != draw_unit) {
draw_unit_tmp = draw_unit_tmp->next;
@@ -121,7 +121,7 @@ void lv_draw_sw_layer(lv_draw_unit_t * draw_unit, const lv_draw_image_dsc_t * dr
lv_draw_sw_rect(draw_unit, &rect_dsc, &area_rot);
lv_point_t txt_size;
lv_txt_get_size(&txt_size, "W", LV_FONT_DEFAULT, 0, 0, 100, LV_TEXT_FLAG_NONE);
lv_text_get_size(&txt_size, "W", LV_FONT_DEFAULT, 0, 0, 100, LV_TEXT_FLAG_NONE);
lv_area_t txt_area;
txt_area.x1 = draw_area.x1;
@@ -150,11 +150,11 @@ LV_ATTRIBUTE_FAST_MEM void lv_draw_sw_image(lv_draw_unit_t * draw_unit, const lv
{
lv_area_t transformed_area;
lv_area_copy(&transformed_area, coords);
if(draw_dsc->angle || draw_dsc->zoom != LV_ZOOM_NONE) {
if(draw_dsc->rotation || draw_dsc->zoom != LV_SCALE_NONE) {
int32_t w = lv_area_get_width(coords);
int32_t h = lv_area_get_height(coords);
_lv_image_buf_get_transformed_area(&transformed_area, w, h, draw_dsc->angle, draw_dsc->zoom, &draw_dsc->pivot);
_lv_image_buf_get_transformed_area(&transformed_area, w, h, draw_dsc->rotation, draw_dsc->zoom, &draw_dsc->pivot);
transformed_area.x1 += coords->x1;
transformed_area.y1 += coords->y1;
@@ -169,8 +169,8 @@ LV_ATTRIBUTE_FAST_MEM void lv_draw_sw_image(lv_draw_unit_t * draw_unit, const lv
}
lv_image_decoder_dsc_t decoder_dsc;
lv_res_t res = lv_image_decoder_open(&decoder_dsc, draw_dsc->src, draw_dsc->recolor, -1);
if(res != LV_RES_OK) {
lv_result_t res = lv_image_decoder_open(&decoder_dsc, draw_dsc->src, draw_dsc->recolor, -1);
if(res != LV_RESULT_OK) {
LV_LOG_ERROR("Failed to open image");
return;
}
@@ -195,13 +195,13 @@ LV_ATTRIBUTE_FAST_MEM void lv_draw_sw_image(lv_draw_unit_t * draw_unit, const lv
relative_decoded_area.y1 = LV_COORD_MIN;
relative_decoded_area.x2 = LV_COORD_MIN;
relative_decoded_area.y2 = LV_COORD_MIN;
res = LV_RES_OK;
while(res == LV_RES_OK) {
res = LV_RESULT_OK;
while(res == LV_RESULT_OK) {
res = lv_image_decoder_get_area(&decoder_dsc, &relative_full_area_to_decode, &relative_decoded_area);
lv_area_t absolute_decoded_area = relative_decoded_area;
lv_area_move(&absolute_decoded_area, coords->x1, coords->y1);
if(res == LV_RES_OK) {
if(res == LV_RESULT_OK) {
/*Limit draw area to the current decoded area and draw the image*/
lv_area_t draw_area_sub;
if(_lv_area_intersect(&draw_area_sub, &draw_area, &absolute_decoded_area)) {
@@ -219,7 +219,7 @@ LV_ATTRIBUTE_FAST_MEM void lv_draw_sw_image(lv_draw_unit_t * draw_unit, const lv
static void img_draw_core(lv_draw_unit_t * draw_unit, const lv_draw_image_dsc_t * draw_dsc, const lv_area_t * draw_area,
const lv_image_decoder_dsc_t * src, lv_draw_image_sup_t * sup, const lv_area_t * img_coords)
{
bool transformed = draw_dsc->angle != 0 || draw_dsc->zoom != LV_ZOOM_NONE ? true : false;
bool transformed = draw_dsc->rotation != 0 || draw_dsc->zoom != LV_SCALE_NONE ? true : false;
lv_draw_sw_blend_dsc_t blend_dsc;
const uint8_t * src_buf = src->img_data;

6
src/draw/sw/lv_draw_sw_letter.c
View File

@@ -9,7 +9,7 @@
#include "lv_draw_sw.h"
#if LV_USE_DRAW_SW
#include "../../disp/lv_disp.h"
#include "../../display/lv_display.h"
#include "../../misc/lv_math.h"
#include "../../misc/lv_assert.h"
#include "../../misc/lv_area.h"
@@ -93,8 +93,8 @@ LV_ATTRIBUTE_FAST_MEM static void draw_letter_cb(lv_draw_unit_t * draw_unit, lv_
#if LV_USE_IMGFONT
lv_draw_image_dsc_t img_dsc;
lv_draw_image_dsc_init(&img_dsc);
img_dsc.angle = 0;
img_dsc.zoom = LV_ZOOM_NONE;
img_dsc.rotation = 0;
img_dsc.zoom = LV_SCALE_NONE;
img_dsc.opa = glyph_draw_dsc->opa;
img_dsc.src = glyph_draw_dsc->bitmap;
lv_draw_sw_image(draw_unit, &img_dsc, glyph_draw_dsc->letter_coords);

2
src/draw/sw/lv_draw_sw_line.c
View File

@@ -346,7 +346,7 @@ LV_ATTRIBUTE_FAST_MEM static void draw_line_skew(lv_draw_unit_t * draw_unit, con
/*Draw the background line by line*/
int32_t h;
uint32_t hor_res = (uint32_t)lv_disp_get_hor_res(_lv_refr_get_disp_refreshing());
uint32_t hor_res = (uint32_t)lv_display_get_horizontal_resolution(_lv_refr_get_disp_refreshing());
size_t mask_buf_size = LV_MIN(lv_area_get_size(&blend_area), hor_res);
lv_opa_t * mask_buf = lv_malloc(mask_buf_size);

6
src/draw/sw/lv_draw_sw_transform.c
View File

@@ -86,7 +86,7 @@ void lv_draw_sw_transform(lv_draw_unit_t * draw_unit, const lv_area_t * dest_are
LV_UNUSED(sup);
point_transform_dsc_t tr_dsc;
tr_dsc.angle = -draw_dsc->angle;
tr_dsc.angle = -draw_dsc->rotation;
tr_dsc.zoom = (256 * 256) / draw_dsc->zoom;
tr_dsc.pivot = draw_dsc->pivot;
@@ -570,7 +570,7 @@ static void transform_a8(const uint8_t * src, lv_coord_t src_w, lv_coord_t src_h
static void transform_point_upscaled(point_transform_dsc_t * t, int32_t xin, int32_t yin, int32_t * xout,
int32_t * yout)
{
if(t->angle == 0 && t->zoom == LV_ZOOM_NONE) {
if(t->angle == 0 && t->zoom == LV_SCALE_NONE) {
*xout = xin * 256;
*yout = yin * 256;
return;
@@ -583,7 +583,7 @@ static void transform_point_upscaled(point_transform_dsc_t * t, int32_t xin, int
*xout = ((int32_t)(xin * t->zoom)) + (t->pivot_x_256);
*yout = ((int32_t)(yin * t->zoom)) + (t->pivot_y_256);
}
else if(t->zoom == LV_ZOOM_NONE) {
else if(t->zoom == LV_SCALE_NONE) {
*xout = ((t->cosma * xin - t->sinma * yin) >> 2) + (t->pivot_x_256);
*yout = ((t->sinma * xin + t->cosma * yin) >> 2) + (t->pivot_y_256);
}

46
src/indev/lv_indev.c
View File

@@ -8,7 +8,7 @@
********************/
#include "lv_indev_private.h"
#include "lv_indev_scroll.h"
#include "../disp/lv_disp_private.h"
#include "../display/lv_display_private.h"
#include "../core/lv_global.h"
#include "../core/lv_obj.h"
#include "../core/lv_group.h"
@@ -65,7 +65,7 @@ static void indev_encoder_proc(lv_indev_t * i, lv_indev_data_t * data);
static void indev_button_proc(lv_indev_t * i, lv_indev_data_t * data);
static void indev_proc_press(lv_indev_t * indev);
static void indev_proc_release(lv_indev_t * indev);
static lv_obj_t * pointer_search_obj(lv_disp_t * disp, lv_point_t * p);
static lv_obj_t * pointer_search_obj(lv_display_t * disp, lv_point_t * p);
static void indev_proc_reset_query_handler(lv_indev_t * indev);
static void indev_click_focus(lv_indev_t * indev);
static void indev_gesture(lv_indev_t * indev);
@@ -92,7 +92,7 @@ static void indev_reset_core(lv_indev_t * indev, lv_obj_t * obj);
lv_indev_t * lv_indev_create(void)
{
lv_disp_t * disp = lv_disp_get_default();
lv_display_t * disp = lv_display_get_default();
if(disp == NULL) {
LV_LOG_WARN("no display was created so far");
}
@@ -107,7 +107,7 @@ lv_indev_t * lv_indev_create(void)
indev->reset_query = 1;
indev->read_timer = lv_timer_create(lv_indev_read_timer_cb, LV_DEF_REFR_PERIOD, indev);
indev->disp = lv_disp_get_default();
indev->disp = lv_display_get_default();
indev->type = LV_INDEV_TYPE_NONE;
indev->scroll_limit = LV_INDEV_DEF_SCROLL_LIMIT;
indev->scroll_throw = LV_INDEV_DEF_SCROLL_THROW;
@@ -308,14 +308,14 @@ lv_group_t * lv_indev_get_group(const lv_indev_t * indev)
return indev->group;
}
lv_disp_t * lv_indev_get_disp(const lv_indev_t * indev)
lv_display_t * lv_indev_get_disp(const lv_indev_t * indev)
{
if(indev == NULL) return NULL;
return indev->disp;
}
void lv_indev_set_disp(lv_indev_t * indev, lv_disp_t * disp)
void lv_indev_set_disp(lv_indev_t * indev, lv_display_t * disp)
{
if(indev == NULL) return;
@@ -362,7 +362,7 @@ void lv_indev_set_cursor(lv_indev_t * indev, lv_obj_t * cur_obj)
if(indev->type != LV_INDEV_TYPE_POINTER) return;
indev->cursor = cur_obj;
lv_obj_set_parent(indev->cursor, lv_disp_get_layer_sys(indev->disp));
lv_obj_set_parent(indev->cursor, lv_display_get_layer_sys(indev->disp));
lv_obj_set_pos(indev->cursor, indev->pointer.act_point.x, indev->pointer.act_point.y);
lv_obj_clear_flag(indev->cursor, LV_OBJ_FLAG_CLICKABLE);
lv_obj_add_flag(indev->cursor, LV_OBJ_FLAG_IGNORE_LAYOUT | LV_OBJ_FLAG_FLOATING);
@@ -508,16 +508,16 @@ lv_obj_t * lv_indev_search_obj(lv_obj_t * obj, lv_point_t * point)
*/
static void indev_pointer_proc(lv_indev_t * i, lv_indev_data_t * data)
{
lv_disp_t * disp = i->disp;
lv_display_t * disp = i->disp;
/*Save the raw points so they can be used again in indev_read_core*/
i->pointer.last_raw_point.x = data->point.x;
i->pointer.last_raw_point.y = data->point.y;
if(disp->rotation == LV_DISP_ROTATION_180 || disp->rotation == LV_DISP_ROTATION_270) {
if(disp->rotation == LV_DISPLAY_ROTATION_180 || disp->rotation == LV_DISPLAY_ROTATION_270) {
data->point.x = disp->hor_res - data->point.x - 1;
data->point.y = disp->ver_res - data->point.y - 1;
}
if(disp->rotation == LV_DISP_ROTATION_90 || disp->rotation == LV_DISP_ROTATION_270) {
if(disp->rotation == LV_DISPLAY_ROTATION_90 || disp->rotation == LV_DISPLAY_ROTATION_270) {
lv_coord_t tmp = data->point.y;
data->point.y = data->point.x;
data->point.x = disp->ver_res - tmp - 1;
@@ -527,13 +527,13 @@ static void indev_pointer_proc(lv_indev_t * i, lv_indev_data_t * data)
if(data->point.x < 0) {
LV_LOG_WARN("X is %d which is smaller than zero", (int)data->point.x);
}
if(data->point.x >= lv_disp_get_hor_res(i->disp)) {
if(data->point.x >= lv_display_get_horizontal_resolution(i->disp)) {
LV_LOG_WARN("X is %d which is greater than hor. res", (int)data->point.x);
}
if(data->point.y < 0) {
LV_LOG_WARN("Y is %d which is smaller than zero", (int)data->point.y);
}
if(data->point.y >= lv_disp_get_ver_res(i->disp)) {
if(data->point.y >= lv_display_get_vertical_resolution(i->disp)) {
LV_LOG_WARN("Y is %d which is greater than ver. res", (int)data->point.y);
}
@@ -589,7 +589,7 @@ static void indev_keypad_proc(lv_indev_t * i, lv_indev_data_t * data)
i->keypad.last_key = data->key;
/*Save the previous state so we can detect state changes below and also set the last state now
*so if any event handler on the way returns `LV_RES_INV` the last state is remembered
*so if any event handler on the way returns `LV_RESULT_INVALID` the last state is remembered
*for the next time*/
uint32_t prev_state = i->keypad.last_state;
i->keypad.last_state = data->state;
@@ -980,7 +980,7 @@ static void indev_button_proc(lv_indev_t * i, lv_indev_data_t * data)
/**
* Process the pressed state of LV_INDEV_TYPE_POINTER input devices
* @param indev pointer to an input device 'proc'
* @return LV_RES_OK: no indev reset required; LV_RES_INV: indev reset is required
* @return LV_RESULT_OK: no indev reset required; LV_RESULT_INVALID: indev reset is required
*/
static void indev_proc_press(lv_indev_t * indev)
{
@@ -990,7 +990,7 @@ static void indev_proc_press(lv_indev_t * indev)
if(indev->wait_until_release != 0) return;
lv_disp_t * disp = indev_act->disp;
lv_display_t * disp = indev_act->disp;
bool new_obj_searched = false;
/*If there is no last object then search*/
@@ -1163,13 +1163,13 @@ static void indev_proc_release(lv_indev_t * indev)
lv_point_t pivot = { 0, 0 };
lv_obj_t * parent = scroll_obj;
while(parent) {
angle += lv_obj_get_style_transform_angle(parent, 0);
int32_t zoom_act = lv_obj_get_style_transform_zoom_safe(parent, 0);
angle += lv_obj_get_style_transform_rotation(parent, 0);
int32_t zoom_act = lv_obj_get_style_transform_scale_safe(parent, 0);
zoom = (zoom * zoom_act) >> 8;
parent = lv_obj_get_parent(parent);
}
if(angle != 0 || zoom != LV_ZOOM_NONE) {
if(angle != 0 || zoom != LV_SCALE_NONE) {
angle = -angle;
zoom = (256 * 256) / zoom;
lv_point_transform(&indev->pointer.scroll_throw_vect, angle, zoom, &pivot);
@@ -1185,18 +1185,18 @@ static void indev_proc_release(lv_indev_t * indev)
}
}
static lv_obj_t * pointer_search_obj(lv_disp_t * disp, lv_point_t * p)
static lv_obj_t * pointer_search_obj(lv_display_t * disp, lv_point_t * p)
{
indev_obj_act = lv_indev_search_obj(lv_disp_get_layer_sys(disp), p);
indev_obj_act = lv_indev_search_obj(lv_display_get_layer_sys(disp), p);
if(indev_obj_act) return indev_obj_act;
indev_obj_act = lv_indev_search_obj(lv_disp_get_layer_top(disp), p);
indev_obj_act = lv_indev_search_obj(lv_display_get_layer_top(disp), p);
if(indev_obj_act) return indev_obj_act;
indev_obj_act = lv_indev_search_obj(lv_disp_get_scr_act(disp), p);
indev_obj_act = lv_indev_search_obj(lv_display_get_scr_act(disp), p);
if(indev_obj_act) return indev_obj_act;
indev_obj_act = lv_indev_search_obj(lv_disp_get_layer_bottom(disp), p);
indev_obj_act = lv_indev_search_obj(lv_display_get_layer_bottom(disp), p);
return indev_obj_act;
}

8
src/indev/lv_indev.h
View File

@@ -25,10 +25,10 @@ extern "C" {
* TYPEDEFS
**********************/
struct _lv_obj_t;
struct _lv_disp_t;
struct _lv_display_t;
struct _lv_group_t;
struct _lv_indev_t;
struct _lv_disp_t;
struct _lv_display_t;
typedef struct _lv_indev_t lv_indev_t;
/** Possible input device types*/
@@ -129,9 +129,9 @@ lv_indev_state_t lv_indev_get_state(const lv_indev_t * indev);
lv_group_t * lv_indev_get_group(const lv_indev_t * indev);
struct _lv_disp_t * lv_indev_get_disp(const lv_indev_t * indev);
struct _lv_display_t * lv_indev_get_disp(const lv_indev_t * indev);
void lv_indev_set_disp(lv_indev_t * indev, struct _lv_disp_t * disp);
void lv_indev_set_disp(lv_indev_t * indev, struct _lv_display_t * disp);
void * lv_indev_get_user_data(const lv_indev_t * indev);

Some files were not shown because too many files have changed in this diff Show More