Kaotings/KT24-1110_65E-HA-651B
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
main
KT24-1110_65E-HA-651B/cpu/br25/ui_driver/interface/ui_platform.c

2897 lines
88 KiB
C
Raw Permalink Normal View History

inited
2024-11-10 10:44:17 +00:00
#include "ui/includes.h"
#include "timer.h"
#include "asm/crc16.h"
#include "ui/lcd_spi/lcd_drive.h"
#include "ascii.h"
#include "font/font_textout.h"
#include "res/rle.h"
#include "res/resfile.h"
#include "ui/res_config.h"
#include "app_config.h"
#include "dev_manager.h"
#include "app_task.h"
#include "smartbox/smartbox_task.h"
#include "fs/fs.h"
#if TCFG_SPI_LCD_ENABLE
#define UI_DEBUG 0
/* #define UI_BUF_CALC */
#if (UI_DEBUG == 1)
#define UI_PUTS puts
#define UI_PRINTF printf
#else
#define UI_PUTS(...)
#define UI_PRINTF(...)
#endif
#define _RGB565(r,g,b) (u16)((((r)>>3)<<11)|(((g)>>2)<<5)|((b)>>3))
#define UI_RGB565(c) \
_RGB565((c>>16)&0xff,(c>>8)&0xff,c&0xff)
#define TEXT_MONO_CLR 0x555aaa
#define TEXT_MONO_INV 0xaaa555
#define RECT_MONO_CLR 0x555aaa
#define BGC_MONO_SET 0x555aaa
struct fb_map_user {
u16 xoffset;
u16 yoffset;
u16 width;
u16 height;
u8 *baddr;
u8 *yaddr;
u8 *uaddr;
u8 *vaddr;
u8 transp;
u8 format;
};
struct fb_var_screeninfo {
u16 s_xoffset; //显示区域x坐标
u16 s_yoffset; //显示区域y坐标
u16 s_xres; //显示区域宽度
u16 s_yres; //显示区域高度
u16 v_xoffset; //屏幕的虚拟x坐标
u16 v_yoffset; //屏幕的虚拟y坐标
u16 v_xres; //屏幕的虚拟宽度
u16 v_yres; //屏幕的虚拟高度
u16 rotate;
};
struct window_head {
u32 offset;
u32 len;
u32 ptr_table_offset;
u16 ptr_table_len;
u16 crc_data;
u16 crc_table;
u16 crc_head;
};
struct ui_file_head {
u8 res[16];
u8 type;
u8 window_num;
u16 prop_len;
u8 rotate;
u8 rev[3];
};
struct ui_load_info ui_load_info_table[] = {
{-1, NULL, NULL},
};
static u32 ui_rotate = false;
static u32 ui_hori_mirror = false;
static u32 ui_vert_mirror = false;
static int malloc_cnt = 0;
static FILE *ui_file = NULL;
static FILE *ui_file1 = NULL;
static FILE *ui_file2 = NULL;
static int ui_file_len = 0;
static int open_resource_file();
void select_strfile(u8 index);
void select_resfile(u8 index);
static const struct ui_platform_api br23_platform_api;
struct ui_priv {
struct ui_platform_api *api;
struct lcd_interface *lcd;
int window_offset;
struct lcd_info info;
};
static struct ui_priv priv ALIGNED(4);
#define __this (&priv)
#ifdef UI_BUF_CALC
struct buffer {
struct list_head list;
u8 *buf;
int size;
};
struct buffer buffer_used = {0};
#endif
void *br23_malloc(int size)
{
void *buf;
malloc_cnt++;
buf = (void *)malloc(size);
/* printf("platform_malloc : 0x%x, %d\n", buf, size); */
#ifdef UI_BUF_CALC
struct buffer *new = (struct buffer *)malloc(sizeof(struct buffer));
new->buf = buf;
new->size = size;
list_add_tail(new, &buffer_used);
printf("platform_malloc : 0x%x, %d\n", buf, size);
struct buffer *p;
int buffer_used_total = 0;
list_for_each_entry(p, &buffer_used.list, list) {
buffer_used_total += p->size;
}
printf("used buffer size:%d\n\n", buffer_used_total);
#endif
return buf;
}
void br23_free(void *buf)
{
/* printf("platform_free : 0x%x\n",buf); */
free(buf);
malloc_cnt--;
#ifdef UI_BUF_CALC
struct buffer *p, *n;
list_for_each_entry_safe(p, n, &buffer_used.list, list) {
if (p->buf == buf) {
printf("platform_free : 0x%x, %d\n", p->buf, p->size);
__list_del_entry(p);
free(p);
}
}
int buffer_used_total = 0;
list_for_each_entry(p, &buffer_used.list, list) {
buffer_used_total += p->size;
}
printf("used buffer size:%d\n\n", buffer_used_total);
#endif
}
int ui_platform_ok()
{
return (malloc_cnt == 0);
}
static void draw_rect_range_check(struct rect *r, struct fb_map_user *map)
{
if (r->left < map->xoffset) {
r->left = map->xoffset;
}
if (r->left > (map->xoffset + map->width)) {
r->left = map->xoffset + map->width;
}
if ((r->left + r->width) > (map->xoffset + map->width)) {
r->width = map->xoffset + map->width - r->left;
}
if (r->top < map->yoffset) {
r->top = map->yoffset;
}
if (r->top > (map->yoffset + map->height)) {
r->top = map->yoffset + map->height;
}
if ((r->top + r->height) > (map->yoffset + map->height)) {
r->height = map->yoffset + map->height - r->top;
}
ASSERT(r->left >= map->xoffset);
ASSERT(r->top >= map->yoffset);
ASSERT((r->left + r->width) <= (map->xoffset + map->width));
ASSERT((r->top + r->height) <= (map->yoffset + map->height));
}
/* 透明色: 16bits 0x55aa 0101 0xxx 1011 01xx 0101 0xxx
* 24bits 0x50b450 0101 0000 1011 0100 0101 0000 , 80 180 80
* */
void __font_pix_copy(struct draw_context *dc, int format, struct fb_map_user *map, u8 *pix, struct rect *draw, int x, int y,
int height, int width, int color)
{
int i, j, h;
u16 osd_color;
u32 size;
osd_color = (format == DC_DATA_FORMAT_OSD8) || (format == DC_DATA_FORMAT_OSD8A) ? color & 0xff : color & 0xffff ;
for (j = 0; j < (height + 7) / 8; j++) { /* 纵向8像素为1字节 */
for (i = 0; i < width; i++) {
if (((i + x) >= draw->left)
&& ((i + x) <= (draw->left + draw->width - 1))) { /* x在绘制区域，要绘制 */
u8 pixel = pix[j * width + i];
int hh = height - (j * 8);
if (hh > 8) {
hh = 8;
}
for (h = 0; h < hh; h++) {
if (((y + j * 8 + h) >= draw->top)
&& ((y + j * 8 + h) <= (draw->top + draw->height - 1))) { /* y在绘制区域，要绘制 */
u16 clr = pixel & BIT(h) ? osd_color : 0;
if (clr) {
if (platform_api->draw_point) {
platform_api->draw_point(dc, x + i, y + j * 8 + h, clr);
}
}
}
} /* endof for h */
}
}/* endof for i */
}/* endof for j */
}
static int image_str_size_check(struct draw_context *dc, int page_num, const char *txt, int *width, int *height)
{
u16 id = ((u8)txt[1] << 8) | (u8)txt[0];
u16 cnt = 0;
struct image_file file;
int w = 0, h = 0;
while (id != 0x00ff) {
select_resfile(dc->prj);
if (open_image_by_id(NULL, &file, id, page_num) != 0) {
return -EFAULT;
}
w += file.width;
cnt += 2;
id = ((u8)txt[cnt + 1] << 8) | (u8)txt[cnt];
}
h = file.height;
*width = w;
*height = h;
return 0;
}
void platform_putchar(struct font_info *info, u8 *pixel, u16 width, u16 height, u16 x, u16 y)
{
__font_pix_copy(info->dc, info->disp.format,
(struct fb_map_user *)info->disp.map,
pixel,
(struct rect *)info->disp.rect,
(s16)x,
(s16)y,
height,
width,
info->disp.color);
}
struct file_dev {
const char *logo;
const char *root_path;
};
struct file_browser {
int show_mode;
struct rect r;
struct vfscan *fscan;
/* struct server *server; */
struct ui_file_browser bro;
struct file_dev dev;//支持三个设备
};
static int check_file_ext(const char *ext_table, const char *ext)
{
const char *str;
for (str = ext_table; *str != '\0'; str += 3) {
if (0 == ASCII_StrCmpNoCase(ext, str, 3)) {
return true;
}
}
return false;
}
static const u8 MUSIC_SCAN_PARAM[] = "-t"
"MP1MP2MP3"
" -sn -d"
;
static int platform_file_get_dev_total()
{
return dev_manager_get_total(1);
}
static void platform_file_browser_get_dev_info(struct ui_file_browser *_bro, u8 index)
{
struct file_browser *bro = container_of(_bro, struct file_browser, bro);
struct file_dev *file_dev;//支持三个设备
if (!bro) {
return;
}
struct __dev *dev = dev_manager_find_by_index(index, 0);//storage_dev_find_by_index(index);
if (dev) {
file_dev = &bro->dev;
file_dev->logo = dev_manager_get_logo(dev);//获取设备logo
file_dev->root_path = dev_manager_get_root_path_by_logo(dev);//获取设备路径
}
}
static struct ui_file_browser *platform_file_browser_open(struct rect *r,
const char *path, const char *ftype, int show_mode)
{
int err;
struct file_browser *bro;
struct __dev *dev = 0;
bro = (struct file_browser *)malloc(sizeof(*bro));
if (!bro) {
return NULL;
}
bro->bro.file_number = 0;
bro->show_mode = show_mode;
if (!path) {
dev = dev_manager_find_active(0);///storage_dev_last();//获取最后一个设备的路径
if (!dev) {
free(bro);
return NULL;
}
path = dev_manager_get_root_path_by_logo(dev);//dev->root_path;
}
if (!ftype) {
ftype = MUSIC_SCAN_PARAM;
}
bro->fscan = fscan(path, ftype, 9);
bro->bro.dev_num = dev_manager_get_total(1);//获取在线设备总数
if (bro->fscan) {
bro->bro.file_number = bro->fscan->file_number;
if (bro->bro.file_number == 0) {
return &bro->bro;
}
}
if (r) {
memcpy(&bro->r, r, sizeof(struct rect));
}
return &bro->bro;
__err:
fscan_release(bro->fscan);
free(bro);
return NULL;
}
static void platform_file_browser_close(struct ui_file_browser *_bro)
{
struct file_browser *bro = container_of(_bro, struct file_browser, bro);
if (!bro) {
return;
}
if (bro->fscan) {
fscan_release(bro->fscan);
}
free(bro);
}
static int platform_get_file_attrs(struct ui_file_browser *_bro,
struct ui_file_attrs *attrs)
{
int i, j;
struct vfs_attr attr;
struct file_browser *bro = container_of(_bro, struct file_browser, bro);
if (!bro->fscan) {
return -ENOENT;
}
FILE *file = fselect(bro->fscan, FSEL_BY_NUMBER, attrs->file_num + 1);
if (!file) {
return -ENOENT;
}
attrs->format = "ascii";
fget_attrs(file, &attrs->attr);
/* printf(" attr = %x, fsize = %x,sclust = %x\n",attrs->attr.attr,attrs->attr.fsize,attrs->attr.sclust); */
struct sys_time *time;
time = &(attrs->attr.crt_time);
/* printf("y =%d m =%d d = %d,h = %d ,m = %d ,s =%d\n",time->year,time->month,time->day,time->hour,time->min,time->sec); */
time = &(attrs->attr.wrt_time);
/* printf("y =%d m =%d d = %d,h = %d ,m = %d ,s =%d\n",time->year,time->month,time->day,time->hour,time->min,time->sec); */
int len = fget_name(file, (u8 *)attrs->fname, 16);//长文件获取有问题
if (len < 0) {
fclose(file);
return -EINVAL;
}
for (i = 0; i < len; i++) {
if ((u8)attrs->fname[i] >= 0x80) {
attrs->format = "uft16";
goto _next;
}
}
/* ASCII_ToUpper(attrs->fname, strlen(attrs->fname)); */
_next:
#if 0//文件系统接口不完善，临时解决
for (i = 0; i < len; i++) {
if (attrs->fname[i] == '.') {
break;
}
}
if (i == len) {
attrs->ftype = UI_FTYPE_DIR;
} else {
char *ext = attrs->fname + i + 1;
if (check_file_ext("JPG", ext)) {
attrs->ftype = UI_FTYPE_IMAGE;
} else if (check_file_ext("MOVAVI", ext)) {
attrs->ftype = UI_FTYPE_VIDEO;
} else if (check_file_ext("MP3WMAWAV", ext)) {
attrs->ftype = UI_FTYPE_AUDIO;
} else {
attrs->ftype = UI_FTYPE_UNKNOW;
}
}
#else
/* printf("name = %d %d \n",strlen(attrs->fname),len); */
/* put_buf(attrs->fname,len); */
if (attrs->attr.attr & F_ATTR_DIR) {
attrs->ftype = UI_FTYPE_DIR;
} else {
char *ext = attrs->fname + strlen(attrs->fname) - 3;
if (check_file_ext("JPG", ext)) {
attrs->ftype = UI_FTYPE_IMAGE;
} else if (check_file_ext("MOVAVI", ext)) {
attrs->ftype = UI_FTYPE_VIDEO;
} else if (check_file_ext("MP3WMAWAV", ext)) {
attrs->ftype = UI_FTYPE_AUDIO;
} else {
attrs->ftype = UI_FTYPE_UNKNOW;
}
}
#endif
fclose(file);
return 0;
}
static int platform_set_file_attrs(struct ui_file_browser *_bro,
struct ui_file_attrs *attrs)
{
int attr = 0;
struct file_browser *bro = container_of(_bro, struct file_browser, bro);
if (!bro->fscan) {
return -ENOENT;
}
FILE *file = fselect(bro->fscan, FSEL_BY_NUMBER, attrs->file_num + 1);
if (!file) {
return -EINVAL;
}
fget_attr(file, &attr);
if (attrs->attr.attr & F_ATTR_RO) {
attr |= F_ATTR_RO;
} else {
attr &= ~F_ATTR_RO;
}
fset_attr(file, attr);
fclose(file);
return 0;
}
static void *platform_open_file(struct ui_file_browser *_bro,
struct ui_file_attrs *attrs)
{
struct file_browser *bro = container_of(_bro, struct file_browser, bro);
if (!bro->fscan) {
return NULL;
}
return fselect(bro->fscan, FSEL_BY_NUMBER, attrs->file_num + 1);
}
static int platform_delete_file(struct ui_file_browser *_bro,
struct ui_file_attrs *attrs)
{
struct file_browser *bro = container_of(_bro, struct file_browser, bro);
if (!bro->fscan) {
return -EINVAL;
}
FILE *file = fselect(bro->fscan, FSEL_BY_NUMBER, attrs->file_num + 1);
if (!file) {
return -EFAULT;
}
fdelete(file);
return 0;
}
void test_browser()
{
struct ui_file_browser *browser = NULL;
static struct ui_file_attrs attrs = {0};
if (!browser) {
browser = platform_file_browser_open(NULL, NULL, MUSIC_SCAN_PARAM, 0);
}
if (browser) {
printf("file num = %d \n", browser->file_number);
platform_get_file_attrs(browser, &attrs);
printf("format =%s name =%s type = %x \n", attrs.format, attrs.fname, attrs.ftype);
platform_delete_file(browser, &attrs);
attrs.file_num ++;
if (attrs.file_num >= browser->file_number) {
attrs.file_num = 0;
}
}
}
static void *br23_set_timer(void *priv, void (*callback)(void *), u32 msec)
{
return (void *)sys_timer_add(priv, callback, msec);
}
static int br23_del_timer(void *fd)
{
if (fd) {
sys_timer_del((int)fd);
}
return 0;
}
u32 __attribute__((weak)) set_retry_cnt()
{
return 10;
}
AT_UI_RAM
static void *br23_load_widget_info(void *__head, u8 page)
{
struct ui_file_head head ALIGNED(4);
static union ui_control_info info ALIGNED(4) = {0};
static const int rotate[] = {0, 90, 180, 270};
static int last_page = -1;
int head_len;
int retry = 10;
u32 offset;
u32 _head = ((u32)__head) & 0xffff;
ui_file = ui_file1;
if (!_head) {
struct ui_style style = {0};
int load_style = 1;
last_page = page;
if (load_style && platform_api->load_style) {
if (platform_api->load_style(&style)) {
return NULL;
}
load_style = 0;
}
if (!ui_file) {
return NULL;
}
/* last_page = page; */
res_fseek(ui_file, 0, SEEK_SET);
res_fread(ui_file, &head, sizeof(struct ui_file_head));
ui_rotate = rotate[head.rotate];
ui_core_set_rotate(ui_rotate);
switch (head.rotate) {
case 1: /* 旋转90度 */
ui_hori_mirror = true;
ui_vert_mirror = false;
break;
case 3:/* 旋转270度 */
ui_hori_mirror = false;
ui_vert_mirror = true;
break;
default:
ui_hori_mirror = false;
ui_vert_mirror = false;
break;
}
if (page != (u8) - 1) {
res_fseek(ui_file, sizeof(struct ui_file_head) + sizeof(struct window_head)*page, SEEK_SET);
res_fread(ui_file, &__this->window_offset, sizeof(__this->window_offset));
}
}
ASSERT((u32)_head <= ui_file_len, ",_head invalid! _head : 0x%x ui_file_len : 0x%x\n", (u32)_head, ui_file_len);
if ((u32)_head > ui_file_len) {
return NULL;
}
if ((u32)__head >= 0x10000) {
page = ((u32)__head >> 22) & 0x7f;
res_fseek(ui_file, sizeof(struct ui_file_head) + sizeof(struct window_head)*page, SEEK_SET);
res_fread(ui_file, &offset, sizeof(__this->window_offset));
} else {
offset = __this->window_offset;
}
res_fseek(ui_file, offset + (u32)_head, SEEK_SET);
if ((u32)_head == 0) {
res_fread(ui_file, &info, sizeof(struct window_info));
} else {
res_fread(ui_file, &info.head, sizeof(struct ui_ctrl_info_head));
head_len = info.head.len - sizeof(struct ui_ctrl_info_head);
if ((head_len > 0) && (head_len <= sizeof(union ui_control_info))) {
res_fread(ui_file, &((u8 *)&info)[sizeof(struct ui_ctrl_info_head)], head_len);
}
}
return &info;
}
AT_UI_RAM
static void *br23_load_css(u8 page, void *_css)
{
u32 rets;
__asm__ volatile("%0 = rets":"=r"(rets));
static struct element_css1 css ALIGNED(4) = {0};
u32 offset;
/* printf(" >>>>>>>>%s %d %x %x\n",__FUNCTION__,__LINE__,((u32)_css) >> 29,rets); */
ui_file = ui_file1;
/* printf(" >>>>>>>>%s %d file = %x\n",__FUNCTION__,__LINE__,ui_file); */
if ((u32)_css >= 0x10000) {
/* offset = ((u32)_css) >> 16; */
page = ((u32)_css >> 22) & 0x7f;
res_fseek(ui_file, sizeof(struct ui_file_head) + sizeof(struct window_head)*page, SEEK_SET);
res_fread(ui_file, &offset, sizeof(offset));
} else {
res_fseek(ui_file, sizeof(struct ui_file_head) + sizeof(struct window_head)*page, SEEK_SET);
res_fread(ui_file, &offset, sizeof(offset));
/* offset = __this->window_offset; */
}
ASSERT((u32)_css <= ui_file_len, ", _css invalid! _css : 0x%x , ui_file_len : 0x%x\n", _css, ui_file_len);
res_fseek(ui_file, offset/* __this->window_offset */ + ((u32)_css & 0xffff), SEEK_SET);
res_fread(ui_file, &css, sizeof(struct element_css1));
return &css;
}
AT_UI_RAM
static void *br23_load_image_list(u8 page, void *_list)
{
u16 image[32] ALIGNED(4);
static struct ui_image_list_t list ALIGNED(4) = {0};
int retry = 10;
u32 offset;
/* printf(" >>>>>>>>%s %d %x\n",__FUNCTION__,__LINE__,(int)_list >> 29); */
ui_file = ui_file1;
if ((u32)_list >= 0x10000) {
/* offset = ((u32)_list) >> 16; */
page = ((u32)_list >> 22) & 0x7f;
res_fseek(ui_file, sizeof(struct ui_file_head) + sizeof(struct window_head)*page, SEEK_SET);
res_fread(ui_file, &offset, sizeof(__this->window_offset));
} else {
/* offset = __this->window_offset; */
res_fseek(ui_file, sizeof(struct ui_file_head) + sizeof(struct window_head)*page, SEEK_SET);
res_fread(ui_file, &offset, sizeof(offset));
}
if ((u32)_list == 0) {
return NULL;
}
ASSERT((u32)_list <= ui_file_len, ", _list invalid! _list : 0x%x, ui_file_len : 0x%x\n", (u32)_list, ui_file_len);
do {
memset(&list, 0x00, sizeof(struct ui_image_list));
res_fseek(ui_file, offset/* __this->window_offset */ + ((u32)_list & 0xffff), SEEK_SET);
res_fread(ui_file, &list.num, sizeof(list.num));
if (list.num == 0) {
printf("list.num : %d\n", list.num);
return NULL;
}
if (list.num < 32) {
res_fread(ui_file, image, list.num * sizeof(list.image[0]));
memcpy(list.image, image, list.num * sizeof(list.image[0]));
} else {
printf("list.num = %d\n", list.num);
printf("load_image_list error,retry %d!\n", retry);
if (retry == 0) {
return NULL;
}
}
} while (retry--);
return &list;
}
AT_UI_RAM
static void *br23_load_text_list(u8 page, void *__list)
{
u8 buf[16 * 2] ALIGNED(4);
static struct ui_text_list_t _list ALIGNED(4) = {0};
struct ui_text_list_t *list;
int retry = 10;
int i;
u32 offset;
/* printf(" >>>>>>>>%s %d %x\n",__FUNCTION__,__LINE__,(u32)__list >> 29); */
ui_file = ui_file1;
if (!ui_file) {
return NULL;
}
if ((u32)__list >= 0x10000) {
/* offset = ((u32)__list) >> 16; */
page = ((u32)__list >> 22) & 0x7f;
res_fseek(ui_file, sizeof(struct ui_file_head) + sizeof(struct window_head)*page, SEEK_SET);
res_fread(ui_file, &offset, sizeof(__this->window_offset));
} else {
/* offset = __this->window_offset; */
res_fseek(ui_file, sizeof(struct ui_file_head) + sizeof(struct window_head)*page, SEEK_SET);
res_fread(ui_file, &offset, sizeof(offset));
}
if ((u32)__list == 0) {
return NULL;
}
ASSERT((u32)__list <= ui_file_len, ", __list invalid! _list : 0x%x, ui_file_len : 0x%x\n", (u32)__list, ui_file_len);
list = &_list;
do {
memset(list, 0x00, sizeof(struct ui_text_list_t));
res_fseek(ui_file, offset/* __this->window_offset */ + ((u32)__list & 0xffff), SEEK_SET);
res_fread(ui_file, &list->num, sizeof(list->num));
if (list->num == 0) {
return NULL;
}
if (list->num <= 16) {
res_fread(ui_file, buf, list->num * 2);
for (i = 0; i < list->num; i++) {
ASSERT(buf[2 * i] < 0x100);
list->str[i] = buf[2 * i];
}
} else {
printf("list->num = %d\n", list->num);
printf("load_text_list error, retry %d!\n", retry);
if (retry == 0) {
return NULL;
}
}
} while (retry--);
return list;
}
static void *br23_load_window(int id)
{
u8 *ui;
int i;
u32 *ptr;
u16 *ptr_table;
struct ui_file_head head ALIGNED(4);
struct window_head window ALIGNED(4);
int len = sizeof(struct ui_file_head);
int retry;
static const int rotate[] = {0, 90, 180, 270};
if (!ui_file) {
printf("ui_file : 0x%x\n", ui_file);
return NULL;
}
ui_platform_ok();
for (retry = 0; retry < set_retry_cnt(); retry++) {
res_fseek(ui_file, 0, SEEK_SET);
res_fread(ui_file, &head, len);
if (id >= head.window_num) {
return NULL;
}
res_fseek(ui_file, sizeof(struct window_head)*id, SEEK_CUR);
res_fread(ui_file, &window, sizeof(struct window_head));
u16 crc = CRC16(&window, (u32) & (((struct window_head *)0)->crc_data));
if (crc == window.crc_head) {
ui_rotate = rotate[head.rotate];
ui_core_set_rotate(ui_rotate);
switch (head.rotate) {
case 1: /* 旋转90度 */
ui_hori_mirror = true;
ui_vert_mirror = false;
break;
case 3:/* 旋转270度 */
ui_hori_mirror = false;
ui_vert_mirror = true;
break;
default:
ui_hori_mirror = false;
ui_vert_mirror = false;
break;
}
goto __read_data;
}
}
return NULL;
__read_data:
ui = (u8 *)__this->api->malloc(window.len);
if (!ui) {
return NULL;
}
for (retry = 0; retry < set_retry_cnt(); retry++) {
res_fseek(ui_file, window.offset, SEEK_SET);
res_fread(ui_file, ui, window.len);
u16 crc = CRC16(ui, window.len);
if (crc == window.crc_data) {
goto __read_table;
}
}
__this->api->free(ui);
return NULL;
__read_table:
ptr_table = (u16 *)__this->api->malloc(window.ptr_table_len);
if (!ptr_table) {
__this->api->free(ui);
return NULL;
}
for (retry = 0; retry < set_retry_cnt(); retry++) {
res_fseek(ui_file, window.ptr_table_offset, SEEK_SET);
res_fread(ui_file, ptr_table, window.ptr_table_len);
u16 crc = CRC16(ptr_table, window.ptr_table_len);
if (crc == window.crc_table) {
u16 *offset = ptr_table;
for (i = 0; i < window.ptr_table_len; i += 2) {
ptr = (u32 *)(ui + *offset++);
if (*ptr != 0) {
*ptr += (u32)ui;
}
}
__this->api->free(ptr_table);
return ui;
}
}
__this->api->free(ui);
__this->api->free(ptr_table);
return NULL;
}
static void br23_unload_window(void *ui)
{
if (ui) {
__this->api->free(ui);
}
}
static int br23_load_style(struct ui_style *style)
{
int err;
int i, j;
int len;
struct vfscan *fs;
char name[64];
char style_name[16];
static char cur_style = 0xff;
if (!style->file && cur_style == 0) {
return 0;
}
if (ui_file1) {
fclose(ui_file1);
ui_file1 = NULL;
}
if (style->file == NULL) {
cur_style = 0;
err = open_resource_file();
if (err) {
return -EINVAL;
}
#if 0
fs = fscan("mnt/spiflash/res", "-t*.sty");
if (!fs) {
printf("open mnt/spiflash/res fail!\n");
return -EFAULT;
}
ui_file1 = fselect(fs, FSEL_FIRST_FILE, 0);
if (!ui_file1) {
fscan_release(fs);
return -ENOENT;
}
len = fget_name(ui_file1, (u8 *)name, 16);
if (len) {
style_name[len - 4] = 0;
memcpy(style_name, name, len - 4);
ui_core_set_style(style_name);
}
fscan_release(fs);
#else
ui_file1 = res_fopen(RES_PATH"JL.sty", "r");
if (!ui_file1) {
return -ENOENT;
}
ui_file_len = res_flen(ui_file1);
len = 6;
strcpy(style_name, "JL.sty");
if (len) {
style_name[len - 4] = 0;
ui_core_set_style(style_name);
}
#endif
} else {
cur_style = 1;
ui_file1 = res_fopen(style->file, "r");
printf("open stylefile %s\n", style->file);
if (!ui_file1) {
return -EINVAL;
}
/* if (!ui_file2) { */
/* ui_file2 = fopen(RES_PATH"sidebar/sidebar.sty", "r"); */
/* } */
ui_file = ui_file1;
ui_file_len = 0xffffffff;//res_flen(ui_file1);
for (i = 0; style->file[i] != '.'; i++) {
name[i] = style->file[i];
}
name[i++] = '.';
name[i++] = 'r';
name[i++] = 'e';
name[i++] = 's';
name[i] = '\0';
open_resfile(name);
printf("open resfile %s\n", name);
name[--i] = 'r';
name[--i] = 't';
name[--i] = 's';
open_str_file(name);
printf("open strfile %s\n", name);
name[i++] = 'a';
name[i++] = 's';
name[i++] = 'i';
font_ascii_init(RES_PATH"font/ascii.res");
printf("open asciifile %s\n", name);
for (i = strlen(style->file) - 5; i >= 0; i--) {
if (style->file[i] == '/') {
break;
}
}
for (i++, j = 0; style->file[i] != '\0'; i++) {
if (style->file[i] == '.') {
name[j] = '\0';
break;
}
name[j++] = style->file[i];
}
ASCII_ToUpper(name, j);
err = ui_core_set_style(name);
if (err) {
printf("style_err: %s\n", name);
}
}
return 0;
__err2:
close_resfile();
__err1:
fclose(ui_file1);
ui_file1 = NULL;
return err;
}
static int br23_open_draw_context(struct draw_context *dc)
{
dc->buf_num = 1;
if (__this->lcd->buffer_malloc) {
u8 *buf;
u32 len;
__this->lcd->buffer_malloc(&buf, &len);
dc->buf0 = buf;
#if UI_USED_DOUBLE_BUFFER
dc->buf1 = &buf[len / 2];
dc->len = len / 2;
#else
dc->buf1 = NULL;
dc->len = len;
#endif
dc->buf = dc->buf0;
/* __this->lcd->buffer_malloc(&dc->buf, &dc->len); */
}
if (__this->lcd->get_screen_info) {
__this->lcd->get_screen_info(&__this->info);
dc->width = __this->info.width;
dc->height = __this->info.height;
dc->col_align = __this->info.col_align;
dc->row_align = __this->info.row_align;
dc->lines = dc->len / dc->width / 2;
if (dc->lines > (dc->height / 10)) {
dc->lines = dc->height / 10;
}
printf("dc->width : %d, dc->lines : %d\n", dc->width, dc->lines);
}
switch (__this->info.color_format) {
case LCD_COLOR_RGB565:
if (dc->data_format != DC_DATA_FORMAT_OSD16) {
ASSERT(0, "The color format of layer don't match the lcd driver,page %d please select OSD16!", dc->page);
}
break;
case LCD_COLOR_MONO:
if (dc->data_format != DC_DATA_FORMAT_MONO) {
ASSERT(0, "The color format of layer don't match the lcd driver,page %d please select OSD1!", dc->page);
}
break;
}
if (dc->data_format == DC_DATA_FORMAT_OSD16) {
dc->fbuf_len = __this->info.width * (3 + 3 * dc->lines) + 0x80;
dc->fbuf = (u8 *)__this->api->malloc(dc->fbuf_len);
} else if (dc->data_format == DC_DATA_FORMAT_MONO) {
dc->fbuf_len = __this->info.width * 2;
dc->fbuf = (u8 *)__this->api->malloc(dc->fbuf_len);
}
return 0;
}
static int br23_get_draw_context(struct draw_context *dc)
{
#if UI_USED_DOUBLE_BUFFER
if (dc->buf == dc->buf0) {
dc->buf = dc->buf1;
} else {
dc->buf = dc->buf0;
}
#endif
dc->disp.left = dc->need_draw.left;
dc->disp.width = dc->need_draw.width;
if (dc->data_format == DC_DATA_FORMAT_OSD16) {
int lines = dc->len / dc->need_draw.width / 2;
if ((dc->disp.top == 0) && (dc->disp.height == 0)) {
dc->disp.top = dc->need_draw.top;
dc->disp.height = lines > dc->need_draw.height ? dc->need_draw.height : lines;
} else {
dc->disp.top = dc->disp.top + dc->disp.height;
dc->disp.height = lines > (dc->need_draw.top + dc->need_draw.height - dc->disp.top) ?
(dc->need_draw.top + dc->need_draw.height - dc->disp.top) : lines;
}
dc->disp.height = dc->disp.height / dc->row_align * dc->row_align;
} else if (dc->data_format == DC_DATA_FORMAT_MONO) {
dc->disp.top = dc->need_draw.top;
dc->disp.height = dc->need_draw.height;
}
return 0;
}
static int br23_put_draw_context(struct draw_context *dc)
{
if (__this->lcd->set_draw_area) {
__this->lcd->set_draw_area(dc->disp.left, dc->disp.left + dc->disp.width - 1,
dc->disp.top, dc->disp.top + dc->disp.height - 1);
}
u8 wait = ((dc->need_draw.top + dc->need_draw.height) == (dc->disp.top + dc->disp.height)) ? 1 : 0;
if (__this->lcd->draw) {
if (dc->data_format == DC_DATA_FORMAT_OSD16) {
__this->lcd->draw(dc->buf, dc->disp.height * dc->disp.width * 2, wait);
} else if (dc->data_format == DC_DATA_FORMAT_MONO) {
__this->lcd->draw(dc->buf, __this->info.width * __this->info.height / 8, wait);
}
}
return 0;
}
static int br23_set_draw_context(struct draw_context *dc)
{
return 0;
}
static int br23_close_draw_context(struct draw_context *dc)
{
if (__this->lcd->buffer_free) {
__this->lcd->buffer_free(dc->buf);
}
if (dc->fbuf) {
__this->api->free(dc->fbuf);
dc->fbuf = NULL;
dc->fbuf_len = 0;
}
return 0;
}
static int br23_invert_rect(struct draw_context *dc, u32 acolor)
{
int i;
int len;
int w, h;
int color = acolor & 0xffff;
if (dc->data_format == DC_DATA_FORMAT_MONO) {
color |= BIT(31);
for (h = 0; h < dc->draw.height; h++) {
for (w = 0; w < dc->draw.width; w++) {
if (platform_api->draw_point) {
platform_api->draw_point(dc, dc->draw.left + w, dc->draw.top + h, color);
}
}
}
}
return 0;
}
static int br23_fill_rect(struct draw_context *dc, u32 acolor)
{
int i;
int w, h;
u16 color = acolor & 0xffff;
if (!dc->buf) {
return 0;
}
if (dc->data_format == DC_DATA_FORMAT_MONO) {
color = (color == UI_RGB565(BGC_MONO_SET)) ? 0xffff : 0x55aa;
for (h = 0; h < dc->draw.height; h++) {
for (w = 0; w < dc->draw.width; w++) {
if (platform_api->draw_point) {
platform_api->draw_point(dc, dc->draw.left + w, dc->draw.top + h, color);
}
}
}
} else {
u16 color16 = (color >> 8) | ((color & 0xff) << 8);
u32 color32 = (color16 << 16) | color16;
h = 0;
u32 *p32 = (u32 *)&dc->buf[(dc->draw.top + h - dc->disp.top) * dc->disp.width * 2 + (dc->draw.left - dc->disp.left) * 2];
u32 *_p32 = p32;
u32 len = dc->draw.width * 2;
if ((u32)p32 % 4) {
u16 *p16 = (u16 *)p32;
*p16++ = color16;
p32 = (u32 *)p16;
len -= 2;
ASSERT((u32)p32 % 4 == 0);
}
u32 count = len / 4;
while (count--) {
*p32++ = color32;
}
count = (len % 4) / 2;
u16 *p16 = (u16 *)p32;
while (count--) {
*p16++ = color16;
}
for (h = 1; h < dc->draw.height; h++) {
u32 *__p32 = (u32 *)&dc->buf[(dc->draw.top + h - dc->disp.top) * dc->disp.width * 2 + (dc->draw.left - dc->disp.left) * 2];
memcpy(__p32, _p32, dc->draw.width * 2);
}
}
return 0;
}
static inline void __draw_vertical_line(struct draw_context *dc, int x, int y, int width, int height, int color, int format)
{
int i, j;
struct rect r = {0};
struct rect disp = {0};
disp.left = x;
disp.top = y;
disp.width = width;
disp.height = height;
if (!get_rect_cover(&dc->draw, &disp, &r)) {
return;
}
switch (format) {
case DC_DATA_FORMAT_OSD16:
for (i = 0; i < r.width; i++) {
for (j = 0; j < r.height; j++) {
if (platform_api->draw_point) {
platform_api->draw_point(dc, r.left + i, r.top + j, color);
}
}
}
break;
case DC_DATA_FORMAT_MONO:
for (i = 0; i < r.width; i++) {
for (j = 0; j < r.height; j++) {
if (platform_api->draw_point) {
platform_api->draw_point(dc, r.left + i, r.top + j, color);
}
}
}
break;
}
}
static inline void __draw_line(struct draw_context *dc, int x, int y, int width, int height, int color, int format)
{
int i, j;
struct rect r = {0};
struct rect disp = {0};
disp.left = x;
disp.top = y;
disp.width = width;
disp.height = height;
if (!get_rect_cover(&dc->draw, &disp, &r)) {
return;
}
switch (format) {
case DC_DATA_FORMAT_OSD16:
for (i = 0; i < r.height; i++) {
for (j = 0; j < r.width; j++) {
if (platform_api->draw_point) {
platform_api->draw_point(dc, r.left + j, r.top + i, color);
}
}
}
break;
case DC_DATA_FORMAT_MONO:
for (i = 0; i < r.height; i++) {
for (j = 0; j < r.width; j++) {
if (platform_api->draw_point) {
platform_api->draw_point(dc, r.left + j, r.top + i, color);
}
}
}
break;
}
}
static int br23_draw_rect(struct draw_context *dc, struct css_border *border)
{
int err;
int offset;
int color = border->color & 0xffff;
/* draw_rect_range_check(&dc->draw, map); */
/* draw_rect_range_check(&dc->rect, map); */
if (dc->data_format == DC_DATA_FORMAT_OSD16) {
color = border->color & 0xffff;
} else if (dc->data_format == DC_DATA_FORMAT_MONO) {
color = (color != UI_RGB565(RECT_MONO_CLR)) ? (color ? color : 0xffff) : 0x55aa;
}
if (border->left) {
if (dc->rect.left >= dc->draw.left &&
dc->rect.left <= rect_right(&dc->draw)) {
__draw_vertical_line(dc, dc->draw.left, dc->draw.top,
border->left, dc->draw.height, color, dc->data_format);
}
}
if (border->right) {
if (rect_right(&dc->rect) >= dc->draw.left &&
rect_right(&dc->rect) <= rect_right(&dc->draw)) {
__draw_vertical_line(dc, dc->draw.left + dc->draw.width - border->right, dc->draw.top,
border->right, dc->draw.height, color, dc->data_format);
}
}
if (border->top) {
if (dc->rect.top >= dc->draw.top &&
dc->rect.top <= rect_bottom(&dc->draw)) {
__draw_line(dc, dc->draw.left, dc->draw.top,
dc->draw.width, border->top, color, dc->data_format);
}
}
if (border->bottom) {
if (rect_bottom(&dc->rect) >= dc->draw.top &&
rect_bottom(&dc->rect) <= rect_bottom(&dc->draw)) {
__draw_line(dc, dc->draw.left, dc->draw.top + dc->draw.height - border->bottom,
dc->draw.width, border->bottom, color, dc->data_format);
}
}
return 0;
}
__attribute__((always_inline_when_const_args))
AT_UI_RAM
static u16 get_mixed_pixel(u16 backcolor, u16 forecolor, u8 alpha)
{
u16 mixed_color;
u8 r0, g0, b0;
u8 r1, g1, b1;
u8 r2, g2, b2;
if (alpha == 255) {
return (forecolor >> 8) | (forecolor & 0xff) << 8;
} else if (alpha == 0) {
return (backcolor >> 8) | (backcolor & 0xff) << 8;
}
r0 = ((backcolor >> 11) & 0x1f) << 3;
g0 = ((backcolor >> 5) & 0x3f) << 2;
b0 = ((backcolor >> 0) & 0x1f) << 3;
r1 = ((forecolor >> 11) & 0x1f) << 3;
g1 = ((forecolor >> 5) & 0x3f) << 2;
b1 = ((forecolor >> 0) & 0x1f) << 3;
r2 = (alpha * r1 + (255 - alpha) * r0) / 255;
g2 = (alpha * g1 + (255 - alpha) * g0) / 255;
b2 = (alpha * b1 + (255 - alpha) * b0) / 255;
mixed_color = ((r2 >> 3) << 11) | ((g2 >> 2) << 5) | (b2 >> 3);
return (mixed_color >> 8) | (mixed_color & 0xff) << 8;
}
static int br23_read_image_info(struct draw_context *dc, u32 id, u8 page, struct ui_image_attrs *attrs)
{
struct image_file file;
if (((u16) - 1 == id) || ((u32) - 1 == id)) {
return -1;
}
select_resfile(dc->prj);
int err = open_image_by_id(NULL, &file, id, dc->page);
if (err) {
return -EFAULT;
}
attrs->width = file.width;
attrs->height = file.height;
return 0;
}
AT_UI_RAM
int line_update(u8 *mask, u16 y, u16 width)
{
int i;
if (!mask) {
return true;
}
for (i = 0; i < (width + 7) / 8; i++) {
if (mask[y * ((width + 7) / 8) + i]) {
return true;
}
}
return false;
}
/* AT_UI_RAM */
void select_resfile(u8 index);
void select_strfile(u8 index);
static int br23_draw_image(struct draw_context *dc, u32 src, u8 quadrant, u8 *mask)
{
u8 *pixelbuf;
u8 *temp_pixelbuf;
u8 *alphabuf;
u8 *temp_alphabuf;
struct rect draw_r;
struct rect r = {0};
struct rect disp = {0};
struct image_file file;
int h, hh, w;
int buf_offset;
int id;
int page;
FILE *fp;
if (dc->preview.file) {
fp = dc->preview.file;
id = dc->preview.id;
page = dc->preview.page;
} else {
fp = NULL;
id = src;
page = dc->page;
}
if (((u16) - 1 == id) || ((u32) - 1 == id)) {
return -1;
}
draw_r.left = dc->draw.left;
draw_r.top = dc->draw.top;
draw_r.width = dc->draw.width;
draw_r.height = dc->draw.height;
/* UI_PRINTF("image draw %d, %d, %d, %d\n", dc->draw.left, dc->draw.top, dc->draw.width, dc->draw.height); */
/* UI_PRINTF("image rect %d, %d, %d, %d\n", dc->rect.left, dc->rect.top, dc->rect.width, dc->rect.height); */
select_resfile(dc->prj);
if (dc->draw_img.en) {
id = dc->draw_img.id;
page = dc->draw_img.page;
}
int err = open_image_by_id(fp, &file, id, page);
if (err) {
return -EFAULT;
}
int x = dc->rect.left;
int y = dc->rect.top;
if (dc->align == UI_ALIGN_CENTER) {
x += (dc->rect.width / 2 - file.width / 2);
y += (dc->rect.height / 2 - file.height / 2);
} else if (dc->align == UI_ALIGN_RIGHT) {
x += dc->rect.width - file.width;
}
int temp_pixelbuf_len;
int temp_alphabuf_len;
int align;
if (dc->draw_img.en) {
disp.left = dc->draw_img.x;
disp.top = dc->draw_img.y;
} else {
disp.left = x;
disp.top = y;
}
disp.width = file.width;
disp.height = file.height;
if (dc->data_format == DC_DATA_FORMAT_MONO) {
pixelbuf = dc->fbuf;
if (get_rect_cover(&draw_r, &disp, &r)) {
int _offset = -1;
for (h = 0; h < r.height; h++) {
if (file.compress == 0) {
int offset = (r.top + h - disp.top) / 8 * file.width + (r.left - disp.left);
if (_offset != offset) {
if (br23_read_image_data(fp, &file, pixelbuf, r.width, offset) != r.width) {
return -EFAULT;
}
_offset = offset;
}
} else {
ASSERT(0, "the compress mode not support!");
}
for (w = 0; w < r.width; w++) {
u8 color = (pixelbuf[w] & BIT((r.top + h - disp.top) % 8)) ? 1 : 0;
if (color) {
if (platform_api->draw_point) {
platform_api->draw_point(dc, r.left + w, r.top + h, color);
}
}
}
}
}
} else if (dc->data_format == DC_DATA_FORMAT_OSD16) {
if (get_rect_cover(&draw_r, &disp, &r)) {
u32 alpha_addr = 0;
br23_read_image_data(fp, &file, &alpha_addr, sizeof(alpha_addr), 0);
if (alpha_addr) {
temp_pixelbuf_len = dc->width * 2 * dc->lines + 0x40 - 8;
temp_alphabuf_len = dc->width * dc->lines + 0x40 - 8;
buf_offset = 0;
pixelbuf = &dc->fbuf[buf_offset];//2 bytes * line
buf_offset += dc->width * 2;
buf_offset = (buf_offset + 3) / 4 * 4;
alphabuf = &dc->fbuf[buf_offset];//1 bytes * line
buf_offset += dc->width;
buf_offset = (buf_offset + 3) / 4 * 4;
temp_pixelbuf = &dc->fbuf[buf_offset];
buf_offset += temp_pixelbuf_len;
buf_offset = (buf_offset + 3) / 4 * 4;
temp_alphabuf = &dc->fbuf[buf_offset];
} else {
/* temp_pixelbuf_len = dc->width * 3 * dc->lines + 0x80; */
temp_pixelbuf_len = dc->fbuf_len - dc->width * 2;
buf_offset = 0;
pixelbuf = &dc->fbuf[buf_offset];//2 bytes * line
buf_offset += dc->width * 2;
buf_offset = (buf_offset + 3) / 4 * 4;
temp_pixelbuf = &dc->fbuf[buf_offset];
}
for (h = 0; h < r.height;) {
int rh = r.top + h - disp.top;
int rw = r.left - disp.left;
int vh = rh;
int vw = rw;
if (quadrant == 0) {
;
} else if (quadrant == 1) {
vh = file.height - (r.top - disp.top + r.height - h);
} else if (quadrant == 2) {
vh = file.height - (r.top - disp.top + r.height - h);
vw = file.width - rw - r.width;
} else {
vw = file.width - rw - r.width;
}
ASSERT(vw >= 0);
ASSERT(vh >= 0);
struct rle_line *line;
struct rle_line *alpha_line;
u8 *ptemp;
u8 *alpha_ptemp;
int lines;
if (file.compress == 0) {
int remain = (r.height - h) > (file.height - vh) ? (file.height - vh) : (r.height - h);
int offset = 4 + vh * file.width * 2 + vw * 2;
br23_read_image_data(fp, &file, &alpha_addr, sizeof(alpha_addr), 0);
if (!alpha_addr) {
lines = dc->fbuf_len / file.width / 2;
} else {
lines = dc->fbuf_len / file.width / 3;
}
lines = (lines > remain) ? remain : lines;
pixelbuf = dc->fbuf;
alphabuf = &dc->fbuf[(lines * file.width * 2 + 3) / 4 * 4];
int remain_bytes = 4 + file.width * 2 * file.height - offset;
int read_bytes = remain_bytes > (file.width * 2 * lines) ? file.width * 2 * lines : remain_bytes;
if (br23_read_image_data(fp, &file, pixelbuf, read_bytes, offset) != read_bytes) {
return -EFAULT;
}
if (alpha_addr) {
offset = alpha_addr + vh * file.width + vw;
int remain_bytes = alpha_addr + file.width * file.height - offset;
int read_bytes = remain_bytes > (file.width * lines) ? file.width * lines : remain_bytes;
if (br23_read_image_data(fp, &file, alphabuf, read_bytes, offset) != read_bytes) {
return -EFAULT;
}
}
} else if (file.compress == 1) {
int remain = (r.height - h) > (file.height - vh) ? (file.height - vh) : (r.height - h);
int headlen = sizeof(struct rle_header) + (remain * 2 + 3) / 4 * 4;
line = (struct rle_line *)temp_pixelbuf;
ptemp = &temp_pixelbuf[headlen];
memset(line, 0x00, sizeof(struct rle_line));
br23_read_image_data(fp, &file, ptemp, sizeof(struct rle_header)*remain, 4 + vh * sizeof(struct rle_header));
int i;
struct rle_header *rle = (struct rle_header *)ptemp;
int total_len = 0;
for (i = 0; i < remain; i++) {
if (i == 0) {
line->addr = rle[i].addr;
line->len[i] = rle[i].len;
} else {
line->len[i] = rle[i].len;
}
if ((total_len + rle[i].len) > (temp_pixelbuf_len - headlen)) {
break;
}
total_len += rle[i].len;
line->num ++;
}
br23_read_image_data(fp, &file, ptemp, total_len, 4 + line->addr);
if (alpha_addr) {
int headlen = sizeof(struct rle_header) + (line->num * 2 + 3) / 4 * 4;
alpha_ptemp = &temp_alphabuf[headlen];
br23_read_image_data(fp, &file, alpha_ptemp, sizeof(struct rle_header)*line->num, alpha_addr + vh * sizeof(struct rle_header));
struct rle_header *rle = (struct rle_header *)alpha_ptemp;
alpha_line = (struct rle_line *)temp_alphabuf;
memset(alpha_line, 0x00, sizeof(struct rle_line));
int total_len = 0;
for (i = 0; i < line->num; i++) {
if (i == 0) {
alpha_line->addr = rle[i].addr;
alpha_line->len[i] = rle[i].len;
} else {
alpha_line->len[i] = rle[i].len;
}
if ((total_len + rle[i].len) > (temp_alphabuf_len - headlen)) {
break;
}
total_len += rle[i].len;
alpha_line->num ++;
}
br23_read_image_data(fp, &file, alpha_ptemp, total_len, alpha_addr + alpha_line->addr);
}
} else {
ASSERT(0, "the compress mode not support!");
}
u8 *p0 = ptemp;
u8 *p1 = alpha_ptemp;
int line_num;
if (file.compress == 0) {
line_num = lines;
} else {
if (alpha_addr) {
line_num = (line->num > alpha_line->num) ? alpha_line->num : line->num;
} else {
line_num = line->num;
}
}
int hs;
int he;
int hstep;
he = h + line_num;
if ((quadrant == 1) || (quadrant == 2)) {
hs = r.height - h - 1;
hstep = -1;
} else {
hs = h;
hstep = 1;
}
for (hh = 0, h = hs; hh < line_num; hh++, h += hstep) {
if (file.compress == 1) {
if (line_update(mask, r.top + h - dc->disp.top, dc->disp.width)) {
Rle_Decode(p0, line->len[hh], pixelbuf, file.width * 2, vw * 2, r.width * 2, 2);
p0 += line->len[hh];
if (alpha_addr) {
Rle_Decode(p1, alpha_line->len[hh], alphabuf, file.width, vw, r.width, 1);
p1 += alpha_line->len[hh];
}
} else {
p0 += line->len[hh];
p1 += alpha_line->len[hh];
continue;
}
}
u16 *pdisp = (u16 *)dc->buf;
u16 *pixelbuf16 = (u16 *)pixelbuf;
if (!alpha_addr) {
u16 x0 = r.left;
u16 y0 = r.top + h;
int offset = (y0 - dc->disp.top) * dc->disp.width + (x0 - dc->disp.left);
/* if ((offset * 2 + 1) < dc->len) { */
/* pdisp[offset] = pixel; */
/* } */
memcpy(&pdisp[offset], pixelbuf16, r.width * 2);
if (file.compress == 0) {
pixelbuf += file.width * 2;
}
continue;
}
for (w = 0; w < r.width; w++) {
u16 color, pixel;
u8 alpha = alpha_addr ? alphabuf[w] : 255;
pixel = color = pixelbuf16[w];
if (alpha) {
if (platform_api->draw_point) {
int vww = w;
if ((quadrant == 2) || (quadrant == 3)) {
vww = r.width - w - 1;
}
u16 x0 = r.left + vww;
u16 y0 = r.top + h;
if (alpha < 255) {
u16 backcolor = platform_api->read_point(dc, x0, y0);
pixel = get_mixed_pixel((backcolor >> 8) | (backcolor & 0xff) << 8, (color >> 8) | (color & 0xff) << 8, alpha);
}
if (mask) {
int yy = y0 - dc->disp.top;
int xx = x0 - dc->disp.left;
if (yy >= dc->disp.height) {
continue;
}
if (xx >= dc->disp.width) {
continue;
}
if (mask[yy * ((dc->disp.width + 7) / 8) + xx / 8] & BIT(xx % 8)) {
int offset = (y0 - dc->disp.top) * dc->disp.width + (x0 - dc->disp.left);
if ((offset * 2 + 1) < dc->len) {
pdisp[offset] = pixel;
}
}
} else {
int offset = (y0 - dc->disp.top) * dc->disp.width + (x0 - dc->disp.left);
if ((offset * 2 + 1) < dc->len) {
pdisp[offset] = pixel;
}
}
}
}
}
if (file.compress == 0) {
pixelbuf += file.width * 2;
alphabuf += file.width;
}
}
h = he;
}
}
}
return 0;
}
int get_multi_string_width(struct draw_context *dc, u8 *str, int *str_width, int *str_height)
{
struct image_file file;
u8 *p = str;
int width = 0;
while (*p != 0) {
select_strfile(dc->prj);
if (open_string_pic(&file, *p)) {
return -EINVAL;
}
width += file.width;
p++;
}
*str_width = width;
*str_height = file.height;
return 0;
}
struct font_info *text_font_init(u8 init)
{
static struct font_info *info = NULL;
static int language = 0;
if (init) {
if (!info || (language != ui_language_get())) {
language = ui_language_get();
if (info) {
font_close(info);
}
info = font_open(NULL, language);
ASSERT(info, "font_open fail!");
}
} else {
if (info) {
font_close(info);
info = NULL;
}
}
return info;
}
static int br23_show_text(struct draw_context *dc, struct ui_text_attrs *text)
{
struct rect draw_r;
struct rect r = {0};
struct rect disp = {0};
struct image_file file;
/* 控件从绝对x,y 转成相对图层的x,y */
int x = dc->rect.left;
int y = dc->rect.top;
/* 绘制区域从绝对x,y 转成相对图层的x,y */
draw_r.left = dc->draw.left;
draw_r.top = dc->draw.top;
draw_r.width = dc->draw.width;
draw_r.height = dc->draw.height;
if (text->format && !strcmp(text->format, "text")) {
struct font_info *info = text_font_init(true);
if (info && (FT_ERROR_NONE == (info->sta & (~(FT_ERROR_NOTABFILE | FT_ERROR_NOPIXFILE))))) {
info->disp.map = 0;
info->disp.rect = &draw_r;
info->disp.format = dc->data_format;
if ((dc->data_format == DC_DATA_FORMAT_MONO) && (text->color == UI_RGB565(TEXT_MONO_INV))) {
if (__this->api->fill_rect) {
__this->api->fill_rect(dc, UI_RGB565(BGC_MONO_SET));
}
}
if (dc->data_format == DC_DATA_FORMAT_OSD16) {
info->disp.color = text->color;
} else if (dc->data_format == DC_DATA_FORMAT_MONO) {
if (text->color == UI_RGB565(TEXT_MONO_INV)) {
info->disp.color = 0x55aa;//清显示
} else {
info->disp.color = (text->color != UI_RGB565(TEXT_MONO_CLR)) ? (text->color ? text->color : 0xffff) : 0x55aa;
}
}
info->dc = dc;
info->text_width = draw_r.width;
info->text_height = draw_r.height;
info->flags = text->flags;
/* info->offset = text->offset; */
int roll = 0;//需要滚动
int multi_line = 0;
/* FONT_SHOW_MULTI_LINE */
if (text->encode == FONT_ENCODE_ANSI) {
int width = font_text_width(info, (u8 *)text->str, text->strlen);
int height;
if (info->ascpixel.size) {
height = info->ascpixel.size;
} else if (info->pixel.size) {
height = info->pixel.size;
} else {
ASSERT(0, "can't get the height of font.");
}
if (width > dc->rect.width) {
width = dc->rect.width;
roll = 1;
multi_line = 1;
}
if (text->flags & FONT_SHOW_MULTI_LINE) {
height += multi_line * height;
}
if (height > dc->rect.height) {
height = dc->rect.height;
}
y += (dc->rect.height / 2 - height / 2);
if (dc->align == UI_ALIGN_CENTER) {
x += (dc->rect.width / 2 - width / 2);
} else if (dc->align == UI_ALIGN_RIGHT) {
x += (dc->rect.width - width);
}
if (dc->draw_img.en) {//指定坐标刷新
x = dc->draw_img.x;
y = dc->draw_img.y;
}
info->x = x;
info->y = y;
int len = font_textout(info, (u8 *)(text->str + roll * text->offset * 2), text->strlen - roll * text->offset * 2, x, y);
ASSERT(len <= 255);
text->displen = len;
} else if (text->encode == FONT_ENCODE_UNICODE) {
if (FT_ERROR_NONE == (info->sta & ~(FT_ERROR_NOTABFILE | FT_ERROR_NOPIXFILE))) {
if (text->endian == FONT_ENDIAN_BIG) {
info->bigendian = true;
} else {
info->bigendian = false;
}
int width = font_textw_width(info, (u8 *)text->str, text->strlen);
int height;
if (info->ascpixel.size) {
height = info->ascpixel.size;
} else if (info->pixel.size) {
height = info->pixel.size;
} else {
ASSERT(0, "can't get the height of font.");
}
if (width > dc->rect.width) {
width = dc->rect.width;
roll = 1;
multi_line = 1;
}
if (text->flags & FONT_SHOW_MULTI_LINE) {
height += multi_line * height;
}
if (height > dc->rect.height) {
height = dc->rect.height;
}
y += (dc->rect.height / 2 - height / 2);
if (dc->align == UI_ALIGN_CENTER) {
x += (dc->rect.width / 2 - width / 2);
} else if (dc->align == UI_ALIGN_RIGHT) {
x += (dc->rect.width - width);
}
if (dc->draw_img.en) {//指定坐标刷新
x = dc->draw_img.x;
y = dc->draw_img.y;
}
info->x = x;
info->y = y;
int len = font_textout_unicode(info, (u8 *)(text->str + roll * text->offset * 2), text->strlen - roll * text->offset * 2, x, y);
ASSERT(len <= 255);
text->displen = len;
}
} else {
int width = font_textu_width(info, (u8 *)text->str, text->strlen);
int height;
if (info->ascpixel.size) {
height = info->ascpixel.size;
} else if (info->pixel.size) {
height = info->pixel.size;
} else {
ASSERT(0, "can't get the height of font.");
}
if (width > dc->rect.width) {
width = dc->rect.width;
}
if (height > dc->rect.height) {
height = dc->rect.height;
}
y += (dc->rect.height / 2 - height / 2);
if (dc->align == UI_ALIGN_CENTER) {
x += (dc->rect.width / 2 - width / 2);
} else if (dc->align == UI_ALIGN_RIGHT) {
x += (dc->rect.width - width);
}
if (dc->draw_img.en) {//指定坐标刷新
x = dc->draw_img.x;
y = dc->draw_img.y;
}
info->x = x;
info->y = y;
int len = font_textout_utf8(info, (u8 *)text->str, text->strlen, x, y);
ASSERT(len <= 255);
text->displen = len;
}
}
} else if (text->format && !strcmp(text->format, "ascii")) {
char *str;
u32 w_sum;
if (!text->str) {
return 0;
}
if ((u8)text->str[0] == 0xff) {
return 0;
}
if (dc->align == UI_ALIGN_CENTER) {
w_sum = font_ascii_width_check(text->str);
x += (dc->rect.width / 2 - w_sum / 2);
} else if (dc->align == UI_ALIGN_RIGHT) {
w_sum = font_ascii_width_check(text->str);
x += (dc->rect.width - w_sum);
}
if (dc->draw_img.en) {//指定坐标刷新
x = dc->draw_img.x;
y = dc->draw_img.y;
}
if ((dc->data_format == DC_DATA_FORMAT_MONO) && (text->color == UI_RGB565(TEXT_MONO_INV))) {
if (__this->api->fill_rect) {
__this->api->fill_rect(dc, UI_RGB565(BGC_MONO_SET));
}
}
str = text->str;
while (*str) {
u8 *pixbuf = dc->fbuf;
int width;
int height;
int color;
font_ascii_get_pix(*str, pixbuf, dc->fbuf_len, &height, &width);
if (dc->data_format == DC_DATA_FORMAT_OSD16) {
color = text->color;
} else if (dc->data_format == DC_DATA_FORMAT_MONO) {
if (text->color == UI_RGB565(TEXT_MONO_INV)) {
color = 0x55aa;//清显示
} else {
color = (text->color != UI_RGB565(TEXT_MONO_CLR)) ? (text->color ? text->color : 0xffff) : 0x55aa;
}
}
__font_pix_copy(dc, dc->data_format, 0, pixbuf, &draw_r, x, y, height, width, color);
x += width;
str++;
}
} else if (text->format && !strcmp(text->format, "strpic")) {
u16 id = (u8)text->str[0];
u8 *pixbuf;
int w;
int h;
if (id == 0xffff) {
return 0;
}
select_strfile(dc->prj);
if (open_string_pic(&file, id)) {
return 0;
}
y += (dc->rect.height / 2 - file.height / 2);
if (dc->align == UI_ALIGN_CENTER) {
x += (dc->rect.width / 2 - file.width / 2);
} else if (dc->align == UI_ALIGN_RIGHT) {
x += (dc->rect.width - file.width);
}
pixbuf = dc->fbuf;
if (!pixbuf) {
return -ENOMEM;
}
if (dc->draw_img.en) {
x = dc->draw_img.x;
y = dc->draw_img.y;
}
disp.left = x;
disp.top = y;
disp.width = file.width;
disp.height = file.height;
if (get_rect_cover(&draw_r, &disp, &r)) {
if ((dc->data_format == DC_DATA_FORMAT_MONO) && (text->color == UI_RGB565(TEXT_MONO_INV))) {
if (__this->api->fill_rect) {
__this->api->fill_rect(dc, UI_RGB565(BGC_MONO_SET));
}
}
for (h = 0; h < file.height; h += 8) {
if (file.compress == 0) {
int offset = (h / 8) * file.width;
if (br23_read_str_data(&file, pixbuf, file.width, offset) != file.width) {
return -EFAULT;
}
} else {
ASSERT(0, "the compress mode not support!");
}
int color;
if (dc->data_format == DC_DATA_FORMAT_OSD16) {
color = text->color;
} else if (dc->data_format == DC_DATA_FORMAT_MONO) {
if (text->color == UI_RGB565(TEXT_MONO_INV)) {
color = 0x55aa;//清显示
} else {
color = (text->color != UI_RGB565(TEXT_MONO_CLR)) ? (text->color ? text->color : 0xffff) : 0x55aa;
}
}
__font_pix_copy(dc, dc->data_format, 0, pixbuf, &r, x, y + h / 8 * 8, 8, file.width, color);
}
}
} else if (text->format && !strcmp(text->format, "mulstr")) {
u16 id = (u8)text->str[0];
u8 *pixbuf;
int w;
int h;
u8 *p = text->str;
select_strfile(dc->prj);
if (get_multi_string_width(dc, text->str, &w, &h)) {
return -EINVAL;
}
y += (dc->rect.height / 2 - h / 2);
if (dc->align == UI_ALIGN_CENTER) {
x += (dc->rect.width / 2 - w / 2);
} else if (dc->align == UI_ALIGN_RIGHT) {
x += (dc->rect.width - w);
}
while (*p != 0) {
id = *p;
if (id == 0xffff) {
return 0;
}
select_strfile(dc->prj);
if (open_string_pic(&file, id)) {
return 0;
}
pixbuf = dc->fbuf;
if (!pixbuf) {
return -ENOMEM;
}
disp.left = x;
disp.top = y;
disp.width = file.width;
disp.height = file.height;
if (get_rect_cover(&draw_r, &disp, &r)) {
if ((dc->data_format == DC_DATA_FORMAT_MONO) && (text->color == UI_RGB565(TEXT_MONO_INV))) {
if (__this->api->fill_rect) {
__this->api->fill_rect(dc, UI_RGB565(BGC_MONO_SET));
}
}
for (h = 0; h < file.height; h += 8) {
if (file.compress == 0) {
int offset = (h / 8) * file.width;
if (br23_read_str_data(&file, pixbuf, file.width, offset) != file.width) {
return -EFAULT;
}
} else {
ASSERT(0, "the compress mode not support!");
}
int color;
if (dc->data_format == DC_DATA_FORMAT_OSD16) {
color = text->color;
} else if (dc->data_format == DC_DATA_FORMAT_MONO) {
if (text->color == UI_RGB565(TEXT_MONO_INV)) {
color = 0x55aa;//清显示
} else {
color = (text->color != UI_RGB565(TEXT_MONO_CLR)) ? (text->color ? text->color : 0xffff) : 0x55aa;
}
}
__font_pix_copy(dc, dc->data_format, 0, pixbuf, &r, x, y + h / 8 * 8, 8, file.width, color);
}
}
x += file.width;
p++;
}
} else if (text->format && !strcmp(text->format, "image")) {
u8 *pixelbuf;
u8 *temp_pixelbuf;
u8 *alphabuf;
u8 *temp_alphabuf;
u16 cnt = 0;
u16 id = ((u8)text->str[1] << 8) | (u8)text->str[0];
u32 w, h;
int ww, hh;
if (image_str_size_check(dc, dc->page, text->str, &ww, &hh) != 0) {
return -EFAULT;
}
if (dc->align == UI_ALIGN_CENTER) {
x += (dc->rect.width / 2 - ww / 2);
} else if (dc->align == UI_ALIGN_RIGHT) {
x += (dc->rect.width - ww);
}
y += (dc->rect.height / 2 - hh / 2);
while ((id != 0x00ff) && (id != 0xffff)) {
select_resfile(dc->prj);
if (open_image_by_id(NULL, &file, id, dc->page) != 0) {
return -EFAULT;
}
disp.left = x;
disp.top = y;
disp.width = file.width;
disp.height = file.height;
if (dc->data_format == DC_DATA_FORMAT_MONO) {
pixelbuf = dc->fbuf;
if (get_rect_cover(&draw_r, &disp, &r)) {
int _offset = -1;
for (h = 0; h < r.height; h++) {
if (file.compress == 0) {
int offset = (r.top + h - disp.top) / 8 * file.width + (r.left - disp.left);
if (_offset != offset) {
if (br23_read_image_data(NULL, &file, pixelbuf, r.width, offset) != r.width) {
return -EFAULT;
}
_offset = offset;
}
} else {
ASSERT(0, "the compress mode not support!");
}
for (w = 0; w < r.width; w++) {
u8 color = (pixelbuf[w] & BIT((r.top + h - disp.top) % 8)) ? 1 : 0;
if (color) {
if (platform_api->draw_point) {
u16 text_color;
if (text->color != 0xffffff) {
text_color = (text->color != UI_RGB565(TEXT_MONO_CLR)) ? (text->color ? text->color : 0xffff) : 0x55aa;
} else {
text_color = color;
}
platform_api->draw_point(dc, r.left + w, r.top + h, text_color);
}
}
}
}
}
} else if (dc->data_format == DC_DATA_FORMAT_OSD16) {
int temp_pixelbuf_len = dc->width * 2 * dc->lines + 0x40 - 8;
int temp_alphabuf_len = dc->width * dc->lines + 0x40 - 8;
int buf_offset;
buf_offset = 0;
pixelbuf = &dc->fbuf[buf_offset];//2 bytes * line
buf_offset += dc->width * 2;
buf_offset = (buf_offset + 3) / 4 * 4;
alphabuf = &dc->fbuf[buf_offset];//1 bytes * line
buf_offset += dc->width;
buf_offset = (buf_offset + 3) / 4 * 4;
temp_pixelbuf = &dc->fbuf[buf_offset];
buf_offset += temp_pixelbuf_len;
buf_offset = (buf_offset + 3) / 4 * 4;
temp_alphabuf = &dc->fbuf[buf_offset];
u32 alpha_addr = 0;
if (get_rect_cover(&draw_r, &disp, &r)) {
for (h = 0; h < r.height;) {
int vh = r.top + h - disp.top;
int vw = r.left - disp.left;
struct rle_line *line;
struct rle_line *alpha_line;
u8 *ptemp;
u8 *alpha_ptemp;
if (file.compress == 0) {
int offset = 4 + vh * file.width * 2 + vw * 2;
if (br23_read_image_data(NULL, &file, pixelbuf, r.width * 2, offset) != r.width * 2) {
return -EFAULT;
}
br23_read_image_data(NULL, &file, &alpha_addr, sizeof(alpha_addr), 0);
if (alpha_addr) {
offset = alpha_addr + vh * file.width + vw;
br23_read_image_data(NULL, &file, alphabuf, r.width, offset);
}
} else if (file.compress == 1) {
int remain = (r.height - h) > (file.height - vh) ? (file.height - vh) : (r.height - h);
int headlen = sizeof(struct rle_header) + (remain * 2 + 3) / 4 * 4;
line = (struct rle_line *)temp_pixelbuf;
ptemp = &temp_pixelbuf[headlen];
memset(line, 0x00, sizeof(struct rle_line));
int rle_header_len = sizeof(struct rle_header) * remain;
br23_read_image_data(NULL, &file, ptemp, rle_header_len, 4 + vh * sizeof(struct rle_header));
int i;
struct rle_header *rle = (struct rle_header *)ptemp;
int total_len = 0;
for (i = 0; i < remain; i++) {
if (i == 0) {
line->addr = rle[i].addr;
line->len[i] = rle[i].len;
} else {
line->len[i] = rle[i].len;
}
if ((total_len + rle[i].len) > (temp_pixelbuf_len - headlen)) {
break;
}
total_len += rle[i].len;
line->num ++;
}
br23_read_image_data(NULL, &file, ptemp, total_len, 4 + line->addr);
br23_read_image_data(NULL, &file, &alpha_addr, sizeof(alpha_addr), 0);
if (alpha_addr) {
int headlen = sizeof(struct rle_header) + (line->num * 2 + 3) / 4 * 4;
alpha_ptemp = &temp_alphabuf[headlen];
br23_read_image_data(NULL, &file, alpha_ptemp, sizeof(struct rle_header)*line->num, alpha_addr + vh * sizeof(struct rle_header));
struct rle_header *rle = (struct rle_header *)alpha_ptemp;
alpha_line = (struct rle_line *)temp_alphabuf;
memset(alpha_line, 0x00, sizeof(struct rle_line));
int total_len = 0;
for (i = 0; i < line->num; i++) {
if (i == 0) {
alpha_line->addr = rle[i].addr;
alpha_line->len[i] = rle[i].len;
} else {
alpha_line->len[i] = rle[i].len;
}
if ((total_len + rle[i].len) > (temp_alphabuf_len - headlen)) {
break;
}
total_len += rle[i].len;
alpha_line->num ++;
}
br23_read_image_data(NULL, &file, alpha_ptemp, total_len, alpha_addr + alpha_line->addr);
}
} else {
ASSERT(0, "the compress mode not support!");
}
u8 *p0 = ptemp;
u8 *p1 = alpha_ptemp;
int line_num;
if (file.compress == 0) {
line_num = 1;
} else {
line_num = (line->num > alpha_line->num) ? alpha_line->num : line->num;
}
for (hh = 0; hh < line_num; hh++, h++) {
if (file.compress == 1) {
Rle_Decode(p0, line->len[hh], pixelbuf, file.width * 2, vw * 2, r.width * 2, 2);
p0 += line->len[hh];
Rle_Decode(p1, alpha_line->len[hh], alphabuf, file.width, vw, r.width, 1);
p1 += alpha_line->len[hh];
}
u16 *pdisp = (u16 *)dc->buf;
u16 *pixelbuf16 = (u16 *)pixelbuf;
for (w = 0; w < r.width; w++) {
u16 color, pixel;
u8 alpha = alpha_addr ? alphabuf[w] : 255;
pixel = color = pixelbuf16[w];
if (alpha) {
if (platform_api->draw_point) {
int vww = w;
u16 x0 = r.left + vww;
u16 y0 = r.top + h;
if (alpha < 255) {
u16 backcolor = platform_api->read_point(dc, x0, y0);
pixel = get_mixed_pixel((backcolor >> 8) | (backcolor & 0xff) << 8, (color >> 8) | (color & 0xff) << 8, alpha);
}
int offset = (y0 - dc->disp.top) * dc->disp.width + (x0 - dc->disp.left);
if ((offset * 2 + 1) < dc->len) {
pdisp[offset] = pixel;
}
}
}
}
}
}
}
}
x += file.width;
cnt += 2;
id = ((u8)text->str[cnt + 1] << 8) | (u8)text->str[cnt];
}
}
return 0;
}
#include "ui/ui_circle.h"
void ui_draw_circle(struct draw_context *dc, int center_x, int center_y,
int radius_small, int radius_big, int angle_begin,
int angle_end, int color, int percent)
{
struct circle_info info;
info.center_x = center_x;
info.center_y = center_y;
info.radius_big = radius_big;
info.radius_small = radius_small;
info.angle_begin = angle_begin;
info.angle_end = angle_end;
info.left = dc->draw.left;
info.top = dc->draw.top;
info.width = dc->draw.width;
info.height = dc->draw.height;
info.x = 0;
info.y = 0;
info.disp_x = dc->disp.left;
info.disp_y = dc->disp.top;
info.color = color;
info.bitmap_width = dc->disp.width;
info.bitmap_height = dc->disp.height;
info.bitmap_pitch = dc->disp.width * 2;
info.bitmap = dc->buf;
info.bitmap_size = dc->len;
info.bitmap_depth = 16;
draw_circle_by_percent(&info, percent);
}
AT_UI_RAM
u32 br23_read_point(struct draw_context *dc, u16 x, u16 y)
{
u32 pixel;
u16 *pdisp = dc->buf;
if (dc->data_format == DC_DATA_FORMAT_OSD16) {
int offset = (y - dc->disp.top) * dc->disp.width + (x - dc->disp.left);
ASSERT((offset * 2 + 1) < dc->len, "dc->len:%d", dc->len);
if ((offset * 2 + 1) >= dc->len) {
return -1;
}
pixel = pdisp[offset];//(dc->buf[offset * 2] << 8) | dc->buf[offset * 2 + 1];
} else {
ASSERT(0);
}
return pixel;
}
__attribute__((always_inline_when_const_args))
AT_UI_RAM
int br23_draw_point(struct draw_context *dc, u16 x, u16 y, u32 pixel)
{
if (dc->data_format == DC_DATA_FORMAT_OSD16) {
int offset = (y - dc->disp.top) * dc->disp.width + (x - dc->disp.left);
/* ASSERT((offset * 2 + 1) < dc->len, "dc->len:%d", dc->len); */
if ((offset * 2 + 1) >= dc->len) {
return -1;
}
dc->buf[offset * 2 ] = pixel >> 8;
dc->buf[offset * 2 + 1] = pixel;
} else if (dc->data_format == DC_DATA_FORMAT_MONO) {
/* ASSERT(x < __this->info.width); */
/* ASSERT(y < __this->info.height); */
if ((x >= __this->info.width) || (y >= __this->info.height)) {
return -1;
}
if (pixel & BIT(31)) {
dc->buf[y / 8 * __this->info.width + x] ^= BIT(y % 8);
} else if (pixel == 0x55aa) {
dc->buf[y / 8 * __this->info.width + x] &= ~BIT(y % 8);
} else if (pixel) {
dc->buf[y / 8 * __this->info.width + x] |= BIT(y % 8);
} else {
dc->buf[y / 8 * __this->info.width + x] &= ~BIT(y % 8);
}
}
return 0;
}
int br23_open_device(struct draw_context *dc, const char *device)
{
return 0;
}
int br23_close_device(int fd)
{
return 0;
}
int ui_fill_rect(struct draw_context *dc, int left, int top, int width, int height, u32 acolor)
{
int i;
int w, h;
u16 color = acolor & 0xffff;
if (!dc->buf) {
return 0;
}
struct rect rect;
rect.left = left;
rect.top = top;
rect.width = width;
rect.height = height;
struct rect cover;
if (!get_rect_cover(&dc->draw, &rect, &cover)) {
return 0;
}
if (dc->data_format == DC_DATA_FORMAT_MONO) {
color = (color == UI_RGB565(BGC_MONO_SET)) ? 0xffff : 0x55aa;
for (h = 0; h < cover.height; h++) {
for (w = 0; w < cover.width; w++) {
if (platform_api->draw_point) {
platform_api->draw_point(dc, cover.left + w, cover.top + h, color);
}
}
}
} else {
#if 0
for (h = 0; h < cover.height; h++) {
for (w = 0; w < cover.width; w++) {
if (platform_api->draw_point) {
platform_api->draw_point(dc, cover.left + w, cover.top + h, color);
}
}
}
#else
u16 color16 = (color >> 8) | ((color & 0xff) << 8);
u32 color32 = (color16 << 16) | color16;
h = 0;
u32 *p32 = (u32 *)&dc->buf[(cover.top + h - dc->disp.top) * dc->disp.width * 2 + (cover.left - dc->disp.left) * 2];
u32 *_p32 = p32;
u32 len = cover.width * 2;
if ((u32)p32 % 4) {
u16 *p16 = (u16 *)p32;
*p16++ = color16;
p32 = (u32 *)p16;
len -= 2;
ASSERT((u32)p32 % 4 == 0);
}
u32 count = len / 4;
while (count--) {
*p32++ = color32;
}
count = (len % 4) / 2;
u16 *p16 = (u16 *)p32;
while (count--) {
*p16++ = color16;
}
for (h = 1; h < cover.height; h++) {
u32 *__p32 = (u32 *)&dc->buf[(cover.top + h - dc->disp.top) * dc->disp.width * 2 + (cover.left - dc->disp.left) * 2];
memcpy(__p32, _p32, cover.width * 2);
}
#endif
}
return 0;
}
int ui_draw_image(struct draw_context *dc, int page, int id, int x, int y)
{
dc->draw_img.en = true;
dc->draw_img.x = x;
dc->draw_img.y = y;
dc->draw_img.id = id;
dc->draw_img.page = page;
return br23_draw_image(dc, id, 0, NULL);
}
int ui_draw_ascii(struct draw_context *dc, char *str, int strlen, int x, int y, int color)
{
struct ui_text_attrs text = {0};
text.str = str;
text.format = "ascii";
text.color = color;
text.strlen = strlen;
text.flags = FONT_DEFAULT;
dc->draw_img.en = true;
dc->draw_img.x = x;
dc->draw_img.y = y;
return br23_show_text(dc, &text);
}
int ui_draw_text(struct draw_context *dc, int encode, int endian, char *str, int strlen, int x, int y, int color)
{
struct ui_text_attrs text = {0};
text.str = str;
text.format = "text";
text.color = color;
text.strlen = strlen;
text.encode = encode;
text.endian = endian;
text.flags = FONT_DEFAULT;
dc->draw_img.en = true;
dc->draw_img.x = x;
dc->draw_img.y = y;
return br23_show_text(dc, &text);
}
int ui_draw_strpic(struct draw_context *dc, int id, int x, int y, int color)
{
struct ui_text_attrs text = {0};
u8 strbuf;
strbuf = id;
text.str = &strbuf;
text.format = "strpic";
text.color = color;
text.strlen = 0;
text.encode = 0;
text.endian = 0;
text.flags = 0;
dc->draw_img.en = true;
dc->draw_img.x = x;
dc->draw_img.y = y;
return br23_show_text(dc, &text);
}
int ui_draw_set_pixel(struct draw_context *dc, int x, int y, int pixel)
{
return platform_api->draw_point(dc, x, y, pixel);
}
u32 ui_draw_get_pixel(struct draw_context *dc, int x, int y)
{
return platform_api->read_point(dc, x, y);
}
u16 ui_draw_get_mixed_pixel(u16 backcolor, u16 forecolor, u8 alpha)
{
return get_mixed_pixel(backcolor, forecolor, alpha);
}
static const struct ui_platform_api br23_platform_api = {
.malloc = br23_malloc,
.free = br23_free,
.load_style = br23_load_style,
.load_window = br23_load_window,
.unload_window = br23_unload_window,
.open_draw_context = br23_open_draw_context,
.get_draw_context = br23_get_draw_context,
.put_draw_context = br23_put_draw_context,
.set_draw_context = br23_set_draw_context,
.close_draw_context = br23_close_draw_context,
.load_widget_info = br23_load_widget_info,
.load_css = br23_load_css,
.load_image_list = br23_load_image_list,
.load_text_list = br23_load_text_list,
.fill_rect = br23_fill_rect,
.draw_rect = br23_draw_rect,
.draw_image = br23_draw_image,
.show_text = br23_show_text,
.read_point = br23_read_point,
.draw_point = br23_draw_point,
.invert_rect = br23_invert_rect,
.read_image_info = br23_read_image_info,
.open_device = br23_open_device,
.close_device = br23_close_device,
.set_timer = br23_set_timer,
.del_timer = br23_del_timer,
.file_browser_open = NULL,
.get_file_attrs = NULL,
.set_file_attrs = NULL,
.show_file_preview = NULL,
.move_file_preview = NULL,
.clear_file_preview = NULL,
.flush_file_preview = NULL,
.open_file = NULL,
.delete_file = NULL,
.file_browser_close = NULL,
};
static int open_resource_file()
{
int ret;
printf("open_resouece_file...\n");
ret = open_resfile(RES_PATH"JL.res");
if (ret) {
return -EINVAL;
}
ret = open_str_file(RES_PATH"JL.str");
if (ret) {
return -EINVAL;
}
ret = font_ascii_init(RES_PATH"ascii.res");
if (ret) {
return -EINVAL;
}
return 0;
}
int __attribute__((weak)) lcd_get_scrennifo(struct fb_var_screeninfo *info)
{
info->s_xoffset = 0;
info->s_yoffset = 0;
info->s_xres = 240;
info->s_yres = 240;
return 0;
}
int ui_platform_init(void *lcd)
{
struct rect rect;
struct lcd_info info = {0};
#ifdef UI_BUF_CALC
INIT_LIST_HEAD(&buffer_used.list);
#endif
__this->api = &br23_platform_api;
ASSERT(__this->api->open_draw_context);
ASSERT(__this->api->get_draw_context);
ASSERT(__this->api->put_draw_context);
ASSERT(__this->api->set_draw_context);
ASSERT(__this->api->close_draw_context);
__this->lcd = lcd_get_hdl();
ASSERT(__this->lcd);
ASSERT(__this->lcd->init);
ASSERT(__this->lcd->get_screen_info);
ASSERT(__this->lcd->buffer_malloc);
ASSERT(__this->lcd->buffer_free);
ASSERT(__this->lcd->draw);
ASSERT(__this->lcd->set_draw_area);
ASSERT(__this->lcd->backlight_ctrl);
if (__this->lcd->init) {
__this->lcd->init(lcd);
}
if (__this->lcd->backlight_ctrl) {
__this->lcd->backlight_ctrl(true);
}
if (__this->lcd->get_screen_info) {
__this->lcd->get_screen_info(&info);
}
rect.left = 0;
rect.top = 0;
rect.width = info.width;
rect.height = info.height;
printf("ui_platform_init :: [%d,%d,%d,%d]\n", rect.left, rect.top, rect.width, rect.height);
ui_core_init(__this->api, &rect);
return 0;
}
int ui_style_file_version_compare(int version)
{
int v;
int len;
struct ui_file_head head;
static u8 checked = 0;
if (checked == 0) {
if (!ui_file) {
puts("ui version_compare ui_file null!\n");
ASSERT(0);
return 0;
}
res_fseek(ui_file, 0, SEEK_SET);
len = sizeof(struct ui_file_head);
res_fread(ui_file, &head, len);
printf("style file version is: 0x%x,UI_VERSION is: 0x%x\n", *(u32 *)(head.res), version);
if (*(u32 *)head.res != version) {
puts("style file version is not the same as UI_VERSION !!\n");
ASSERT(0);
}
checked = 1;
}
return 0;
}
int ui_upgrade_file_check_valid()
{
#if UI_UPGRADE_RES_ENABLE
//简单实现
//假设升级界面必须存在，调用了该接口证明资源不完整
//需要进行升级
smartbox_eflash_flag_set(1);//这个标志的清理需要注意
return 0;
#endif
return -ENOENT;
}
int ui_file_check_valid()
{
return 0;
}
#endif
Reference in New Issue Copy Permalink