Embedded/pikapython
1
0
Fork 0
mirror of https://gitee.com/Lyon1998/pikapython.git synced 2025-01-15 17:02:53 +08:00
Code Issues Packages Projects Releases Wiki Activity

add lvgl to submodule on port/linux for CI

Browse Source 
compile pass for lvgl

support compile lvgl on CI
This commit is contained in:
lyon1998 2024-01-03 23:34:14 +08:00
parent bef27d8ab1
commit 6e44357067
26 changed files with 7605 additions and 8 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
.gitmodules vendored Normal file
View File

@ -0,0 +1,3 @@
[submodule "port/linux/package/lvgl/lvgl"]
path = port/linux/package/lvgl/lvgl
url = https://gitee.com/Lyon1998/lvgl

6
port/linux/CMakeLists.txt
View File

@ -5,6 +5,9 @@ IF(PIKA_CONFIG_ENABLE)
ADD_DEFINITIONS(-DPIKA_CONFIG_ENABLE)
ENDIF(PIKA_CONFIG_ENABLE)
ADD_DEFINITIONS(-DUSE_GOOGLE_TEST=1)
ADD_DEFINITIONS(-DLV_CONF_INCLUDE_SIMPLE=1)
ADD_DEFINITIONS(-DLV_LVGL_H_INCLUDE_SIMPLE=1)
ADD_DEFINITIONS(-DPIKASCRIPT=1)
set (CMAKE_EXPORT_COMPILE_COMMANDS ON)
set(CMAKE_C_STANDARD 99)
set(CMAKE_C_STANDARD_REQUIRED True)
@ -34,6 +37,8 @@ include_directories(package/pikascript/pikascript-lib/PikaNN/TinyMaix/include)
include_directories(package/pikascript/pikascript-lib/PikaStdDevice)
# rbg/kcf add ---
include_directories(package/pikascript/pikascript-lib/flashdb)
include_directories(package/lvgl)
include_directories(package/lvgl/lvgl)
include_directories(test)
@ -42,6 +47,7 @@ include_directories(config)
# include_directories(boot/demo01-led)
add_subdirectory(package/googletest)
add_subdirectory(package/pikascript)
add_subdirectory(package/lvgl)
add_subdirectory(test)
# add_subdirectory(boot/demo01-led)
# add_subdirectory(boot/demo02-add)

5
port/linux/benchmark/CMakeLists.txt
View File

@ -8,6 +8,9 @@ find_package(benchmark REQUIRED)
# 链接src生成的lib库和gtest库
target_link_libraries(${BINARY} PUBLIC
-Wl,--whole-archive ${CMAKE_PROJECT_NAME}-core -Wl,--no-whole-archive
-Wl,--whole-archive
${CMAKE_PROJECT_NAME}-core
${CMAKE_PROJECT_NAME}-lvgl
-Wl,--no-whole-archive
gtest
benchmark::benchmark)

5
port/linux/boot/demo06-pikamain/CMakeLists.txt
View File

@ -4,5 +4,8 @@ set(SOURCES ${THIS_SOURCES})
add_executable(${BINARY} ${THIS_SOURCES})
# 链接src生成的lib库和gtest库
target_link_libraries(${BINARY} PUBLIC
-Wl,--whole-archive ${CMAKE_PROJECT_NAME}-core -Wl,--no-whole-archive
-Wl,--whole-archive
${CMAKE_PROJECT_NAME}-core
${CMAKE_PROJECT_NAME}-lvgl
-Wl,--no-whole-archive
)

4
port/linux/init.sh
View File

@ -2,8 +2,8 @@ ROOT=$PWD
reset
cp config/pika_config_default.h config/pika_config.h
# git submodule init
# git submodule update
git submodule init
git submodule update
git config --unset-all core.filemode
git config --add core.filemode false
chmod +x *.sh

12
port/linux/package/lvgl/CMakeLists.txt Normal file
View File

@ -0,0 +1,12 @@
#设置 BINARY 为项目名IndexProject
set(BINARY ${CMAKE_PROJECT_NAME})
set(CMAKE_C_FLAGS "-Wno-unused-variable")
file(GLOB_RECURSE SOURCES LIST_DIRECTORIES true *.h *.c)
set(SOURCES ${SOURCES})
link_libraries(m)
add_library(${BINARY}-lvgl
STATIC
${SOURCES}
)

784
port/linux/package/lvgl/lv_conf.h Normal file
View File

