wandering1/STM32F4-Base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects 1 Releases Wiki Activity

LVGL 库提交

Browse Source
This commit is contained in:
wandering1
2026-08-30 08:57:07 +08:00
parent 26c9098630
commit e2f199c6bf
1056 changed files with 556743 additions and 45 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Lib/lvgl/src/drivers/qnx/lv_qnx.c
+542
View File
@@ -0,0 +1,542 @@
/**
* @file lv_qnx.c
*
*/
/*********************
* INCLUDES
*********************/
#include "lv_qnx.h"
#if LV_USE_QNX
#include <stdbool.h>
#include "../../core/lv_refr.h"
#include "../../stdlib/lv_string.h"
#include "../../core/lv_global.h"
#include "../../display/lv_display_private.h"
#include "../../lv_init.h"
#include <stdlib.h>
#include <time.h>
#include <screen/screen.h>
#include <sys/keycodes.h>
/*********************
* DEFINES
*********************/
/**********************
* TYPEDEFS
**********************/
typedef struct {
screen_window_t window;
screen_buffer_t buffers[LV_QNX_BUF_COUNT];
int bufidx;
bool managed;
lv_indev_t * pointer;
lv_indev_t * keyboard;
} lv_qnx_window_t;
typedef struct {
int pos[2];
int buttons;
} lv_qnx_pointer_t;
typedef struct {
int key;
int flags;
} lv_qnx_keyboard_t;
/**********************
* STATIC PROTOTYPES
**********************/
static uint32_t get_ticks(void);
static void flush_cb(lv_display_t * disp, const lv_area_t * area, uint8_t * color_p);
static bool window_create(lv_display_t * disp);
static bool init_display_from_window(lv_display_t * disp);
static void get_pointer(lv_indev_t * indev, lv_indev_data_t * data);
static void get_key(lv_indev_t * indev, lv_indev_data_t * data);
static bool handle_pointer_event(lv_display_t * disp, screen_event_t event);
static bool handle_keyboard_event(lv_display_t * disp, screen_event_t event);
static void release_disp_cb(lv_event_t * e);
static void refresh_cb(lv_timer_t * timer);
/***********************
* GLOBAL PROTOTYPES
***********************/
static screen_context_t context;
/**********************
* STATIC VARIABLES
**********************/
/**********************
* MACROS
**********************/
/**********************
* GLOBAL FUNCTIONS
**********************/
lv_display_t * lv_qnx_window_create(int32_t hor_res, int32_t ver_res)
{
static bool inited = false;
if(!inited) {
if(screen_create_context(&context,
SCREEN_APPLICATION_CONTEXT) != 0) {
LV_LOG_ERROR("screen_create_context: %s", strerror(errno));
return NULL;
}
lv_tick_set_cb(get_ticks);
inited = true;
}
lv_qnx_window_t * dsc = lv_malloc_zeroed(sizeof(lv_qnx_window_t));
LV_ASSERT_MALLOC(dsc);
if(dsc == NULL) return NULL;
lv_display_t * disp = lv_display_create(hor_res, ver_res);
if(disp == NULL) {
lv_free(dsc);
return NULL;
}
lv_display_add_event_cb(disp, release_disp_cb, LV_EVENT_DELETE, disp);
lv_display_set_driver_data(disp, dsc);
if(!window_create(disp)) {
lv_free(dsc);
return NULL;
}
lv_display_set_flush_cb(disp, flush_cb);
if(!init_display_from_window(disp)) {
screen_destroy_window(dsc->window);
lv_free(dsc);
return NULL;
}
/*Replace the default refresh timer handler, so that we can run it on
*demand instead of constantly.*/
lv_timer_t * refr_timer = lv_display_get_refr_timer(disp);
lv_timer_set_cb(refr_timer, refresh_cb);
return disp;
}
void lv_qnx_window_set_title(lv_display_t * disp, const char * title)
{
lv_qnx_window_t * dsc = lv_display_get_driver_data(disp);
if(!dsc->managed) {
/*Can't set title if there is no window manager*/
return;
}
screen_event_t event;
screen_create_event(&event);
char title_buf[64];
lv_snprintf(title_buf, sizeof(title_buf), "Title=%s", title);
int type = SCREEN_EVENT_MANAGER;
screen_set_event_property_iv(event, SCREEN_PROPERTY_TYPE, &type);
screen_set_event_property_cv(event, SCREEN_PROPERTY_USER_DATA,
sizeof(title_buf), title_buf);
screen_set_event_property_pv(event, SCREEN_PROPERTY_WINDOW,
(void **)&dsc->window);
screen_set_event_property_pv(event, SCREEN_PROPERTY_CONTEXT,
(void **)&context);
screen_inject_event(NULL, event);
}
bool lv_qnx_add_pointer_device(lv_display_t * disp)
{
lv_qnx_window_t * dsc = lv_display_get_driver_data(disp);
if(dsc->pointer != NULL) {
/*Only one pointer device per display*/
return false;
}
lv_qnx_pointer_t * ptr_dsc = lv_malloc_zeroed(sizeof(lv_qnx_pointer_t));
LV_ASSERT_MALLOC(ptr_dsc);
if(ptr_dsc == NULL) {
return false;
}
dsc->pointer = lv_indev_create();
if(dsc->pointer == NULL) {
lv_free(ptr_dsc);
return false;
}
lv_indev_set_type(dsc->pointer, LV_INDEV_TYPE_POINTER);
lv_indev_set_read_cb(dsc->pointer, get_pointer);
lv_indev_set_driver_data(dsc->pointer, ptr_dsc);
lv_indev_set_mode(dsc->pointer, LV_INDEV_MODE_EVENT);
return true;
}
bool lv_qnx_add_keyboard_device(lv_display_t * disp)
{
lv_qnx_window_t * dsc = lv_display_get_driver_data(disp);
if(dsc->keyboard != NULL) {
/*Only one keyboard device per display*/
return false;
}
lv_qnx_keyboard_t * kbd_dsc = lv_malloc_zeroed(sizeof(lv_qnx_keyboard_t));
LV_ASSERT_MALLOC(kbd_dsc);
if(dsc == NULL) {
return false;
}
dsc->keyboard = lv_indev_create();
if(dsc->keyboard == NULL) {
lv_free(kbd_dsc);
return false;
}
lv_indev_set_type(dsc->keyboard, LV_INDEV_TYPE_KEYPAD);
lv_indev_set_read_cb(dsc->keyboard, get_key);
lv_indev_set_driver_data(dsc->keyboard, kbd_dsc);
lv_indev_set_mode(dsc->keyboard, LV_INDEV_MODE_EVENT);
return true;
}
int lv_qnx_event_loop(lv_display_t * disp)
{
lv_refr_now(disp);
/*Run the event loop*/
screen_event_t event;
if(screen_create_event(&event) != 0) {
LV_LOG_ERROR("screen_create_event: %s", strerror(errno));
return EXIT_FAILURE;
}
uint64_t timeout_ns = 0;
for(;;) {
/*Wait for an event, timing out after 16ms if animations are running*/
if(screen_get_event(context, event, timeout_ns) != 0) {
LV_LOG_ERROR("screen_get_event: %s", strerror(errno));
return EXIT_FAILURE;
}
/*Get the event's type*/
int type;
if(screen_get_event_property_iv(event, SCREEN_PROPERTY_TYPE, &type)
!= 0) {
LV_LOG_ERROR("screen_get_event_property_iv(TYPE): %s", strerror(errno));
return EXIT_FAILURE;
}
if(type == SCREEN_EVENT_POINTER) {
if(!handle_pointer_event(disp, event)) {
return EXIT_FAILURE;
}
}
else if(type == SCREEN_EVENT_KEYBOARD) {
if(!handle_keyboard_event(disp, event)) {
return EXIT_FAILURE;
}
}
else if(type == SCREEN_EVENT_MANAGER) {
/*Only sub-type supported is closing the window*/
break;
}
/*Calculate the next timeout*/
uint32_t timeout_ms = lv_timer_handler();
if(timeout_ms == LV_NO_TIMER_READY) {
timeout_ns = -1ULL;
}
else {
timeout_ns = (uint64_t)timeout_ms * 1000000UL;
}
}
return EXIT_SUCCESS;
}
/**********************
* STATIC FUNCTIONS
**********************/
static uint32_t get_ticks(void)
{
uint64_t const ns = clock_gettime_mon_ns();
return (uint32_t)(ns / 1000000UL);
}
static void flush_cb(lv_display_t * disp, const lv_area_t * area, uint8_t * px_map)
{
lv_qnx_window_t * dsc = lv_display_get_driver_data(disp);
if(screen_post_window(dsc->window, dsc->buffers[dsc->bufidx], 0, NULL, 0)
!= 0) {
LV_LOG_ERROR("screen_post_window: %s", strerror(errno));
}
#if (LV_QNX_BUF_COUNT > 1)
dsc->bufidx = 1 - dsc->bufidx;
#endif
lv_display_flush_ready(disp);
}
static bool window_create(lv_display_t * disp)
{
/*Create a window*/
lv_qnx_window_t * dsc = lv_display_get_driver_data(disp);
if(screen_create_window(&dsc->window, context) != 0) {
LV_LOG_ERROR("screen_create_window: %s", strerror(errno));
return false;
}
/*Set window properties*/
int rect[] = { 0, 0, disp->hor_res, disp->ver_res };
if(screen_set_window_property_iv(dsc->window, SCREEN_PROPERTY_POSITION,
&rect[0]) != 0) {
LV_LOG_ERROR("screen_window_set_property_iv(POSITION): %s", strerror(errno));
return false;
}
if(screen_set_window_property_iv(dsc->window, SCREEN_PROPERTY_SIZE,
&rect[2]) != 0) {
LV_LOG_ERROR("screen_window_set_property_iv(SIZE): %s", strerror(errno));
return false;
}
if(screen_set_window_property_iv(dsc->window, SCREEN_PROPERTY_SOURCE_SIZE,
&rect[2]) != 0) {
LV_LOG_ERROR("screen_window_set_property_iv(SOURCE_SIZE): %s", strerror(errno));
return NULL;
}
int usage = SCREEN_USAGE_WRITE;
if(screen_set_window_property_iv(dsc->window, SCREEN_PROPERTY_USAGE,
&usage) != 0) {
LV_LOG_ERROR("screen_window_set_property_iv(USAGE): %s", strerror(errno));
return NULL;
}
int format = SCREEN_FORMAT_RGBA8888;
if(screen_set_window_property_iv(dsc->window, SCREEN_PROPERTY_FORMAT,
&format) != 0) {
LV_LOG_ERROR("screen_window_set_property_iv(USAGE): %s", strerror(errno));
return NULL;
}
/*Initialize window buffers*/
if(screen_create_window_buffers(dsc->window, LV_QNX_BUF_COUNT) != 0) {
LV_LOG_ERROR("screen_create_window_buffers: %s", strerror(errno));
return false;
}
if(screen_get_window_property_pv(dsc->window, SCREEN_PROPERTY_BUFFERS,
(void **)&dsc->buffers) != 0) {
LV_LOG_ERROR("screen_get_window_property_pv(BUFFERS): %s", strerror(errno));
return false;
}
/*Connect to the window manager. Can legitimately fail if one is not running*/
if(screen_manage_window(dsc->window, "Frame=Y") == 0) {
dsc->managed = true;
}
else {
dsc->managed = false;
}
int visible = 1;
if(screen_set_window_property_iv(dsc->window, SCREEN_PROPERTY_VISIBLE,
&visible) != 0) {
LV_LOG_ERROR("screen_set_window_property_iv(VISIBLE): %s", strerror(errno));
return false;
}
return true;
}
static bool init_display_from_window(lv_display_t * disp)
{
lv_qnx_window_t * dsc = lv_display_get_driver_data(disp);
int bufsize;
if(screen_get_buffer_property_iv(dsc->buffers[0], SCREEN_PROPERTY_SIZE,
&bufsize) == -1) {
LV_LOG_ERROR("screen_get_buffer_property_iv(SIZE): %s", strerror(errno));
return false;
}
void * ptr1 = NULL;
if(screen_get_buffer_property_pv(dsc->buffers[0], SCREEN_PROPERTY_POINTER,
&ptr1) == -1) {
LV_LOG_ERROR("screen_get_buffer_property_pv(POINTER): %s", strerror(errno));
return false;
}
void * ptr2 = NULL;
#if (LV_QNX_BUF_COUNT > 1)
if(screen_get_buffer_property_pv(dsc->buffers[1], SCREEN_PROPERTY_POINTER,
&ptr2) == -1) {
LV_LOG_ERROR("screen_get_buffer_property_pv(POINTER): %s", strerror(errno));
return false;
}
#endif
lv_display_set_buffers(disp, ptr1, ptr2, bufsize, LV_DISPLAY_RENDER_MODE_FULL);
return true;
}
static void release_disp_cb(lv_event_t * e)
{
lv_display_t * disp = (lv_display_t *) lv_event_get_user_data(e);
lv_qnx_window_t * dsc = lv_display_get_driver_data(disp);
if(dsc->window != NULL) {
screen_destroy_window(dsc->window);
}
if(dsc->pointer != NULL) {
lv_free(dsc->pointer);
}
if(dsc->keyboard != NULL) {
lv_free(dsc->keyboard);
}
lv_free(dsc);
lv_display_set_driver_data(disp, NULL);
}
static void get_pointer(lv_indev_t * indev, lv_indev_data_t * data)
{
lv_qnx_pointer_t * dsc = lv_indev_get_driver_data(indev);
data->point.x = dsc->pos[0];
data->point.y = dsc->pos[1];
if((dsc->buttons & SCREEN_LEFT_MOUSE_BUTTON) != 0) {
data->state = LV_INDEV_STATE_PRESSED;
}
else {
data->state = LV_INDEV_STATE_RELEASED;
}
}
static bool handle_pointer_event(lv_display_t * disp, screen_event_t event)
{
lv_qnx_window_t * dsc = lv_display_get_driver_data(disp);
if(dsc->pointer == NULL) return true;
lv_qnx_pointer_t * ptr_dsc = lv_indev_get_driver_data(dsc->pointer);
if(screen_get_event_property_iv(event, SCREEN_PROPERTY_SOURCE_POSITION,
ptr_dsc->pos)
!= 0) {
LV_LOG_ERROR("screen_get_event_property_iv(SOURCE_POSITION): %s", strerror(errno));
return false;
}
if(screen_get_event_property_iv(event, SCREEN_PROPERTY_BUTTONS,
&ptr_dsc->buttons)
!= 0) {
LV_LOG_ERROR("screen_get_event_property_iv(BUTTONS): %s", strerror(errno));
return false;
}
lv_indev_read(dsc->pointer);
return true;
}
static void get_key(lv_indev_t * indev, lv_indev_data_t * data)
{
lv_qnx_keyboard_t * dsc = lv_indev_get_driver_data(indev);
if((dsc->flags & KEY_DOWN) != 0) {
data->state = LV_INDEV_STATE_PRESSED;
data->key = dsc->key;
}
else {
data->state = LV_INDEV_STATE_RELEASED;
}
}
static bool handle_keyboard_event(lv_display_t * disp, screen_event_t event)
{
lv_qnx_window_t * dsc = lv_display_get_driver_data(disp);
if(dsc->keyboard == NULL) return true;
lv_qnx_keyboard_t * kbd_dsc = lv_indev_get_driver_data(dsc->keyboard);
/*Get event data*/
if(screen_get_event_property_iv(event, SCREEN_PROPERTY_FLAGS,
&kbd_dsc->flags)
!= 0) {
LV_LOG_ERROR("screen_get_event_property_iv(FLAGS): %s", strerror(errno));
return false;
}
if(screen_get_event_property_iv(event, SCREEN_PROPERTY_SYM,
&kbd_dsc->key)
!= 0) {
LV_LOG_ERROR("screen_get_event_property_iv(SYM): %s", strerror(errno));
return false;
}
/*Translate special keys*/
switch(kbd_dsc->key) {
case KEYCODE_UP:
kbd_dsc->key = LV_KEY_UP;
break;
case KEYCODE_DOWN:
kbd_dsc->key = LV_KEY_DOWN;
break;
case KEYCODE_LEFT:
kbd_dsc->key = LV_KEY_LEFT;
break;
case KEYCODE_RIGHT:
kbd_dsc->key = LV_KEY_RIGHT;
break;
case KEYCODE_RETURN:
kbd_dsc->key = LV_KEY_ENTER;
break;
case KEYCODE_BACKSPACE:
kbd_dsc->key = LV_KEY_BACKSPACE;
break;
case KEYCODE_HOME:
kbd_dsc->key = LV_KEY_HOME;
break;
case KEYCODE_END:
kbd_dsc->key = LV_KEY_END;
break;
case KEYCODE_DELETE:
kbd_dsc->key = LV_KEY_DEL;
break;
default:
/*Ignore other non-ASCII keys, including modifiers*/
if(kbd_dsc->key > 0xff) return true;
}
lv_indev_read(dsc->keyboard);
return true;
}
static void refresh_cb(lv_timer_t * timer)
{
/*Refresh the window on timeout, but disable the timer. Any callback can
*re-enable it.*/
lv_display_t * disp = timer->user_data;
lv_refr_now(disp);
lv_timer_pause(timer);
}
#endif /*LV_USE_QNX*/
Lib/lvgl/src/drivers/qnx/lv_qnx.h
+86
View File
@@ -0,0 +1,86 @@
/**
* @file lv_qnx.h
* @brief LVGL driver for the QNX Screen compositing window manager
*/
#ifndef LV_QNX_H
#define LV_QNX_H
#ifdef __cplusplus
extern "C" {
#endif
/*********************
* INCLUDES
*********************/
#include "../../display/lv_display.h"
#include "../../indev/lv_indev.h"
#if LV_USE_QNX
#include <stdbool.h>
#include <screen/screen.h>
/*********************
* DEFINES
*********************/
/**********************
* TYPEDEFS
**********************/
/**********************
* GLOBAL PROTOTYPES
**********************/
/**
* Create a window to use as a display for LVGL.
* @param hor_res The horizontal resolution (size) of the window
* @param ver_res The vertical resolution (size) of the window
* @return A pointer to a new display object if successful, NULL otherwise
*/
lv_display_t * lv_qnx_window_create(int32_t hor_res, int32_t ver_res);
/**
* Set the title of the window identified by the given display.
* @param disp The display object for the window
* @param title The new title to set
*/
void lv_qnx_window_set_title(lv_display_t * disp, const char * title);
/**
* Create a pointer input device for the display.
* Only one pointer object is currently supported.
* @param disp The display object associated with the device
* @return true if successful, false otherwise
*/
bool lv_qnx_add_pointer_device(lv_display_t * disp);
/**
* Create a keyboard input device for the display.
* Only one keyboard object is currently supported.
* @param disp The display object associated with the device
* @return true if successful, false otherwise
*/
bool lv_qnx_add_keyboard_device(lv_display_t * disp);
/**
* Runs the event loop for the display.
* The function only returns in response to a close event.
* @param disp The display for the event loop
* @return Exit code
*/
int lv_qnx_event_loop(lv_display_t * disp);
/**********************
* MACROS
**********************/
#endif /* LV_DRV_QNX */
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* LV_QNX_H */