@ -0,0 +1,784 @@
/**
* @file lv_conf.h
* Configuration file for v8.3.11
*/
/*
* Copy this file as `lv_conf.h`
* 1. simply next to the `lvgl` folder
* 2. or any other places and
* - define `LV_CONF_INCLUDE_SIMPLE`
* - add the path as include path
*/
/* clang-format off */
#if 1 /*Set it to "1" to enable content*/
#ifndef LV_CONF_H
#define LV_CONF_H
#include <stdint.h>
/*====================
COLOR SETTINGS
*====================*/
/*Color depth: 1 (1 byte per pixel), 8 (RGB332), 16 (RGB565), 32 (ARGB8888)*/
#define LV_COLOR_DEPTH 16
/*Swap the 2 bytes of RGB565 color. Useful if the display has an 8-bit interface (e.g. SPI)*/
#define LV_COLOR_16_SWAP 0
/*Enable features to draw on transparent background.
*It's required if opa, and transform_* style properties are used.
*Can be also used if the UI is above another layer, e.g. an OSD menu or video player.*/
#define LV_COLOR_SCREEN_TRANSP 0
/* Adjust color mix functions rounding. GPUs might calculate color mix (blending) differently.
* 0: round down, 64: round up from x.75, 128: round up from half, 192: round up from x.25, 254: round up */
#define LV_COLOR_MIX_ROUND_OFS 0
/*Images pixels with this color will not be drawn if they are chroma keyed)*/
#define LV_COLOR_CHROMA_KEY lv_color_hex(0x00ff00) /*pure green*/
/*=========================
MEMORY SETTINGS
*=========================*/
/*1: use custom malloc/free, 0: use the built-in `lv_mem_alloc()` and `lv_mem_free()`*/
#define LV_MEM_CUSTOM 0
#if LV_MEM_CUSTOM == 0
/*Size of the memory available for `lv_mem_alloc()` in bytes (>= 2kB)*/
#define LV_MEM_SIZE (48U * 1024U) /*[bytes]*/
/*Set an address for the memory pool instead of allocating it as a normal array. Can be in external SRAM too.*/
#define LV_MEM_ADR 0 /*0: unused*/
/*Instead of an address give a memory allocator that will be called to get a memory pool for LVGL. E.g. my_malloc*/
#if LV_MEM_ADR == 0
#undef LV_MEM_POOL_INCLUDE
#undef LV_MEM_POOL_ALLOC
#endif
#else /*LV_MEM_CUSTOM*/
#define LV_MEM_CUSTOM_INCLUDE <stdlib.h> /*Header for the dynamic memory function*/
#define LV_MEM_CUSTOM_ALLOC malloc
#define LV_MEM_CUSTOM_FREE free
#define LV_MEM_CUSTOM_REALLOC realloc
#endif /*LV_MEM_CUSTOM*/
/*Number of the intermediate memory buffer used during rendering and other internal processing mechanisms.
*You will see an error log message if there wasn't enough buffers. */
#define LV_MEM_BUF_MAX_NUM 16
/*Use the standard `memcpy` and `memset` instead of LVGL's own functions. (Might or might not be faster).*/
#define LV_MEMCPY_MEMSET_STD 0
/*====================
HAL SETTINGS
*====================*/
/*Default display refresh period. LVG will redraw changed areas with this period time*/
#define LV_DISP_DEF_REFR_PERIOD 30 /*[ms]*/
/*Input device read period in milliseconds*/
#define LV_INDEV_DEF_READ_PERIOD 30 /*[ms]*/
/*Use a custom tick source that tells the elapsed time in milliseconds.
*It removes the need to manually update the tick with `lv_tick_inc()`)*/
#define LV_TICK_CUSTOM 0
#if LV_TICK_CUSTOM
#define LV_TICK_CUSTOM_INCLUDE "Arduino.h" /*Header for the system time function*/
#define LV_TICK_CUSTOM_SYS_TIME_EXPR (millis()) /*Expression evaluating to current system time in ms*/
/*If using lvgl as ESP32 component*/
// #define LV_TICK_CUSTOM_INCLUDE "esp_timer.h"
// #define LV_TICK_CUSTOM_SYS_TIME_EXPR ((esp_timer_get_time() / 1000LL))
#endif /*LV_TICK_CUSTOM*/
/*Default Dot Per Inch. Used to initialize default sizes such as widgets sized, style paddings.
*(Not so important, you can adjust it to modify default sizes and spaces)*/
#define LV_DPI_DEF 130 /*[px/inch]*/
/*=======================
* FEATURE CONFIGURATION
*=======================*/
/*-------------
* Drawing
*-----------*/
/*Enable complex draw engine.
*Required to draw shadow, gradient, rounded corners, circles, arc, skew lines, image transformations or any masks*/
#define LV_DRAW_COMPLEX 1
#if LV_DRAW_COMPLEX != 0
/*Allow buffering some shadow calculation.
*LV_SHADOW_CACHE_SIZE is the max. shadow size to buffer, where shadow size is `shadow_width + radius`
*Caching has LV_SHADOW_CACHE_SIZE^2 RAM cost*/
#define LV_SHADOW_CACHE_SIZE 0
/* Set number of maximally cached circle data.
* The circumference of 1/4 circle are saved for anti-aliasing
* radius * 4 bytes are used per circle (the most often used radiuses are saved)
* 0: to disable caching */
#define LV_CIRCLE_CACHE_SIZE 4
#endif /*LV_DRAW_COMPLEX*/
/**
* "Simple layers" are used when a widget has `style_opa < 255` to buffer the widget into a layer
* and blend it as an image with the given opacity.
* Note that `bg_opa`, `text_opa` etc don't require buffering into layer)
* The widget can be buffered in smaller chunks to avoid using large buffers.
*
* - LV_LAYER_SIMPLE_BUF_SIZE: [bytes] the optimal target buffer size. LVGL will try to allocate it
* - LV_LAYER_SIMPLE_FALLBACK_BUF_SIZE: [bytes] used if `LV_LAYER_SIMPLE_BUF_SIZE` couldn't be allocated.
*
* Both buffer sizes are in bytes.
* "Transformed layers" (where transform_angle/zoom properties are used) use larger buffers
* and can't be drawn in chunks. So these settings affects only widgets with opacity.
*/
#define LV_LAYER_SIMPLE_BUF_SIZE (24 * 1024)
#define LV_LAYER_SIMPLE_FALLBACK_BUF_SIZE (3 * 1024)
/*Default image cache size. Image caching keeps the images opened.
*If only the built-in image formats are used there is no real advantage of caching. (I.e. if no new image decoder is added)
*With complex image decoders (e.g. PNG or JPG) caching can save the continuous open/decode of images.
*However the opened images might consume additional RAM.
*0: to disable caching*/
#define LV_IMG_CACHE_DEF_SIZE 0
/*Number of stops allowed per gradient. Increase this to allow more stops.
*This adds (sizeof(lv_color_t) + 1) bytes per additional stop*/
#define LV_GRADIENT_MAX_STOPS 2
/*Default gradient buffer size.
*When LVGL calculates the gradient "maps" it can save them into a cache to avoid calculating them again.
*LV_GRAD_CACHE_DEF_SIZE sets the size of this cache in bytes.
*If the cache is too small the map will be allocated only while it's required for the drawing.
*0 mean no caching.*/
#define LV_GRAD_CACHE_DEF_SIZE 0
/*Allow dithering the gradients (to achieve visual smooth color gradients on limited color depth display)
*LV_DITHER_GRADIENT implies allocating one or two more lines of the object's rendering surface
*The increase in memory consumption is (32 bits * object width) plus 24 bits * object width if using error diffusion */
#define LV_DITHER_GRADIENT 0
#if LV_DITHER_GRADIENT
/*Add support for error diffusion dithering.
*Error diffusion dithering gets a much better visual result, but implies more CPU consumption and memory when drawing.
*The increase in memory consumption is (24 bits * object's width)*/
#define LV_DITHER_ERROR_DIFFUSION 0
#endif
/*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)
/*-------------
* GPU
*-----------*/
/*Use Arm's 2D acceleration library Arm-2D */
#define LV_USE_GPU_ARM2D 0
/*Use STM32's DMA2D (aka Chrom Art) GPU*/
#define LV_USE_GPU_STM32_DMA2D 0
#if LV_USE_GPU_STM32_DMA2D
/*Must be defined to include path of CMSIS header of target processor
e.g. "stm32f7xx.h" or "stm32f4xx.h"*/
#define LV_GPU_DMA2D_CMSIS_INCLUDE
#endif
/*Enable RA6M3 G2D GPU*/
#define LV_USE_GPU_RA6M3_G2D 0
#if LV_USE_GPU_RA6M3_G2D
/*include path of target processor
e.g. "hal_data.h"*/
#define LV_GPU_RA6M3_G2D_INCLUDE "hal_data.h"
#endif
/*Use SWM341's DMA2D GPU*/
#define LV_USE_GPU_SWM341_DMA2D 0
#if LV_USE_GPU_SWM341_DMA2D
#define LV_GPU_SWM341_DMA2D_INCLUDE "SWM341.h"
#endif
/*Use NXP's PXP GPU iMX RTxxx platforms*/
#define LV_USE_GPU_NXP_PXP 0
#if LV_USE_GPU_NXP_PXP
/*1: Add default bare metal and FreeRTOS interrupt handling routines for PXP (lv_gpu_nxp_pxp_osa.c)
* and call lv_gpu_nxp_pxp_init() automatically during lv_init(). Note that symbol SDK_OS_FREE_RTOS
* has to be defined in order to use FreeRTOS OSA, otherwise bare-metal implementation is selected.
*0: lv_gpu_nxp_pxp_init() has to be called manually before lv_init()
*/
#define LV_USE_GPU_NXP_PXP_AUTO_INIT 0
#endif
/*Use NXP's VG-Lite GPU iMX RTxxx platforms*/
#define LV_USE_GPU_NXP_VG_LITE 0
/*Use SDL renderer API*/
#define LV_USE_GPU_SDL 0
#if LV_USE_GPU_SDL
#define LV_GPU_SDL_INCLUDE_PATH <SDL2/SDL.h>
/*Texture cache size, 8MB by default*/
#define LV_GPU_SDL_LRU_SIZE (1024 * 1024 * 8)
/*Custom blend mode for mask drawing, disable if you need to link with older SDL2 lib*/
#define LV_GPU_SDL_CUSTOM_BLEND_MODE (SDL_VERSION_ATLEAST(2, 0, 6))
#endif
/*-------------
* Logging
*-----------*/
/*Enable the log module*/
#define LV_USE_LOG 0
#if LV_USE_LOG
/*How important log should be added:
*LV_LOG_LEVEL_TRACE A lot of logs to give detailed information
*LV_LOG_LEVEL_INFO Log important events
*LV_LOG_LEVEL_WARN Log if something unwanted happened but didn't cause a problem
*LV_LOG_LEVEL_ERROR Only critical issue, when the system may fail
*LV_LOG_LEVEL_USER Only logs added by the user
*LV_LOG_LEVEL_NONE Do not log anything*/
#define LV_LOG_LEVEL LV_LOG_LEVEL_WARN
/*1: Print the log with 'printf';
*0: User need to register a callback with `lv_log_register_print_cb()`*/
#define LV_LOG_PRINTF 0
/*Enable/disable LV_LOG_TRACE in modules that produces a huge number of logs*/
#define LV_LOG_TRACE_MEM 1
#define LV_LOG_TRACE_TIMER 1
#define LV_LOG_TRACE_INDEV 1
#define LV_LOG_TRACE_DISP_REFR 1
#define LV_LOG_TRACE_EVENT 1
#define LV_LOG_TRACE_OBJ_CREATE 1
#define LV_LOG_TRACE_LAYOUT 1
#define LV_LOG_TRACE_ANIM 1
#endif /*LV_USE_LOG*/
/*-------------
* Asserts
*-----------*/
/*Enable asserts if an operation is failed or an invalid data is found.
*If LV_USE_LOG is enabled an error message will be printed on failure*/
#define LV_USE_ASSERT_NULL 1 /*Check if the parameter is NULL. (Very fast, recommended)*/
#define LV_USE_ASSERT_MALLOC 1 /*Checks is the memory is successfully allocated or no. (Very fast, recommended)*/
#define LV_USE_ASSERT_STYLE 0 /*Check if the styles are properly initialized. (Very fast, recommended)*/
#define LV_USE_ASSERT_MEM_INTEGRITY 0 /*Check the integrity of `lv_mem` after critical operations. (Slow)*/
#define LV_USE_ASSERT_OBJ 0 /*Check the object's type and existence (e.g. not deleted). (Slow)*/
/*Add a custom handler when assert happens e.g. to restart the MCU*/
#define LV_ASSERT_HANDLER_INCLUDE <stdint.h>
#define LV_ASSERT_HANDLER while(1); /*Halt by default*/
/*-------------
* Others
*-----------*/
/*1: Show CPU usage and FPS count*/
#define LV_USE_PERF_MONITOR 0
#if LV_USE_PERF_MONITOR
#define LV_USE_PERF_MONITOR_POS LV_ALIGN_BOTTOM_RIGHT
#endif
/*1: Show the used memory and the memory fragmentation
* Requires LV_MEM_CUSTOM = 0*/
#define LV_USE_MEM_MONITOR 0
#if LV_USE_MEM_MONITOR
#define LV_USE_MEM_MONITOR_POS LV_ALIGN_BOTTOM_LEFT
#endif
/*1: Draw random colored rectangles over the redrawn areas*/
#define LV_USE_REFR_DEBUG 0
/*Change the built in (v)snprintf functions*/
#define LV_SPRINTF_CUSTOM 0
#if LV_SPRINTF_CUSTOM
#define LV_SPRINTF_INCLUDE <stdio.h>
#define lv_snprintf snprintf
#define lv_vsnprintf vsnprintf
#else /*LV_SPRINTF_CUSTOM*/
#define LV_SPRINTF_USE_FLOAT 0
#endif /*LV_SPRINTF_CUSTOM*/
#define LV_USE_USER_DATA 1
/*Garbage Collector settings
*Used if lvgl is bound to higher level language and the memory is managed by that language*/
#define LV_ENABLE_GC 0
#if LV_ENABLE_GC != 0
#define LV_GC_INCLUDE "gc.h" /*Include Garbage Collector related things*/
#endif /*LV_ENABLE_GC*/
/*=====================
* COMPILER SETTINGS
*====================*/
/*For big endian systems set to 1*/
#define LV_BIG_ENDIAN_SYSTEM 0
/*Define a custom attribute to `lv_tick_inc` function*/
#define LV_ATTRIBUTE_TICK_INC
/*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 LV_ATTRIBUTE_FLUSH_READY
/*Required alignment size for buffers*/
#define LV_ATTRIBUTE_MEM_ALIGN_SIZE 1
/*Will be added where memories needs to be aligned (with -Os data might not be aligned to boundary by default).
* E.g. __attribute__((aligned(4)))*/
#define LV_ATTRIBUTE_MEM_ALIGN
/*Attribute to mark large constant arrays for example font's bitmaps*/
#define LV_ATTRIBUTE_LARGE_CONST
/*Compiler prefix for a big array declaration in RAM*/
#define LV_ATTRIBUTE_LARGE_RAM_ARRAY
/*Place performance critical functions into a faster memory (e.g RAM)*/
#define LV_ATTRIBUTE_FAST_MEM
/*Prefix variables that are used in GPU accelerated operations, often these need to be placed in RAM sections that are DMA accessible*/
#define LV_ATTRIBUTE_DMA
/*Export integer constant to binding. This macro is used with constants in the form of LV_<CONST> that
*should also appear on LVGL binding API such as Micropython.*/
#define LV_EXPORT_CONST_INT(int_value) struct _silence_gcc_warning /*The default value just prevents GCC warning*/
/*Extend the default -32k..32k coordinate range to -4M..4M by using int32_t for coordinates instead of int16_t*/
#define LV_USE_LARGE_COORD 0
/*==================
* FONT USAGE
*===================*/
/*Montserrat fonts with ASCII range and some symbols using bpp = 4
*https://fonts.google.com/specimen/Montserrat*/
#define LV_FONT_MONTSERRAT_8 0
#define LV_FONT_MONTSERRAT_10 0
#define LV_FONT_MONTSERRAT_12 0
#define LV_FONT_MONTSERRAT_14 1
#define LV_FONT_MONTSERRAT_16 0
#define LV_FONT_MONTSERRAT_18 0
#define LV_FONT_MONTSERRAT_20 0
#define LV_FONT_MONTSERRAT_22 0
#define LV_FONT_MONTSERRAT_24 0
#define LV_FONT_MONTSERRAT_26 0
#define LV_FONT_MONTSERRAT_28 0
#define LV_FONT_MONTSERRAT_30 0
#define LV_FONT_MONTSERRAT_32 0
#define LV_FONT_MONTSERRAT_34 0
#define LV_FONT_MONTSERRAT_36 0
#define LV_FONT_MONTSERRAT_38 0
#define LV_FONT_MONTSERRAT_40 0
#define LV_FONT_MONTSERRAT_42 0
#define LV_FONT_MONTSERRAT_44 0
#define LV_FONT_MONTSERRAT_46 0
#define LV_FONT_MONTSERRAT_48 0
/*Demonstrate special features*/
#define LV_FONT_MONTSERRAT_12_SUBPX 0
#define LV_FONT_MONTSERRAT_28_COMPRESSED 0 /*bpp = 3*/
#define LV_FONT_DEJAVU_16_PERSIAN_HEBREW 0 /*Hebrew, Arabic, Persian letters and all their forms*/
#define LV_FONT_SIMSUN_16_CJK 0 /*1000 most common CJK radicals*/
/*Pixel perfect monospace fonts*/
#define LV_FONT_UNSCII_8 0
#define LV_FONT_UNSCII_16 0
/*Optionally declare custom fonts here.
*You can use these fonts as default font too and they will be available globally.
*E.g. #define LV_FONT_CUSTOM_DECLARE LV_FONT_DECLARE(my_font_1) LV_FONT_DECLARE(my_font_2)*/
#define LV_FONT_CUSTOM_DECLARE
/*Always set a default font*/
#define LV_FONT_DEFAULT &lv_font_montserrat_14
/*Enable handling large font and/or fonts with a lot of characters.
*The limit depends on the font size, font face and bpp.
*Compiler error will be triggered if a font needs it.*/
#define LV_FONT_FMT_TXT_LARGE 0
/*Enables/disables support for compressed fonts.*/
#define LV_USE_FONT_COMPRESSED 0
/*Enable subpixel rendering*/
#define LV_USE_FONT_SUBPX 0
#if LV_USE_FONT_SUBPX
/*Set the pixel order of the display. Physical order of RGB channels. Doesn't matter with "normal" fonts.*/
#define LV_FONT_SUBPX_BGR 0 /*0: RGB; 1:BGR order*/
#endif
/*Enable drawing placeholders when glyph dsc is not found*/
#define LV_USE_FONT_PLACEHOLDER 1
/*=================
* TEXT SETTINGS
*=================*/
/**
* Select a character encoding for strings.
* Your IDE or editor should have the same character encoding
* - LV_TXT_ENC_UTF8
* - LV_TXT_ENC_ASCII
*/
#define LV_TXT_ENC LV_TXT_ENC_UTF8
/*Can break (wrap) texts on these chars*/
#define LV_TXT_BREAK_CHARS " ,.;:-_"
/*If a word is at least this long, will break wherever "prettiest"
*To disable, set to a value <= 0*/
#define LV_TXT_LINE_BREAK_LONG_LEN 0
/*Minimum number of characters in a long word to put on a line before a break.
*Depends on LV_TXT_LINE_BREAK_LONG_LEN.*/
#define LV_TXT_LINE_BREAK_LONG_PRE_MIN_LEN 3
/*Minimum number of characters in a long word to put on a line after a break.
*Depends on LV_TXT_LINE_BREAK_LONG_LEN.*/
#define LV_TXT_LINE_BREAK_LONG_POST_MIN_LEN 3
/*The control character to use for signalling text recoloring.*/
#define LV_TXT_COLOR_CMD "#"
/*Support bidirectional texts. Allows mixing Left-to-Right and Right-to-Left texts.
*The direction will be processed according to the Unicode Bidirectional Algorithm:
*https://www.w3.org/International/articles/inline-bidi-markup/uba-basics*/
#define LV_USE_BIDI 0
#if LV_USE_BIDI
/*Set the default direction. Supported values:
*`LV_BASE_DIR_LTR` Left-to-Right
*`LV_BASE_DIR_RTL` Right-to-Left
*`LV_BASE_DIR_AUTO` detect texts base direction*/
#define LV_BIDI_BASE_DIR_DEF LV_BASE_DIR_AUTO
#endif
/*Enable Arabic/Persian processing
*In these languages characters should be replaced with an other form based on their position in the text*/
#define LV_USE_ARABIC_PERSIAN_CHARS 0
/*==================
* WIDGET USAGE
*================*/
/*Documentation of the widgets: https://docs.lvgl.io/latest/en/html/widgets/index.html*/
#define LV_USE_ARC 1
#define LV_USE_BAR 1
#define LV_USE_BTN 1
#define LV_USE_BTNMATRIX 1
#define LV_USE_CANVAS 1
#define LV_USE_CHECKBOX 1
#define LV_USE_DROPDOWN 1 /*Requires: lv_label*/
#define LV_USE_IMG 1 /*Requires: lv_label*/
#define LV_USE_LABEL 1
#if LV_USE_LABEL
#define LV_LABEL_TEXT_SELECTION 1 /*Enable selecting text of the label*/
#define LV_LABEL_LONG_TXT_HINT 1 /*Store some extra info in labels to speed up drawing of very long texts*/
#endif
#define LV_USE_LINE 1
#define LV_USE_ROLLER 1 /*Requires: lv_label*/
#if LV_USE_ROLLER
#define LV_ROLLER_INF_PAGES 7 /*Number of extra "pages" when the roller is infinite*/
#endif
#define LV_USE_SLIDER 1 /*Requires: lv_bar*/
#define LV_USE_SWITCH 1
#define LV_USE_TEXTAREA 1 /*Requires: lv_label*/
#if LV_USE_TEXTAREA != 0
#define LV_TEXTAREA_DEF_PWD_SHOW_TIME 1500 /*ms*/
#endif
#define LV_USE_TABLE 1
/*==================
* EXTRA COMPONENTS
*==================*/
/*-----------
* Widgets
*----------*/
#define LV_USE_ANIMIMG 1
#define LV_USE_CALENDAR 1
#if LV_USE_CALENDAR
#define LV_CALENDAR_WEEK_STARTS_MONDAY 0
#if LV_CALENDAR_WEEK_STARTS_MONDAY
#define LV_CALENDAR_DEFAULT_DAY_NAMES {"Mo", "Tu", "We", "Th", "Fr", "Sa", "Su"}
#else
#define LV_CALENDAR_DEFAULT_DAY_NAMES {"Su", "Mo", "Tu", "We", "Th", "Fr", "Sa"}
#endif
#define LV_CALENDAR_DEFAULT_MONTH_NAMES {"January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"}
#define LV_USE_CALENDAR_HEADER_ARROW 1
#define LV_USE_CALENDAR_HEADER_DROPDOWN 1
#endif /*LV_USE_CALENDAR*/
#define LV_USE_CHART 1
#define LV_USE_COLORWHEEL 1
#define LV_USE_IMGBTN 1
#define LV_USE_KEYBOARD 1
#define LV_USE_LED 1
#define LV_USE_LIST 1
#define LV_USE_MENU 1
#define LV_USE_METER 1
#define LV_USE_MSGBOX 1
#define LV_USE_SPAN 1
#if LV_USE_SPAN
/*A line text can contain maximum num of span descriptor */
#define LV_SPAN_SNIPPET_STACK_SIZE 64
#endif
#define LV_USE_SPINBOX 1
#define LV_USE_SPINNER 1
#define LV_USE_TABVIEW 1
#define LV_USE_TILEVIEW 1
#define LV_USE_WIN 1
/*-----------
* Themes
*----------*/
/*A simple, impressive and very complete theme*/
#define LV_USE_THEME_DEFAULT 1
#if LV_USE_THEME_DEFAULT
/*0: Light mode; 1: Dark mode*/
#define LV_THEME_DEFAULT_DARK 0
/*1: Enable grow on press*/
#define LV_THEME_DEFAULT_GROW 1
/*Default transition time in [ms]*/
#define LV_THEME_DEFAULT_TRANSITION_TIME 80
#endif /*LV_USE_THEME_DEFAULT*/
/*A very simple theme that is a good starting point for a custom theme*/
#define LV_USE_THEME_BASIC 1
/*A theme designed for monochrome displays*/
#define LV_USE_THEME_MONO 1
/*-----------
* Layouts
*----------*/
/*A layout similar to Flexbox in CSS.*/
#define LV_USE_FLEX 1
/*A layout similar to Grid in CSS.*/
#define LV_USE_GRID 1
/*---------------------
* 3rd party libraries
*--------------------*/
/*File system interfaces for common APIs */
/*API for fopen, fread, etc*/
#define LV_USE_FS_STDIO 0
#if LV_USE_FS_STDIO
#define LV_FS_STDIO_LETTER '\0' /*Set an upper cased letter on which the drive will accessible (e.g. 'A')*/
#define LV_FS_STDIO_PATH "" /*Set the working directory. File/directory paths will be appended to it.*/
#define LV_FS_STDIO_CACHE_SIZE 0 /*>0 to cache this number of bytes in lv_fs_read()*/
#endif
/*API for open, read, etc*/
#define LV_USE_FS_POSIX 0
#if LV_USE_FS_POSIX
#define LV_FS_POSIX_LETTER '\0' /*Set an upper cased letter on which the drive will accessible (e.g. 'A')*/
#define LV_FS_POSIX_PATH "" /*Set the working directory. File/directory paths will be appended to it.*/
#define LV_FS_POSIX_CACHE_SIZE 0 /*>0 to cache this number of bytes in lv_fs_read()*/
#endif
/*API for CreateFile, ReadFile, etc*/
#define LV_USE_FS_WIN32 0
#if LV_USE_FS_WIN32
#define LV_FS_WIN32_LETTER '\0' /*Set an upper cased letter on which the drive will accessible (e.g. 'A')*/
#define LV_FS_WIN32_PATH "" /*Set the working directory. File/directory paths will be appended to it.*/
#define LV_FS_WIN32_CACHE_SIZE 0 /*>0 to cache this number of bytes in lv_fs_read()*/
#endif
/*API for FATFS (needs to be added separately). Uses f_open, f_read, etc*/
#define LV_USE_FS_FATFS 0
#if LV_USE_FS_FATFS
#define LV_FS_FATFS_LETTER '\0' /*Set an upper cased letter on which the drive will accessible (e.g. 'A')*/
#define LV_FS_FATFS_CACHE_SIZE 0 /*>0 to cache this number of bytes in lv_fs_read()*/
#endif
/*API for LittleFS (library needs to be added separately). Uses lfs_file_open, lfs_file_read, etc*/
#define LV_USE_FS_LITTLEFS 0
#if LV_USE_FS_LITTLEFS
#define LV_FS_LITTLEFS_LETTER '\0' /*Set an upper cased letter on which the drive will accessible (e.g. 'A')*/
#define LV_FS_LITTLEFS_CACHE_SIZE 0 /*>0 to cache this number of bytes in lv_fs_read()*/
#endif
/*PNG decoder library*/
#define LV_USE_PNG 1
/*BMP decoder library*/
#define LV_USE_BMP 0
/* JPG + split JPG decoder library.
* Split JPG is a custom format optimized for embedded systems. */
#define LV_USE_SJPG 0
/*GIF decoder library*/
#define LV_USE_GIF 0
/*QR code library*/
#define LV_USE_QRCODE 0
/*FreeType library*/
#define LV_USE_FREETYPE 0
#if LV_USE_FREETYPE
/*Memory used by FreeType to cache characters [bytes] (-1: no caching)*/
#define LV_FREETYPE_CACHE_SIZE (16 * 1024)
#if LV_FREETYPE_CACHE_SIZE >= 0
/* 1: bitmap cache use the sbit cache, 0:bitmap cache use the image cache. */
/* sbit cache:it is much more memory efficient for small bitmaps(font size < 256) */
/* if font size >= 256, must be configured as image cache */
#define LV_FREETYPE_SBIT_CACHE 0
/* Maximum number of opened FT_Face/FT_Size objects managed by this cache instance. */
/* (0:use system defaults) */
#define LV_FREETYPE_CACHE_FT_FACES 0
#define LV_FREETYPE_CACHE_FT_SIZES 0
#endif
#endif
/*Tiny TTF library*/
#define LV_USE_TINY_TTF 0
#if LV_USE_TINY_TTF
/*Load TTF data from files*/
#define LV_TINY_TTF_FILE_SUPPORT 0
#endif
/*Rlottie library*/
#define LV_USE_RLOTTIE 0
/*FFmpeg library for image decoding and playing videos
*Supports all major image formats so do not enable other image decoder with it*/
#define LV_USE_FFMPEG 0
#if LV_USE_FFMPEG
/*Dump input information to stderr*/
#define LV_FFMPEG_DUMP_FORMAT 0
#endif
/*-----------
* Others
*----------*/
/*1: Enable API to take snapshot for object*/
#define LV_USE_SNAPSHOT 0
/*1: Enable Monkey test*/
#define LV_USE_MONKEY 0
/*1: Enable grid navigation*/
#define LV_USE_GRIDNAV 0
/*1: Enable lv_obj fragment*/
#define LV_USE_FRAGMENT 0
/*1: Support using images as font in label or span widgets */
#define LV_USE_IMGFONT 0
/*1: Enable a published subscriber based messaging system */
#define LV_USE_MSG 0
/*1: Enable Pinyin input method*/
/*Requires: lv_keyboard*/
#define LV_USE_IME_PINYIN 0
#if LV_USE_IME_PINYIN
/*1: Use default thesaurus*/
/*If you do not use the default thesaurus, be sure to use `lv_ime_pinyin` after setting the thesauruss*/
#define LV_IME_PINYIN_USE_DEFAULT_DICT 1
/*Set the maximum number of candidate panels that can be displayed*/
/*This needs to be adjusted according to the size of the screen*/
#define LV_IME_PINYIN_CAND_TEXT_NUM 6
/*Use 9 key input(k9)*/
#define LV_IME_PINYIN_USE_K9_MODE 1
#if LV_IME_PINYIN_USE_K9_MODE == 1
#define LV_IME_PINYIN_K9_CAND_TEXT_NUM 3
#endif // LV_IME_PINYIN_USE_K9_MODE
#endif
/*==================
* EXAMPLES
*==================*/
/*Enable the examples to be built with the library*/
#define LV_BUILD_EXAMPLES 1
/*===================
* DEMO USAGE
====================*/
/*Show some widget. It might be required to increase `LV_MEM_SIZE` */
#define LV_USE_DEMO_WIDGETS 0
#if LV_USE_DEMO_WIDGETS
#define LV_DEMO_WIDGETS_SLIDESHOW 0
#endif
/*Demonstrate the usage of encoder and keyboard*/
#define LV_USE_DEMO_KEYPAD_AND_ENCODER 0
/*Benchmark your system*/
#define LV_USE_DEMO_BENCHMARK 0
#if LV_USE_DEMO_BENCHMARK
/*Use RGB565A8 images with 16 bit color depth instead of ARGB8565*/
#define LV_DEMO_BENCHMARK_RGB565A8 0
#endif
/*Stress test for LVGL*/
#define LV_USE_DEMO_STRESS 0
/*Music player demo*/
#define LV_USE_DEMO_MUSIC 0
#if LV_USE_DEMO_MUSIC
#define LV_DEMO_MUSIC_SQUARE 0
#define LV_DEMO_MUSIC_LANDSCAPE 0
#define LV_DEMO_MUSIC_ROUND 0
#define LV_DEMO_MUSIC_LARGE 0
#define LV_DEMO_MUSIC_AUTO_PLAY 0
#endif
/*--END OF LV_CONF_H--*/
#endif /*LV_CONF_H*/
#endif /*End of "Content enable"*/

4
port/linux/package/lvgl/lv_port.c Normal file
View File

@ -0,0 +1,4 @@
void user_lvgl_init(void) {
return;
}

1
port/linux/package/lvgl/lvgl Submodule

@ -0,0 +1 @@
Subproject commit 74d0a816a440eea53e030c4f1af842a94f7ce3d3

2
port/linux/package/pikascript/CMakeLists.txt
View File

@ -5,7 +5,7 @@ file(GLOB_RECURSE SOURCES LIST_DIRECTORIES true *.h *.c)
set(SOURCES ${SOURCES})
# support <math.h>
link_libraries(m lua5.3 pthread mbedcrypto)
link_libraries(m lua5.3 pthread mbedcrypto ${BINARY}-lvgl)
add_library(${BINARY}-core
STATIC

3
port/linux/package/pikascript/module_list.txt
View File

@ -41,4 +41,5 @@ this
fsm
subsrc.mod1
flashdb
fuzzypid
fuzzypid
pika_lvgl

1349
port/linux/package/pikascript/pika_lvgl.pyi Normal file
View File

File diff suppressed because it is too large Load Diff

9
port/linux/package/pikascript/pikascript-lib/pika_lvgl/README.md Normal file
View File

@ -0,0 +1,9 @@
# PikaPython LVGL package
## Dependency
- lvgl v8.3.1
## Global Macro
- PIKASCRIPT=1

534
port/linux/package/pikascript/pikascript-lib/pika_lvgl/pika_lvgl.c Normal file
View File

@ -0,0 +1,534 @@
#if defined(LV_LVGL_H_INCLUDE_SIMPLE)
#include "lvgl.h"
#else
#include "../../lvgl.h"
#endif
#ifdef PIKASCRIPT
#include "BaseObj.h"
#include "pika_lvgl.h"
#include "pika_lvgl_ALIGN.h"
#include "pika_lvgl_ANIM.h"
#include "pika_lvgl_EVENT.h"
#include "pika_lvgl_FLEX_ALIGN.h"
#include "pika_lvgl_FLEX_FLOW.h"
#include "pika_lvgl_LAYOUT_FLEX.h"
#include "pika_lvgl_OPA.h"
#include "pika_lvgl_PALETTE.h"
#include "pika_lvgl_SIZE.h"
#include "pika_lvgl_STATE.h"
#include "pika_lvgl_TEXT_DECOR.h"
#include "pika_lvgl_arc.h"
#include "pika_lvgl_common.h"
#include "pika_lvgl_flag_t.h"
#include "pika_lvgl_indev_t.h"
#include "pika_lvgl_lv_color_t.h"
#include "pika_lvgl_lv_obj.h"
#include "pika_lvgl_lv_timer_t.h"
PikaObj* pika_lv_event_listener_g;
Args* pika_lv_id_register_g;
pika_platform_thread_mutex_t pika_lv_global_mutex_g = {0};
#if !PIKASCRIPT_VERSION_REQUIRE_MINIMUN(1, 13, 1)
#error "pikascript version must be greater than 1.13.1"
#endif
volatile int g_lvgl_inited = 0;
void pika_lvgl_STATE___init__(PikaObj* self) {
obj_setInt(self, "DEFAULT", LV_STATE_DEFAULT);
obj_setInt(self, "CHECKED", LV_STATE_CHECKED);
obj_setInt(self, "FOCUSED", LV_STATE_FOCUSED);
obj_setInt(self, "FOCUS_KEY", LV_STATE_FOCUS_KEY);
obj_setInt(self, "EDITED", LV_STATE_EDITED);
obj_setInt(self, "HOVERED", LV_STATE_HOVERED);
obj_setInt(self, "PRESSED", LV_STATE_PRESSED);
obj_setInt(self, "SCROLLED", LV_STATE_SCROLLED);
obj_setInt(self, "DISABLED", LV_STATE_DISABLED);
obj_setInt(self, "USER_1", LV_STATE_USER_1);
obj_setInt(self, "USER_2", LV_STATE_USER_2);
obj_setInt(self, "USER_3", LV_STATE_USER_3);
obj_setInt(self, "USER_4", LV_STATE_USER_4);
obj_setInt(self, "ANY", LV_STATE_ANY);
}
void pika_lvgl_lock(PikaObj* self) {
#if PIKA_LVGL_THREAD_LOCK_ENABLE
if (!g_lvgl_inited) {
return;
}
pika_platform_thread_mutex_lock(&pika_lv_global_mutex_g);
#else
return;
#endif
}
void pika_lvgl_unlock(PikaObj* self) {
#if PIKA_LVGL_THREAD_LOCK_ENABLE
if (!g_lvgl_inited) {
return;
}
pika_platform_thread_mutex_unlock(&pika_lv_global_mutex_g);
#else
return;
#endif
}
void pika_lvgl_flag_t___init__(PikaObj* self) {
obj_setInt(self, "HIDDEN", LV_OBJ_FLAG_HIDDEN);
obj_setInt(self, "CLICKABLE", LV_OBJ_FLAG_CLICKABLE);
obj_setInt(self, "CLICK_FOCUSABLE", LV_OBJ_FLAG_CLICK_FOCUSABLE);
obj_setInt(self, "CHECKABLE", LV_OBJ_FLAG_CHECKABLE);
obj_setInt(self, "SCROLLABLE", LV_OBJ_FLAG_SCROLLABLE);
obj_setInt(self, "SCROLL_ELASTIC", LV_OBJ_FLAG_SCROLL_ELASTIC);
obj_setInt(self, "SCROLL_MOMENTUM", LV_OBJ_FLAG_SCROLL_MOMENTUM);
obj_setInt(self, "SCROLL_ONE", LV_OBJ_FLAG_SCROLL_ONE);
obj_setInt(self, "SCROLL_CHAIN_HOR", LV_OBJ_FLAG_SCROLL_CHAIN_HOR);
obj_setInt(self, "SCROLL_CHAIN_VER", LV_OBJ_FLAG_SCROLL_CHAIN_VER);
obj_setInt(self, "SCROLL_CHAIN", LV_OBJ_FLAG_SCROLL_CHAIN);
obj_setInt(self, "SCROLL_ON_FOCUS", LV_OBJ_FLAG_SCROLL_ON_FOCUS);
obj_setInt(self, "SCROLL_WITH_ARROW", LV_OBJ_FLAG_SCROLL_WITH_ARROW);
obj_setInt(self, "SNAPPABLE", LV_OBJ_FLAG_SNAPPABLE);
obj_setInt(self, "PRESS_LOCK", LV_OBJ_FLAG_PRESS_LOCK);
obj_setInt(self, "EVENT_BUBBLE", LV_OBJ_FLAG_EVENT_BUBBLE);
obj_setInt(self, "GESTURE_BUBBLE", LV_OBJ_FLAG_GESTURE_BUBBLE);
obj_setInt(self, "ADV_HITTEST", LV_OBJ_FLAG_ADV_HITTEST);
obj_setInt(self, "IGNORE_LAYOUT", LV_OBJ_FLAG_IGNORE_LAYOUT);
obj_setInt(self, "FLOATING", LV_OBJ_FLAG_FLOATING);
obj_setInt(self, "OVERFLOW_VISIBLE", LV_OBJ_FLAG_OVERFLOW_VISIBLE);
obj_setInt(self, "LAYOUT_1", LV_OBJ_FLAG_LAYOUT_1);
obj_setInt(self, "LAYOUT_2", LV_OBJ_FLAG_LAYOUT_2);
obj_setInt(self, "WIDGET_1", LV_OBJ_FLAG_WIDGET_1);
obj_setInt(self, "WIDGET_2", LV_OBJ_FLAG_WIDGET_2);
obj_setInt(self, "USER_1", LV_OBJ_FLAG_USER_1);
obj_setInt(self, "USER_2", LV_OBJ_FLAG_USER_2);
obj_setInt(self, "USER_3", LV_OBJ_FLAG_USER_3);
obj_setInt(self, "USER_4", LV_OBJ_FLAG_USER_4);
}
void pika_lvgl_TEXT_DECOR___init__(PikaObj* self) {
obj_setInt(self, "NONE", LV_TEXT_DECOR_NONE);
obj_setInt(self, "UNDERLINE", LV_TEXT_DECOR_UNDERLINE);
obj_setInt(self, "STRIKETHROUGH", LV_TEXT_DECOR_STRIKETHROUGH);
}
void pika_lvgl_ANIM___init__(PikaObj* self) {
obj_setInt(self, "ON", LV_ANIM_ON);
obj_setInt(self, "OFF", LV_ANIM_OFF);
}
void pika_lvgl_ALIGN___init__(PikaObj* self) {
obj_setInt(self, "CENTER", LV_ALIGN_CENTER);
obj_setInt(self, "DEFAULT", LV_ALIGN_DEFAULT);
obj_setInt(self, "TOP_LEFT", LV_ALIGN_TOP_LEFT);
obj_setInt(self, "TOP_MID", LV_ALIGN_TOP_MID);
obj_setInt(self, "TOP_RIGHT", LV_ALIGN_TOP_RIGHT);
obj_setInt(self, "BOTTOM_LEFT", LV_ALIGN_BOTTOM_LEFT);
obj_setInt(self, "BOTTOM_MID", LV_ALIGN_BOTTOM_MID);
obj_setInt(self, "BOTTOM_RIGHT", LV_ALIGN_BOTTOM_RIGHT);
obj_setInt(self, "LEFT_MID", LV_ALIGN_LEFT_MID);
obj_setInt(self, "RIGHT_MID", LV_ALIGN_RIGHT_MID);
obj_setInt(self, "OUT_TOP_LEFT", LV_ALIGN_OUT_TOP_LEFT);
obj_setInt(self, "OUT_TOP_MID", LV_ALIGN_OUT_TOP_MID);
obj_setInt(self, "OUT_TOP_RIGHT", LV_ALIGN_OUT_TOP_RIGHT);
obj_setInt(self, "OUT_BOTTOM_LEFT", LV_ALIGN_OUT_BOTTOM_LEFT);
obj_setInt(self, "OUT_BOTTOM_MID", LV_ALIGN_OUT_BOTTOM_MID);
obj_setInt(self, "OUT_BOTTOM_RIGHT", LV_ALIGN_OUT_BOTTOM_RIGHT);
obj_setInt(self, "OUT_LEFT_TOP", LV_ALIGN_OUT_LEFT_TOP);
obj_setInt(self, "OUT_LEFT_MID", LV_ALIGN_OUT_LEFT_MID);
obj_setInt(self, "OUT_LEFT_BOTTOM", LV_ALIGN_OUT_LEFT_BOTTOM);
obj_setInt(self, "OUT_RIGHT_TOP", LV_ALIGN_OUT_RIGHT_TOP);
obj_setInt(self, "OUT_RIGHT_MID", LV_ALIGN_OUT_RIGHT_MID);
obj_setInt(self, "OUT_RIGHT_BOTTOM", LV_ALIGN_OUT_RIGHT_BOTTOM);
}
void pika_lvgl_EVENT___init__(PikaObj* self) {
obj_setInt(self, "ALL", LV_EVENT_ALL);
obj_setInt(self, "PRESSED", LV_EVENT_PRESSED);
obj_setInt(self, "PRESSING", LV_EVENT_PRESSING);
obj_setInt(self, "PRESS_LOST", LV_EVENT_PRESS_LOST);
obj_setInt(self, "SHORT_CLICKED", LV_EVENT_SHORT_CLICKED);
obj_setInt(self, "LONG_PRESSED", LV_EVENT_LONG_PRESSED);
obj_setInt(self, "LONG_PRESSED_REPEAT", LV_EVENT_LONG_PRESSED_REPEAT);
obj_setInt(self, "CLICKED", LV_EVENT_CLICKED);
obj_setInt(self, "RELEASED", LV_EVENT_RELEASED);
obj_setInt(self, "SCROLL_BEGIN", LV_EVENT_SCROLL_BEGIN);
obj_setInt(self, "SCROLL_END", LV_EVENT_SCROLL_END);
obj_setInt(self, "SCROLL", LV_EVENT_SCROLL);
obj_setInt(self, "GESTURE", LV_EVENT_GESTURE);
obj_setInt(self, "KEY", LV_EVENT_KEY);
obj_setInt(self, "FOCUSED", LV_EVENT_FOCUSED);
obj_setInt(self, "DEFOCUSED", LV_EVENT_DEFOCUSED);
obj_setInt(self, "LEAVE", LV_EVENT_LEAVE);
obj_setInt(self, "HIT_TEST", LV_EVENT_HIT_TEST);
obj_setInt(self, "COVER_CHECK", LV_EVENT_COVER_CHECK);
obj_setInt(self, "REFR_EXT_DRAW_SIZE", LV_EVENT_REFR_EXT_DRAW_SIZE);
obj_setInt(self, "DRAW_MAIN_BEGIN", LV_EVENT_DRAW_MAIN_BEGIN);
obj_setInt(self, "DRAW_MAIN", LV_EVENT_DRAW_MAIN);
obj_setInt(self, "DRAW_MAIN_END", LV_EVENT_DRAW_MAIN_END);
obj_setInt(self, "DRAW_POST_BEGIN", LV_EVENT_DRAW_POST_BEGIN);
obj_setInt(self, "DRAW_POST", LV_EVENT_DRAW_POST);
obj_setInt(self, "DRAW_POST_END", LV_EVENT_DRAW_POST_END);
obj_setInt(self, "DRAW_PART_BEGIN", LV_EVENT_DRAW_PART_BEGIN);
obj_setInt(self, "DRAW_PART_END", LV_EVENT_DRAW_PART_END);
obj_setInt(self, "VALUE_CHANGED", LV_EVENT_VALUE_CHANGED);
obj_setInt(self, "INSERT", LV_EVENT_INSERT);
obj_setInt(self, "REFRESH", LV_EVENT_REFRESH);
obj_setInt(self, "READY", LV_EVENT_READY);
obj_setInt(self, "CANCEL", LV_EVENT_CANCEL);
obj_setInt(self, "DELETE", LV_EVENT_DELETE);
obj_setInt(self, "CHILD_CHANGED", LV_EVENT_CHILD_CHANGED);
obj_setInt(self, "CHILD_CREATED", LV_EVENT_CHILD_CREATED);
obj_setInt(self, "CHILD_DELETED", LV_EVENT_CHILD_DELETED);
obj_setInt(self, "SCREEN_UNLOAD_START", LV_EVENT_SCREEN_UNLOAD_START);
obj_setInt(self, "SCREEN_LOAD_START", LV_EVENT_SCREEN_LOAD_START);
obj_setInt(self, "SCREEN_LOADED", LV_EVENT_SCREEN_LOADED);
obj_setInt(self, "SCREEN_UNLOADED", LV_EVENT_SCREEN_UNLOADED);
obj_setInt(self, "SIZE_CHANGED", LV_EVENT_SIZE_CHANGED);
obj_setInt(self, "STYLE_CHANGED", LV_EVENT_STYLE_CHANGED);
obj_setInt(self, "LAYOUT_CHANGED", LV_EVENT_LAYOUT_CHANGED);
obj_setInt(self, "GET_SELF_SIZE", LV_EVENT_GET_SELF_SIZE);
obj_setInt(self, "PREPROCESS", LV_EVENT_PREPROCESS);
}
void pika_lvgl_OPA___init__(PikaObj* self) {
obj_setInt(self, "TRANSP", LV_OPA_TRANSP);
obj_setInt(self, "COVER", LV_OPA_COVER);
}
void pika_lvgl_PALETTE___init__(PikaObj* self) {
obj_setInt(self, "RED", LV_PALETTE_RED);
obj_setInt(self, "PINK", LV_PALETTE_PINK);
obj_setInt(self, "PURPLE", LV_PALETTE_PURPLE);
obj_setInt(self, "DEEP_PURPLE", LV_PALETTE_DEEP_PURPLE);
obj_setInt(self, "INDIGO", LV_PALETTE_INDIGO);
obj_setInt(self, "BLUE", LV_PALETTE_BLUE);
obj_setInt(self, "LIGHT_BLUE", LV_PALETTE_LIGHT_BLUE);
obj_setInt(self, "CYAN", LV_PALETTE_CYAN);
obj_setInt(self, "TEAL", LV_PALETTE_TEAL);
obj_setInt(self, "GREEN", LV_PALETTE_GREEN);
obj_setInt(self, "LIGHT_GREEN", LV_PALETTE_LIGHT_GREEN);
obj_setInt(self, "LIME", LV_PALETTE_LIME);
obj_setInt(self, "YELLOW", LV_PALETTE_YELLOW);
obj_setInt(self, "AMBER", LV_PALETTE_AMBER);
obj_setInt(self, "ORANGE", LV_PALETTE_ORANGE);
obj_setInt(self, "DEEP_ORANGE", LV_PALETTE_DEEP_ORANGE);
obj_setInt(self, "BROWN", LV_PALETTE_BROWN);
obj_setInt(self, "BLUE_GREY", LV_PALETTE_BLUE_GREY);
obj_setInt(self, "GREY", LV_PALETTE_GREY);
obj_setInt(self, "NONE", LV_PALETTE_NONE);
}
PikaObj* pika_lvgl_scr_act(PikaObj* self) {
PikaObj* new_obj = newNormalObj(New_pika_lvgl_lv_obj);
lv_obj_t* lv_obj = lv_scr_act();
obj_setPtr(new_obj, "lv_obj", lv_obj);
return new_obj;
}
void user_lvgl_init(void);
void pika_lvgl___init__(PikaObj* self) {
user_lvgl_init();
if (!lv_is_initialized()) {
pika_debug("Error: lvgl is not initialized");
return;
}
obj_newDirectObj(self, "lv_event_listener", New_TinyObj);
pika_lv_event_listener_g = obj_getObj(self, "lv_event_listener");
pika_lv_id_register_g = New_args(NULL);
if (!g_lvgl_inited) {
#if PIKA_LVGL_THREAD_LOCK_ENABLE
pika_debug("Init pika_lv_global_mutex_g");
pika_platform_thread_mutex_init(&pika_lv_global_mutex_g);
#endif
pika_lvgl_lock(NULL);
lv_png_init();
pika_lvgl_unlock(NULL);
g_lvgl_inited = 1;
}
}
void pika_lvgl___del__(PikaObj* self) {
args_deinit(pika_lv_id_register_g);
}
void pika_lvgl_obj___init__(PikaObj* self, PikaTuple* parent) {
PikaObj* parent_obj = NULL;
if (NULL == parent) {
void pika_lvgl_flag_tMethod(PikaObj * self, Args * args);
class_defineConstructor(self, "FLAG", "", pika_lvgl_flag_tMethod);
return;
}
if (pikaTuple_getSize(parent) == 1) {
parent_obj = pikaTuple_getPtr(parent, 0);
lv_obj_t* lv_parent = obj_getPtr(parent_obj, "lv_obj");
lv_obj_t* lv_obj = lv_obj_create(lv_parent);
obj_setPtr(self, "lv_obj", lv_obj);
return;
}
}
PikaObj* pika_lvgl_palette_lighten(PikaObj* self, int p, int lvl) {
PikaObj* new_obj = newNormalObj(New_pika_lvgl_lv_color_t);
lv_color_t lv_color = lv_palette_lighten(p, lvl);
args_setStruct(new_obj->list, "lv_color_struct", lv_color);
lv_color_t* plv_color = args_getStruct(new_obj->list, "lv_color_struct");
obj_setPtr(new_obj, "lv_color", plv_color);
return new_obj;
}
PikaObj* pika_lvgl_palette_darken(PikaObj* self, int p, int lvl) {
PikaObj* new_obj = newNormalObj(New_pika_lvgl_lv_color_t);
lv_color_t lv_color = lv_palette_darken(p, lvl);
args_setStruct(new_obj->list, "lv_color_struct", lv_color);
lv_color_t* plv_color = args_getStruct(new_obj->list, "lv_color_struct");
obj_setPtr(new_obj, "lv_color", plv_color);
return new_obj;
}
PikaObj* pika_lvgl_lv_color_hex(PikaObj* self, int64_t hex) {
PikaObj* new_obj = newNormalObj(New_pika_lvgl_lv_color_t);
lv_color_t lv_color = lv_color_hex(hex);
args_setStruct(new_obj->list, "lv_color_struct", lv_color);
lv_color_t* plv_color = args_getStruct(new_obj->list, "lv_color_struct");
obj_setPtr(new_obj, "lv_color", plv_color);
return new_obj;
}
PikaObj* pika_lvgl_palette_main(PikaObj* self, int p) {
PikaObj* new_obj = newNormalObj(New_pika_lvgl_lv_color_t);
lv_color_t lv_color = lv_palette_main(p);
args_setStruct(new_obj->list, "lv_color_struct", lv_color);
obj_setPtr(new_obj, "lv_color",
args_getStruct(new_obj->list, "lv_color_struct"));
return new_obj;
}
PikaObj* pika_lvgl_indev_get_act(PikaObj* self) {
PikaObj* new_obj = newNormalObj(New_pika_lvgl_indev_t);
lv_indev_t* lv_indev = lv_indev_get_act();
obj_setPtr(new_obj, "lv_indev", lv_indev);
return new_obj;
}
PikaObj* pika_lvgl_timer_create_basic(PikaObj* self) {
PikaObj* new_obj = newNormalObj(New_pika_lvgl_lv_timer_t);
lv_timer_t* lv_timer = lv_timer_create_basic();
obj_setPtr(new_obj, "lv_timer", lv_timer);
return new_obj;
}
void pika_lvgl_FLEX_FLOW___init__(PikaObj* self) {
obj_setInt(self, "ROW", LV_FLEX_FLOW_ROW);
obj_setInt(self, "COLUMN", LV_FLEX_FLOW_COLUMN);
obj_setInt(self, "ROW_WRAP", LV_FLEX_FLOW_ROW_WRAP);
obj_setInt(self, "ROW_REVERSE", LV_FLEX_FLOW_ROW_REVERSE);
obj_setInt(self, "ROW_WRAP_REVERSE", LV_FLEX_FLOW_ROW_WRAP_REVERSE);
obj_setInt(self, "COLUMN_WRAP", LV_FLEX_FLOW_COLUMN_WRAP);
obj_setInt(self, "COLUMN_REVERSE", LV_FLEX_FLOW_COLUMN_REVERSE);
obj_setInt(self, "COLUMN_WRAP_REVERSE", LV_FLEX_FLOW_COLUMN_WRAP_REVERSE);
}
void pika_lvgl_FLEX_ALIGN___init__(PikaObj* self) {
obj_setInt(self, "START", LV_FLEX_ALIGN_START);
obj_setInt(self, "END", LV_FLEX_ALIGN_END);
obj_setInt(self, "CENTER", LV_FLEX_ALIGN_CENTER);
obj_setInt(self, "SPACE_EVENLY", LV_FLEX_ALIGN_SPACE_EVENLY);
obj_setInt(self, "SPACE_AROUND", LV_FLEX_ALIGN_SPACE_AROUND);
obj_setInt(self, "SPACE_BETWEEN", LV_FLEX_ALIGN_SPACE_BETWEEN);
}
void pika_lvgl_LAYOUT_FLEX___init__(PikaObj* self) {
obj_setInt(self, "value", LV_LAYOUT_FLEX);
}
void pika_lvgl_SIZE___init__(PikaObj* self) {
obj_setInt(self, "CONTENT", LV_SIZE_CONTENT);
}
int pika_lvgl_pct(PikaObj* self, int x) {
return LV_PCT(x);
}
/*
"""
enum {
LV_DIR_NONE = 0x00,
LV_DIR_LEFT = (1 << 0),
LV_DIR_RIGHT = (1 << 1),
LV_DIR_TOP = (1 << 2),
LV_DIR_BOTTOM = (1 << 3),
LV_DIR_HOR = LV_DIR_LEFT | LV_DIR_RIGHT,
LV_DIR_VER = LV_DIR_TOP | LV_DIR_BOTTOM,
LV_DIR_ALL = LV_DIR_HOR | LV_DIR_VER,
};
typedef uint8_t lv_dir_t;
"""
class DIR:
NONE: int
LEFT: int
RIGHT: int
TOP: int
BOTTOM: int
HOR: int
VER: int
ALL: int
def __init__(self): ...
*/
void pika_lvgl_DIR___init__(PikaObj* self) {
obj_setInt(self, "NONE", LV_DIR_NONE);
obj_setInt(self, "LEFT", LV_DIR_LEFT);
obj_setInt(self, "RIGHT", LV_DIR_RIGHT);
obj_setInt(self, "TOP", LV_DIR_TOP);
obj_setInt(self, "BOTTOM", LV_DIR_BOTTOM);
obj_setInt(self, "HOR", LV_DIR_HOR);
obj_setInt(self, "VER", LV_DIR_VER);
obj_setInt(self, "ALL", LV_DIR_ALL);
}
/*
enum {
LV_SCROLLBAR_MODE_OFF,
LV_SCROLLBAR_MODE_ON,
LV_SCROLLBAR_MODE_ACTIVE,
LV_SCROLLBAR_MODE_AUTO,
};
typedef uint8_t lv_scrollbar_mode_t;
class SCROLLBAR_MODE:
OFF: int
ON: int
ACTIVE: int
AUTO: int
def __init__(self): ...
*/
void pika_lvgl_SCROLLBAR_MODE___init__(PikaObj* self) {
obj_setInt(self, "OFF", LV_SCROLLBAR_MODE_OFF);
obj_setInt(self, "ON", LV_SCROLLBAR_MODE_ON);
obj_setInt(self, "ACTIVE", LV_SCROLLBAR_MODE_ACTIVE);
obj_setInt(self, "AUTO", LV_SCROLLBAR_MODE_AUTO);
}
/*
def color_black() -> lv_color_t: ...
def color_white() -> lv_color_t: ...
*/
PikaObj* pika_lvgl_color_black(PikaObj* self) {
PikaObj* new_obj = newNormalObj(New_pika_lvgl_lv_color_t);
lv_color_t lv_color = lv_color_black();
args_setStruct(new_obj->list, "lv_color_struct", lv_color);
lv_color_t* plv_color = args_getStruct(new_obj->list, "lv_color_struct");
obj_setPtr(new_obj, "lv_color", plv_color);
return new_obj;
}
PikaObj* pika_lvgl_color_white(PikaObj* self) {
PikaObj* new_obj = newNormalObj(New_pika_lvgl_lv_color_t);
lv_color_t lv_color = lv_color_white();
args_setStruct(new_obj->list, "lv_color_struct", lv_color);
lv_color_t* plv_color = args_getStruct(new_obj->list, "lv_color_struct");
obj_setPtr(new_obj, "lv_color", plv_color);
return new_obj;
}
/*
class PART:
MAIN: int
SCROLLBAR: int
INDICATOR: int
KNOB: int
SELECTED: int
ITEMS: int
TICKS: int
CURSOR: int
CUSTOM_FIRST: int
ANY: int
def __init__(self): ...
*/
void pika_lvgl_PART___init__(PikaObj* self) {
obj_setInt(self, "MAIN", LV_PART_MAIN);
obj_setInt(self, "SCROLLBAR", LV_PART_SCROLLBAR);
obj_setInt(self, "INDICATOR", LV_PART_INDICATOR);
obj_setInt(self, "KNOB", LV_PART_KNOB);
obj_setInt(self, "SELECTED", LV_PART_SELECTED);
obj_setInt(self, "ITEMS", LV_PART_ITEMS);
obj_setInt(self, "TICKS", LV_PART_TICKS);
obj_setInt(self, "CURSOR", LV_PART_CURSOR);
obj_setInt(self, "CUSTOM_FIRST", LV_PART_CUSTOM_FIRST);
obj_setInt(self, "ANY", LV_PART_ANY);
}
/*
class CHART_TYPE:
NONE: int
LINE: int
BAR: int
SCATTER: int
def __init__(self): ...
*/
void pika_lvgl_CHART_TYPE___init__(PikaObj* self) {
obj_setInt(self, "NONE", LV_CHART_TYPE_NONE);
obj_setInt(self, "LINE", LV_CHART_TYPE_LINE);
obj_setInt(self, "BAR", LV_CHART_TYPE_BAR);
obj_setInt(self, "SCATTER", LV_CHART_TYPE_SCATTER);
}
/*
class CHART_AXIS:
PRIMARY_Y: int
SECONDARY_Y: int
PRIMARY_X: int
SECONDARY_X: int
def __init__(self): ...
*/
void pika_lvgl_CHART_AXIS___init__(PikaObj* self) {
obj_setInt(self, "PRIMARY_Y", LV_CHART_AXIS_PRIMARY_Y);
obj_setInt(self, "SECONDARY_Y", LV_CHART_AXIS_SECONDARY_Y);
obj_setInt(self, "PRIMARY_X", LV_CHART_AXIS_PRIMARY_X);
obj_setInt(self, "SECONDARY_X", LV_CHART_AXIS_SECONDARY_X);
}
/*
class CHART_UPDATE_MODE:
SHIFT: int
CIRCULAR: int
def __init__(self): ...
*/
void pika_lvgl_CHART_UPDATE_MODE___init__(PikaObj* self) {
obj_setInt(self, "SHIFT", LV_CHART_UPDATE_MODE_SHIFT);
obj_setInt(self, "CIRCULAR", LV_CHART_UPDATE_MODE_CIRCULAR);
}
/*
class CHART_DRAW_PART:
DIV_LINE_INIT: int
DIV_LINE_HOR: int
DIV_LINE_VER: int
LINE_AND_POINT: int
BAR: int
CURSOR: int
TICK_LABEL: int
def __init__(self): ...
*/
void pika_lvgl_CHART_DRAW_PART___init__(PikaObj* self) {
obj_setInt(self, "DIV_LINE_INIT", LV_CHART_DRAW_PART_DIV_LINE_INIT);
obj_setInt(self, "DIV_LINE_HOR", LV_CHART_DRAW_PART_DIV_LINE_HOR);
obj_setInt(self, "DIV_LINE_VER", LV_CHART_DRAW_PART_DIV_LINE_VER);
obj_setInt(self, "LINE_AND_POINT", LV_CHART_DRAW_PART_LINE_AND_POINT);
obj_setInt(self, "BAR", LV_CHART_DRAW_PART_BAR);
obj_setInt(self, "CURSOR", LV_CHART_DRAW_PART_CURSOR);
obj_setInt(self, "TICK_LABEL", LV_CHART_DRAW_PART_TICK_LABEL);
}
#endif

1350
port/linux/package/pikascript/pikascript-lib/pika_lvgl/pika_lvgl.pyi Normal file
View File

File diff suppressed because it is too large Load Diff

104
port/linux/package/pikascript/pikascript-lib/pika_lvgl/pika_lvgl_canvas.c Normal file
View File

@ -0,0 +1,104 @@
#if defined(LV_LVGL_H_INCLUDE_SIMPLE)
#include "lvgl.h"
#else
#include "../../lvgl.h"
#endif
#ifdef PIKASCRIPT
#include "pika_lvgl_canvas.h"
void pika_lvgl_canvas___init__(PikaObj* self, PikaObj* parent) {
lv_obj_t* lv_parent = obj_getPtr(parent, "lv_obj");
lv_obj_t* lv_obj = lv_canvas_create(lv_parent);
obj_setPtr(self, "lv_obj", lv_obj);
pika_debug("lv_canvas_create, lv_obj: %p", lv_obj);
}
void pika_lvgl_canvas_copy_buf(PikaObj* self,
uint8_t* to_copy,
int x,
int y,
int w,
int h) {
lv_obj_t* lv_obj = obj_getPtr(self, "lv_obj");
lv_canvas_copy_buf(lv_obj, to_copy, x, y, w, h);
}
void pika_lvgl_canvas_fill_bg(PikaObj* self, PikaObj* color, int opa) {
lv_obj_t* lv_obj = obj_getPtr(self, "lv_obj");
lv_color_t* lv_color = obj_getPtr(color, "lv_color");
lv_canvas_fill_bg(lv_obj, *lv_color, opa);
}
PikaObj* pika_lvgl_canvas_get_img(PikaObj* self) {
// lv_obj_t* lv_obj = obj_getPtr(self, "lv_obj");
// lv_img_dsc_t* img = lv_canvas_get_img(lv_obj);
// PikaObj* pika_img = new_Obj("PikaImg", NULL);
// obj_setPtr(pika_img, "lv_img_dsc", img);
// return pika_img;
return NULL;
}
void pika_lvgl_canvas_get_px(PikaObj* self,
int x,
int y,
PikaObj* color,
int opa) {
// lv_obj_t* lv_obj = obj_getPtr(self, "lv_obj");
// lv_color_t lv_color = lv_canvas_get_px(lv_obj, x, y);
// obj_setInt(color, "full", lv_color.full);
// obj_setInt(color, "ch", lv_color.ch.alpha);
// obj_setInt(color, "opa", opa);
}
void pika_lvgl_canvas_set_buffer(PikaObj* self,
Arg* buf,
int w,
int h,
int cf) {
lv_obj_t* lv_obj = obj_getPtr(self, "lv_obj");
if (arg_getType(buf) == ARG_TYPE_BYTES){
pika_debug("lv_canvas_set_buffer, buf: %p", arg_getBytes(buf));
lv_canvas_set_buffer(lv_obj, arg_getBytes(buf), w, h, cf);
return;
}
if (arg_getType(buf) == ARG_TYPE_INT){
pika_debug("lv_canvas_set_buffer, buf: %p", (void*)arg_getInt(buf));
lv_canvas_set_buffer(lv_obj, (void*)arg_getInt(buf), w, h, cf);
return;
}
}
void pika_lvgl_canvas_set_palette(PikaObj* self, int id, PikaObj* c) {
lv_obj_t* lv_obj = obj_getPtr(self, "lv_obj");
lv_color_t* lv_color = obj_getPtr(c, "lv_color");
lv_canvas_set_palette(lv_obj, id, *lv_color);
}
void pika_lvgl_canvas_set_px(PikaObj* self,
int x,
int y,
PikaObj* color,
int opa) {
lv_obj_t* lv_obj = obj_getPtr(self, "lv_obj");
lv_color_t* lv_color = obj_getPtr(color, "lv_color");
lv_canvas_set_px(lv_obj, x, y, *lv_color);
}
void pika_lvgl_canvas_transform(PikaObj* self,
PikaObj* img,
int angle,
int zoom,
int offset_x,
int offset_y,
int pivot_x,
int pivot_y,
PIKA_BOOL antialias) {
lv_obj_t* lv_obj = obj_getPtr(self, "lv_obj");
lv_img_dsc_t* lv_img = obj_getPtr(img, "lv_img_dsc");
lv_canvas_transform(lv_obj, lv_img, angle, zoom, offset_x, offset_y,
pivot_x, pivot_y, antialias);
}
#endif

9
port/linux/package/pikascript/pikascript-lib/pika_lvgl/pika_lvgl_common.h Normal file
View File

@ -0,0 +1,9 @@
#ifndef _PIKA_LVGL_COMMON_H_
#define _PIKA_LVGL_COMMON_H_
#include "PikaObj.h"
#ifndef PIKA_LVGL_THREAD_LOCK_ENABLE
#define PIKA_LVGL_THREAD_LOCK_ENABLE 0
#endif
#endif

120
port/linux/package/pikascript/pikascript-lib/pika_lvgl/pika_lvgl_indev_t.c Normal file
View File

@ -0,0 +1,120 @@
#if defined(LV_LVGL_H_INCLUDE_SIMPLE)
#include "lvgl.h"
#else
#include "../../lvgl.h"
#endif
#ifdef PIKASCRIPT
#include "pika_lvgl_indev_t.h"
#include "pika_lvgl_lv_obj.h"
#include "pika_lvgl_point_t.h"
/*
class indev_t:
def __init__(self): ...
def enable(self, en: int): ...
def get_type(self) -> int: ...
def reset(self, obj: lv_obj): ...
def reset_long_press(self): ...
def set_cursor(self, cur_obj: lv_obj): ...
# def set_group(self, group: lv_group): ...
def set_button_points(self, points: point_t): ...
def get_point(self, point: point_t): ...
def get_gesture_dir(self) -> int: ...
def get_key(self) -> int: ...
def get_scroll_dir(self) -> int: ...
def get_scroll_obj(self) -> lv_obj: ...
def get_vect(self, point: point_t): ...
def wait_release(self): ...
def get_obj_act(self) -> lv_obj: ...
# def get_read_timer(self) -> lv_timer: ...
def search_obj(self, obj: lv_obj, point: point_t) -> lv_obj: ...
*/
void pika_lvgl_indev_t___init__(PikaObj* self) {
lv_indev_t* lv_indev = lv_indev_get_act();
obj_setPtr(self, "lv_indev", lv_indev);
}
void pika_lvgl_indev_t_enable(PikaObj* self, int en) {
lv_indev_t* lv_indev = obj_getPtr(self, "lv_indev");
lv_indev_enable(lv_indev, en);
}
int pika_lvgl_indev_t_get_type(PikaObj* self) {
lv_indev_t* lv_indev = obj_getPtr(self, "lv_indev");
return lv_indev_get_type(lv_indev);
}
void pika_lvgl_indev_t_reset(PikaObj* self, PikaObj* obj) {
lv_indev_t* lv_indev = obj_getPtr(self, "lv_indev");
lv_obj_t* lv_obj = obj_getPtr(obj, "lv_obj");
lv_indev_reset(lv_indev, lv_obj);
}
void pika_lvgl_indev_t_reset_long_press(PikaObj* self) {
lv_indev_t* lv_indev = obj_getPtr(self, "lv_indev");
lv_indev_reset_long_press(lv_indev);
}
void pika_lvgl_indev_t_set_cursor(PikaObj* self, PikaObj* cur_obj) {
lv_indev_t* lv_indev = obj_getPtr(self, "lv_indev");
lv_obj_t* lv_cur_obj = obj_getPtr(cur_obj, "lv_obj");
lv_indev_set_cursor(lv_indev, lv_cur_obj);
}
void pika_lvgl_indev_t_set_button_points(PikaObj* self, PikaObj* points) {
lv_indev_t* lv_indev = obj_getPtr(self, "lv_indev");
lv_point_t* lv_points = obj_getPtr(points, "lv_point");
lv_indev_set_button_points(lv_indev, lv_points);
}
PikaObj* pika_lvgl_indev_t_get_point(PikaObj* self) {
lv_indev_t* lv_indev = obj_getPtr(self, "lv_indev");
PikaObj* new_obj = newNormalObj(New_pika_lvgl_point_t);
lv_point_t lv_point = {0};
lv_indev_get_point(lv_indev, &lv_point);
obj_setInt(new_obj, "x", lv_point.x);
obj_setInt(new_obj, "y", lv_point.y);
return new_obj;
}
int pika_lvgl_indev_t_get_gesture_dir(PikaObj* self) {
lv_indev_t* lv_indev = obj_getPtr(self, "lv_indev");
return lv_indev_get_gesture_dir(lv_indev);
}
int pika_lvgl_indev_t_get_key(PikaObj* self) {
lv_indev_t* lv_indev = obj_getPtr(self, "lv_indev");
return lv_indev_get_key(lv_indev);
}
int pika_lvgl_indev_t_get_scroll_dir(PikaObj* self) {
lv_indev_t* lv_indev = obj_getPtr(self, "lv_indev");
return lv_indev_get_scroll_dir(lv_indev);
}
PikaObj* pika_lvgl_indev_t_get_scroll_obj(PikaObj* self) {
lv_indev_t* lv_indev = obj_getPtr(self, "lv_indev");
lv_obj_t* lv_obj = lv_indev_get_scroll_obj(lv_indev);
PikaObj* new_obj = newNormalObj(New_pika_lvgl_lv_obj);
obj_setPtr(new_obj, "lv_obj", lv_obj);
return new_obj;
}
void pika_lvgl_indev_t_get_vect(PikaObj* self, PikaObj* point) {
lv_indev_t* lv_indev = obj_getPtr(self, "lv_indev");
lv_point_t* lv_point = obj_getPtr(point, "lv_point");
lv_indev_get_vect(lv_indev, lv_point);
obj_setInt(point, "x", lv_point->x);
obj_setInt(point, "y", lv_point->y);
}
void pika_lvgl_indev_t_wait_release(PikaObj* self) {
lv_indev_t* lv_indev = obj_getPtr(self, "lv_indev");
lv_indev_wait_release(lv_indev);
}
#endif

24
port/linux/package/pikascript/pikascript-lib/pika_lvgl/pika_lvgl_lv_event.c Normal file
View File

@ -0,0 +1,24 @@
#if defined(LV_LVGL_H_INCLUDE_SIMPLE)
#include "lvgl.h"
#else
#include "../../lvgl.h"
#endif
#ifdef PIKASCRIPT
#include "pika_lvgl_lv_event.h"
int pika_lvgl_lv_event_get_code(PikaObj *self){
lv_event_t *lv_event = obj_getPtr(self, "lv_event");
return lv_event_get_code(lv_event);
}
PikaObj *New_pika_lvgl_lv_obj(Args *args);
PikaObj* pika_lvgl_lv_event_get_target(PikaObj *self){
lv_event_t *lv_event = obj_getPtr(self, "lv_event");
lv_obj_t* lv_obj = lv_event_get_target(lv_event);
PikaObj* new_obj = newNormalObj(New_pika_lvgl_lv_obj);
obj_setPtr(new_obj, "lv_obj", lv_obj);
return new_obj;
}
#endif

1327
port/linux/package/pikascript/pikascript-lib/pika_lvgl/pika_lvgl_lv_obj.c Normal file
View File

File diff suppressed because it is too large Load Diff

16
port/linux/package/pikascript/pikascript-lib/pika_lvgl/pika_lvgl_lv_point_t.c Normal file
View File

@ -0,0 +1,16 @@
#if defined(LV_LVGL_H_INCLUDE_SIMPLE)
#include "lvgl.h"
#else
#include "../../lvgl.h"
#endif
#ifdef PIKASCRIPT
#include "pika_lvgl_point_t.h"
void pika_lvgl_point_t___init__(PikaObj* self) {
lv_point_t lv_point = {0};
obj_setStruct(self, "lv_point_struct", lv_point);
obj_setPtr(self, "lv_point", obj_getStruct(self, "lv_point_struct"));
}
#endif

500
port/linux/package/pikascript/pikascript-lib/pika_lvgl/pika_lvgl_lv_style_t.c Normal file
View File

@ -0,0 +1,500 @@
#if defined(LV_LVGL_H_INCLUDE_SIMPLE)
#include "lvgl.h"
#else
#include "../../lvgl.h"
#endif
#ifdef PIKASCRIPT
#include "pika_lvgl_style_t.h"
void pika_lvgl_style_t_init(PikaObj* self) {
lv_style_t* lv_style = obj_getPtr(self, "lv_style");
lv_style_init(lv_style);
}
void pika_lvgl_style_t___init__(PikaObj* self) {
lv_style_t lv_style_stack = {0};
args_setStruct(self->list, "lv_style_struct", lv_style_stack);
lv_style_t* lv_style = args_getStruct(self->list, "lv_style_struct");
obj_setPtr(self, "lv_style", lv_style);
}
void pika_lvgl_style_t_set_align(PikaObj* self, int value) {
lv_style_t* lv_style = obj_getPtr(self, "lv_style");
lv_style_set_align(lv_style, value);
}
void pika_lvgl_style_t_set_anim_speed(PikaObj* self, int value) {
lv_style_t* lv_style = obj_getPtr(self, "lv_style");
lv_style_set_anim_speed(lv_style, value);
}
void pika_lvgl_style_t_set_anim_time(PikaObj* self, int value) {
lv_style_t* lv_style = obj_getPtr(self, "lv_style");
lv_style_set_anim_time(lv_style, value);
}
void pika_lvgl_style_t_set_arc_color(PikaObj* self, PikaObj* value) {
lv_style_t* lv_style = obj_getPtr(self, "lv_style");
lv_color_t* lv_color = obj_getPtr(value, "lv_color");
lv_style_set_arc_color(lv_style, *lv_color);
}
void pika_lvgl_style_t_set_arc_img_src(PikaObj* self, uint8_t* value) {
lv_style_t* lv_style = obj_getPtr(self, "lv_style");
lv_style_set_arc_img_src(lv_style, value);
}
void pika_lvgl_style_t_set_arc_opa(PikaObj* self, int value) {
lv_style_t* lv_style = obj_getPtr(self, "lv_style");
lv_style_set_arc_opa(lv_style, value);
}
void pika_lvgl_style_t_set_arc_rounded(PikaObj* self, int value) {
lv_style_t* lv_style = obj_getPtr(self, "lv_style");
lv_style_set_arc_rounded(lv_style, value);
}
void pika_lvgl_style_t_set_arc_width(PikaObj* self, int value) {
lv_style_t* lv_style = obj_getPtr(self, "lv_style");
lv_style_set_arc_width(lv_style, value);
}
void pika_lvgl_style_t_set_base_dir(PikaObj* self, int value) {
lv_style_t* lv_style = obj_getPtr(self, "lv_style");
lv_style_set_base_dir(lv_style, value);
}
void pika_lvgl_style_t_set_bg_color(PikaObj* self, PikaObj* value) {
lv_style_t* lv_style = obj_getPtr(self, "lv_style");
lv_color_t* lv_color = obj_getPtr(value, "lv_color");
lv_style_set_bg_color(lv_style, *lv_color);
}
void pika_lvgl_style_t_set_bg_dither_mode(PikaObj* self, int value) {
lv_style_t* lv_style = obj_getPtr(self, "lv_style");
lv_style_set_bg_dither_mode(lv_style, value);
}
void pika_lvgl_style_t_set_bg_grad_color(PikaObj* self, PikaObj* value) {
lv_style_t* lv_style = obj_getPtr(self, "lv_style");
lv_color_t* lv_color = obj_getPtr(value, "lv_color");
lv_style_set_bg_grad_color(lv_style, *lv_color);
}
void pika_lvgl_style_t_set_bg_grad_dir(PikaObj* self, int value) {
lv_style_t* lv_style = obj_getPtr(self, "lv_style");
lv_style_set_bg_grad_dir(lv_style, value);
}
void pika_lvgl_style_t_set_bg_grad_stop(PikaObj* self, int value) {
lv_style_t* lv_style = obj_getPtr(self, "lv_style");
lv_style_set_bg_grad_stop(lv_style, value);
}
void pika_lvgl_style_t_set_bg_img_opa(PikaObj* self, int value) {
lv_style_t* lv_style = obj_getPtr(self, "lv_style");
lv_style_set_bg_img_opa(lv_style, value);
}
void pika_lvgl_style_t_set_bg_img_recolor(PikaObj* self, PikaObj* value) {
lv_style_t* lv_style = obj_getPtr(self, "lv_style");
lv_color_t* lv_color = obj_getPtr(value, "lv_color");
lv_style_set_bg_img_recolor(lv_style, *lv_color);
}
void pika_lvgl_style_t_set_bg_img_recolor_opa(PikaObj* self, int value) {
lv_style_t* lv_style = obj_getPtr(self, "lv_style");
lv_style_set_bg_img_recolor_opa(lv_style, value);
}
void pika_lvgl_style_t_set_bg_img_src(PikaObj* self, uint8_t* value) {
lv_style_t* lv_style = obj_getPtr(self, "lv_style");
lv_style_set_bg_img_src(lv_style, value);
}
void pika_lvgl_style_t_set_bg_img_tiled(PikaObj* self, int value) {
lv_style_t* lv_style = obj_getPtr(self, "lv_style");
lv_style_set_bg_img_tiled(lv_style, value);
}
void pika_lvgl_style_t_set_bg_main_stop(PikaObj* self, int value) {
lv_style_t* lv_style = obj_getPtr(self, "lv_style");
lv_style_set_bg_main_stop(lv_style, value);
}
void pika_lvgl_style_t_set_bg_opa(PikaObj* self, int value) {
lv_style_t* lv_style = obj_getPtr(self, "lv_style");
lv_style_set_bg_opa(lv_style, value);
}
void pika_lvgl_style_t_set_blend_mode(PikaObj* self, int value) {
lv_style_t* lv_style = obj_getPtr(self, "lv_style");
lv_style_set_blend_mode(lv_style, value);
}
void pika_lvgl_style_t_set_border_color(PikaObj* self, PikaObj* value) {
lv_style_t* lv_style = obj_getPtr(self, "lv_style");
lv_color_t* lv_color = obj_getPtr(value, "lv_color");
lv_style_set_border_color(lv_style, *lv_color);
}
void pika_lvgl_style_t_set_border_opa(PikaObj* self, int value) {
lv_style_t* lv_style = obj_getPtr(self, "lv_style");
lv_style_set_border_opa(lv_style, value);
}
void pika_lvgl_style_t_set_border_post(PikaObj* self, int value) {
lv_style_t* lv_style = obj_getPtr(self, "lv_style");
lv_style_set_border_post(lv_style, value);
}
void pika_lvgl_style_t_set_border_side(PikaObj* self, int value) {
lv_style_t* lv_style = obj_getPtr(self, "lv_style");
lv_style_set_border_side(lv_style, value);
}
void pika_lvgl_style_t_set_border_width(PikaObj* self, int value) {
lv_style_t* lv_style = obj_getPtr(self, "lv_style");
lv_style_set_border_width(lv_style, value);
}
void pika_lvgl_style_t_set_clip_corner(PikaObj* self, int value) {
lv_style_t* lv_style = obj_getPtr(self, "lv_style");
lv_style_set_clip_corner(lv_style, value);
}
void pika_lvgl_style_t_set_color_filter_opa(PikaObj* self, int value) {
lv_style_t* lv_style = obj_getPtr(self, "lv_style");
lv_style_set_color_filter_opa(lv_style, value);
}
void pika_lvgl_style_t_set_height(PikaObj* self, int value) {
lv_style_t* lv_style = obj_getPtr(self, "lv_style");
lv_style_set_height(lv_style, value);
}
void pika_lvgl_style_t_set_img_opa(PikaObj* self, int value) {
lv_style_t* lv_style = obj_getPtr(self, "lv_style");
lv_style_set_img_opa(lv_style, value);
}
void pika_lvgl_style_t_set_img_recolor(PikaObj* self, PikaObj* value) {
lv_style_t* lv_style = obj_getPtr(self, "lv_style");
lv_color_t* lv_color = obj_getPtr(value, "lv_color");
lv_style_set_img_recolor(lv_style, *lv_color);
}
void pika_lvgl_style_t_set_img_recolor_opa(PikaObj* self, int value) {
lv_style_t* lv_style = obj_getPtr(self, "lv_style");
lv_style_set_img_recolor_opa(lv_style, value);
}
void pika_lvgl_style_t_set_layout(PikaObj* self, int value) {
lv_style_t* lv_style = obj_getPtr(self, "lv_style");
lv_style_set_layout(lv_style, value);
}
void pika_lvgl_style_t_set_line_color(PikaObj* self, PikaObj* value) {
lv_style_t* lv_style = obj_getPtr(self, "lv_style");
lv_color_t* lv_color = obj_getPtr(value, "lv_color");
lv_style_set_line_color(lv_style, *lv_color);
}
void pika_lvgl_style_t_set_line_dash_gap(PikaObj* self, int value) {
lv_style_t* lv_style = obj_getPtr(self, "lv_style");
lv_style_set_line_dash_gap(lv_style, value);
}
void pika_lvgl_style_t_set_line_dash_width(PikaObj* self, int value) {
lv_style_t* lv_style = obj_getPtr(self, "lv_style");
lv_style_set_line_dash_width(lv_style, value);
}
void pika_lvgl_style_t_set_line_opa(PikaObj* self, int value) {
lv_style_t* lv_style = obj_getPtr(self, "lv_style");
lv_style_set_line_opa(lv_style, value);
}
void pika_lvgl_style_t_set_line_rounded(PikaObj* self, int value) {
lv_style_t* lv_style = obj_getPtr(self, "lv_style");
lv_style_set_line_rounded(lv_style, value);
}
void pika_lvgl_style_t_set_line_width(PikaObj* self, int value) {
lv_style_t* lv_style = obj_getPtr(self, "lv_style");
lv_style_set_line_width(lv_style, value);
}
void pika_lvgl_style_t_set_max_height(PikaObj* self, int value) {
lv_style_t* lv_style = obj_getPtr(self, "lv_style");
lv_style_set_max_height(lv_style, value);
}
void pika_lvgl_style_t_set_max_width(PikaObj* self, int value) {
lv_style_t* lv_style = obj_getPtr(self, "lv_style");
lv_style_set_max_width(lv_style, value);
}
void pika_lvgl_style_t_set_min_height(PikaObj* self, int value) {
lv_style_t* lv_style = obj_getPtr(self, "lv_style");
lv_style_set_min_height(lv_style, value);
}
void pika_lvgl_style_t_set_min_width(PikaObj* self, int value) {
lv_style_t* lv_style = obj_getPtr(self, "lv_style");
lv_style_set_min_width(lv_style, value);
}
void pika_lvgl_style_t_set_opa(PikaObj* self, int value) {
lv_style_t* lv_style = obj_getPtr(self, "lv_style");
lv_style_set_opa(lv_style, value);
}
void pika_lvgl_style_t_set_outline_color(PikaObj* self, PikaObj* value) {
lv_style_t* lv_style = obj_getPtr(self, "lv_style");
lv_color_t* lv_color = obj_getPtr(value, "lv_color");
lv_style_set_outline_color(lv_style, *lv_color);
}
void pika_lvgl_style_t_set_outline_opa(PikaObj* self, int value) {
lv_style_t* lv_style = obj_getPtr(self, "lv_style");
lv_style_set_outline_opa(lv_style, value);
}
void pika_lvgl_style_t_set_outline_pad(PikaObj* self, int value) {
lv_style_t* lv_style = obj_getPtr(self, "lv_style");
lv_style_set_outline_pad(lv_style, value);
}
void pika_lvgl_style_t_set_outline_width(PikaObj* self, int value) {
lv_style_t* lv_style = obj_getPtr(self, "lv_style");
lv_style_set_outline_width(lv_style, value);
}
void pika_lvgl_style_t_set_pad_bottom(PikaObj* self, int value) {
lv_style_t* lv_style = obj_getPtr(self, "lv_style");
lv_style_set_pad_bottom(lv_style, value);
}
void pika_lvgl_style_t_set_pad_column(PikaObj* self, int value) {
lv_style_t* lv_style = obj_getPtr(self, "lv_style");
lv_style_set_pad_column(lv_style, value);
}
void pika_lvgl_style_t_set_pad_left(PikaObj* self, int value) {
lv_style_t* lv_style = obj_getPtr(self, "lv_style");
lv_style_set_pad_left(lv_style, value);
}
void pika_lvgl_style_t_set_pad_right(PikaObj* self, int value) {
lv_style_t* lv_style = obj_getPtr(self, "lv_style");
lv_style_set_pad_right(lv_style, value);
}
void pika_lvgl_style_t_set_pad_row(PikaObj* self, int value) {
lv_style_t* lv_style = obj_getPtr(self, "lv_style");
lv_style_set_pad_row(lv_style, value);
}
void pika_lvgl_style_t_set_pad_top(PikaObj* self, int value) {
lv_style_t* lv_style = obj_getPtr(self, "lv_style");
lv_style_set_pad_top(lv_style, value);
}
void pika_lvgl_style_t_set_radius(PikaObj* self, int value) {
lv_style_t* lv_style = obj_getPtr(self, "lv_style");
lv_style_set_radius(lv_style, value);
}
void pika_lvgl_style_t_set_shadow_color(PikaObj* self, PikaObj* value) {
lv_style_t* lv_style = obj_getPtr(self, "lv_style");
lv_color_t* lv_color = obj_getPtr(value, "lv_color");
lv_style_set_shadow_color(lv_style, *lv_color);
}
void pika_lvgl_style_t_set_shadow_ofs_x(PikaObj* self, int value) {
lv_style_t* lv_style = obj_getPtr(self, "lv_style");
lv_style_set_shadow_ofs_x(lv_style, value);
}
void pika_lvgl_style_t_set_shadow_ofs_y(PikaObj* self, int value) {
lv_style_t* lv_style = obj_getPtr(self, "lv_style");
lv_style_set_shadow_ofs_y(lv_style, value);
}
void pika_lvgl_style_t_set_shadow_opa(PikaObj* self, int value) {
lv_style_t* lv_style = obj_getPtr(self, "lv_style");
lv_style_set_shadow_opa(lv_style, value);
}
void pika_lvgl_style_t_set_shadow_spread(PikaObj* self, int value) {
lv_style_t* lv_style = obj_getPtr(self, "lv_style");
lv_style_set_shadow_spread(lv_style, value);
}
void pika_lvgl_style_t_set_shadow_width(PikaObj* self, int value) {
lv_style_t* lv_style = obj_getPtr(self, "lv_style");
lv_style_set_shadow_width(lv_style, value);
}
void pika_lvgl_style_t_set_text_align(PikaObj* self, int value) {
lv_style_t* lv_style = obj_getPtr(self, "lv_style");
lv_style_set_text_align(lv_style, value);
}
void pika_lvgl_style_t_set_text_color(PikaObj* self, PikaObj* value) {
lv_style_t* lv_style = obj_getPtr(self, "lv_style");
lv_color_t* lv_color = obj_getPtr(value, "lv_color");
lv_style_set_text_color(lv_style, *lv_color);
}
void pika_lvgl_style_t_set_text_decor(PikaObj* self, int value) {
lv_style_t* lv_style = obj_getPtr(self, "lv_style");
lv_style_set_text_decor(lv_style, value);
}
void pika_lvgl_style_t_set_text_letter_space(PikaObj* self, int value) {
lv_style_t* lv_style = obj_getPtr(self, "lv_style");
lv_style_set_text_letter_space(lv_style, value);
}
void pika_lvgl_style_t_set_text_line_space(PikaObj* self, int value) {
lv_style_t* lv_style = obj_getPtr(self, "lv_style");
lv_style_set_text_line_space(lv_style, value);
}
void pika_lvgl_style_t_set_text_opa(PikaObj* self, int value) {
lv_style_t* lv_style = obj_getPtr(self, "lv_style");
lv_style_set_text_opa(lv_style, value);
}
void pika_lvgl_style_t_set_transform_angle(PikaObj* self, int value) {
lv_style_t* lv_style = obj_getPtr(self, "lv_style");
lv_style_set_transform_angle(lv_style, value);
}
void pika_lvgl_style_t_set_transform_height(PikaObj* self, int value) {
lv_style_t* lv_style = obj_getPtr(self, "lv_style");
lv_style_set_transform_height(lv_style, value);
}
void pika_lvgl_style_t_set_transform_pivot_x(PikaObj* self, int value) {
lv_style_t* lv_style = obj_getPtr(self, "lv_style");
lv_style_set_transform_pivot_x(lv_style, value);
}
void pika_lvgl_style_t_set_transform_pivot_y(PikaObj* self, int value) {
lv_style_t* lv_style = obj_getPtr(self, "lv_style");
lv_style_set_transform_pivot_y(lv_style, value);
}
void pika_lvgl_style_t_set_transform_width(PikaObj* self, int value) {
lv_style_t* lv_style = obj_getPtr(self, "lv_style");
lv_style_set_transform_width(lv_style, value);
}
void pika_lvgl_style_t_set_transform_zoom(PikaObj* self, int value) {
lv_style_t* lv_style = obj_getPtr(self, "lv_style");
lv_style_set_transform_zoom(lv_style, value);
}
void pika_lvgl_style_t_set_translate_x(PikaObj* self, int value) {
lv_style_t* lv_style = obj_getPtr(self, "lv_style");
lv_style_set_translate_x(lv_style, value);
}
void pika_lvgl_style_t_set_translate_y(PikaObj* self, int value) {
lv_style_t* lv_style = obj_getPtr(self, "lv_style");
lv_style_set_translate_y(lv_style, value);
}
void pika_lvgl_style_t_set_width(PikaObj* self, int value) {
lv_style_t* lv_style = obj_getPtr(self, "lv_style");
lv_style_set_width(lv_style, value);
}
void pika_lvgl_style_t_set_x(PikaObj* self, int value) {
lv_style_t* lv_style = obj_getPtr(self, "lv_style");
lv_style_set_x(lv_style, value);
}
void pika_lvgl_style_t_set_y(PikaObj* self, int value) {
lv_style_t* lv_style = obj_getPtr(self, "lv_style");
lv_style_set_y(lv_style, value);
}
int pika_lvgl_style_t_get_num_custom_props(PikaObj* self) {
return lv_style_get_num_custom_props();
}
int pika_lvgl_style_t_prop_has_flag(PikaObj* self, int prop, int flag) {
return lv_style_prop_has_flag(prop, flag);
}
int pika_lvgl_style_t_is_empty(PikaObj* self) {
lv_style_t* lv_style = obj_getPtr(self, "lv_style");
return lv_style_is_empty(lv_style);
}
int pika_lvgl_style_t_register_prop(PikaObj* self, int flag) {
return lv_style_register_prop(flag);
}
int pika_lvgl_style_t_remove_prop(PikaObj* self, int prop) {
lv_style_t* lv_style = obj_getPtr(self, "lv_style");
return lv_style_remove_prop(lv_style, prop);
}
void pika_lvgl_style_t_reset(PikaObj* self) {
lv_style_t* lv_style = obj_getPtr(self, "lv_style");
lv_style_reset(lv_style);
}
void pika_lvgl_style_t_set_pad_all(PikaObj* self, int value) {
lv_style_t* lv_style = obj_getPtr(self, "lv_style");
lv_style_set_pad_all(lv_style, value);
}
void pika_lvgl_style_t_set_pad_gap(PikaObj* self, int value) {
lv_style_t* lv_style = obj_getPtr(self, "lv_style");
lv_style_set_pad_gap(lv_style, value);
}
void pika_lvgl_style_t_set_pad_hor(PikaObj* self, int value) {
lv_style_t* lv_style = obj_getPtr(self, "lv_style");
lv_style_set_pad_hor(lv_style, value);
}
void pika_lvgl_style_t_set_pad_ver(PikaObj* self, int value) {
lv_style_t* lv_style = obj_getPtr(self, "lv_style");
lv_style_set_pad_ver(lv_style, value);
}
// void pika_lvgl_style_t_set_prop_meta(PikaObj* self, int prop, int meta) {
// lv_style_t* lv_style = obj_getPtr(self, "lv_style");
// lv_style_set_prop_meta(lv_style, prop, meta);
//}
void pika_lvgl_style_t_set_size(PikaObj* self, int value) {
lv_style_t* lv_style = obj_getPtr(self, "lv_style");
lv_style_set_size(lv_style, value);
}
void pika_lvgl_style_t_set_flex_cross_place(PikaObj* self, int value) {
lv_style_t* lv_style = obj_getPtr(self, "lv_style");
lv_style_set_flex_cross_place(lv_style, value);
}
void pika_lvgl_style_t_set_flex_flow(PikaObj* self, int value) {
lv_style_t* lv_style = obj_getPtr(self, "lv_style");
lv_style_set_flex_flow(lv_style, value);
}
void pika_lvgl_style_t_set_flex_grow(PikaObj* self, int value) {
lv_style_t* lv_style = obj_getPtr(self, "lv_style");
lv_style_set_flex_grow(lv_style, value);
}
void pika_lvgl_style_t_set_flex_main_place(PikaObj* self, int value) {
lv_style_t* lv_style = obj_getPtr(self, "lv_style");
lv_style_set_flex_main_place(lv_style, value);
}
void pika_lvgl_style_t_set_flex_track_place(PikaObj* self, int value) {
lv_style_t* lv_style = obj_getPtr(self, "lv_style");
lv_style_set_flex_track_place(lv_style, value);
}
#endif

43
port/linux/package/pikascript/pikascript-lib/pika_lvgl/pika_lvgl_lv_timer_t.c Normal file
View File

@ -0,0 +1,43 @@
#if defined(LV_LVGL_H_INCLUDE_SIMPLE)
#include "lvgl.h"
#else
#include "../../lvgl.h"
#endif
#ifdef PIKASCRIPT
#include "pika_lvgl_lv_timer_t.h"
PikaEventListener* g_pika_lv_timer_event_listener;
void __pika_timer_cb(lv_timer_t* timer) {
PikaObj* eventHandleObj = pks_eventLisener_getEventHandleObj(
g_pika_lv_timer_event_listener, (uint32_t)timer);
obj_newDirectObj(eventHandleObj, "timer", New_pika_lvgl_lv_timer_t);
obj_setPtr(obj_getPtr(eventHandleObj, "timer"), "lv_timer", timer);
obj_run(eventHandleObj, "eventCallBack(timer)");
}
void pika_lvgl_lv_timer_t_set_period(PikaObj* self, int period) {
lv_timer_t* lv_timer = obj_getPtr(self, "lv_timer");
lv_timer_set_period(lv_timer, period);
}
void pika_lvgl_lv_timer_t_set_cb(PikaObj* self, Arg* cb) {
lv_timer_t* lv_timer = obj_getPtr(self, "lv_timer");
lv_timer_set_cb(lv_timer, __pika_timer_cb);
obj_setArg(self, "eventCallBack", cb);
/* init event_listener for the first time */
if (NULL == g_pika_lv_timer_event_listener) {
pks_eventLisener_init(&g_pika_lv_timer_event_listener);
}
pks_eventLicener_registEvent(g_pika_lv_timer_event_listener,
(uint32_t)lv_timer, self);
}
void pika_lvgl_lv_timer_t__del(PikaObj* self) {
lv_timer_t* lv_timer = obj_getPtr(self, "lv_timer");
lv_timer_del(lv_timer);
}
#endif

1389
port/linux/package/pikascript/pikascript-lib/pika_lvgl/pika_lvgl_lv_wegit.c Normal file
View File

File diff suppressed because it is too large Load Diff

5
port/linux/performance/CMakeLists.txt
View File

@ -10,4 +10,7 @@ SET(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -pg")
# 链接src生成的lib库和gtest库
target_link_libraries(${BINARY} PUBLIC
-Wl,--whole-archive ${CMAKE_PROJECT_NAME}-core -Wl,--no-whole-archive)
-Wl,--whole-archive
${CMAKE_PROJECT_NAME}-core
${CMAKE_PROJECT_NAME}-lvgl
-Wl,--no-whole-archive)

5
port/linux/test/CMakeLists.txt
View File

@ -20,5 +20,8 @@ add_test(NAME ${BINARY} COMMAND ${BINARY})
# 链接src生成的lib库和gtest库
target_link_libraries(${BINARY} PUBLIC
-Wl,--whole-archive ${CMAKE_PROJECT_NAME}-core -Wl,--no-whole-archive
-Wl,--whole-archive
${CMAKE_PROJECT_NAME}-core
${CMAKE_PROJECT_NAME}-lvgl
-Wl,--no-whole-archive
gtest)