Unnamed: 0
int64 0
0
| repo_id
stringlengths 5
186
| file_path
stringlengths 15
223
| content
stringlengths 1
32.8M
⌀ |
|---|---|---|---|
0 |
repos/awtk/src/ext_widgets
|
repos/awtk/src/ext_widgets/keyboard/candidates.h
|
/**
* File: candidates.h
* Author: AWTK Develop Team
* Brief: input method text candidates
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-06-23 Li XianJing <[email protected]> created
*
*/
#ifndef TK_CANDIDATES_H
#define TK_CANDIDATES_H
#include "tkc/str.h"
#include "base/widget.h"
#include "base/hscrollable.h"
BEGIN_C_DECLS
/**
* @class candidates_t
* @parent widget_t
* @annotation ["scriptable","design","widget"]
* 输入法候选字词控件。
*
* 如果希望启用用数字选择对应的候选字，请设置属性grab_keys="true"。如：
*
* ```xml
* <candidates x="0" y="0" w="100%" h="30" grab_keys="true"/>
* ```
*
*>相关文件： assets/default/raw/ui/kb_default.xml
*
* 如果希望通过左右键切换不同的候选字，除了设置属性grab_keys="true"，还需要设置按钮的focused状态的style。
*
* ```xml
* <style name="candidates" text_color="black">
* <normal />
* <pressed bg_color="#c0c0c0" border_color="#a0a0a0"/>
* <over bg_color="#e0e0e0" border_color="#a0a0a0"/>
* <focused border_color="#a0a0a0"/>
* </style>
* ```
*
*>相关文件：assets/default/raw/styles/keyboard.xml
*
*/
typedef struct _candidates_t {
widget_t widget;
/**
* @property {bool_t} pre
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 是否为预候选字。
*
* > 预候选字: 在有的输入法中，比如T9硬键盘输入时，按下12两个键时，预候选字会显示可用的拼音列表。
* > 从预候选字列表中选择拼音，再查询拼音对应的候选字列表。
*/
bool_t pre;
/**
* @property {bool_t} select_by_num
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 是否启用用数字选择候选字。比如按下1选择第1个候选字，按下2选择第2个候选字。
*
*/
bool_t select_by_num;
/**
* @property {bool_t} auto_hide
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 没有候选字时，是否自动隐藏控件。
*
*/
bool_t auto_hide;
/**
* @property {char*} button_style
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 按钮的style名称。
*/
char* button_style;
/**
* @property {bool_t} enable_preview
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 是否启用候选字预览。
*
*/
bool_t enable_preview;
/*private*/
bool_t expanded;
wh_t normal_h;
uint32_t event_id;
hscrollable_t* hscrollable;
uint32_t candidates_nr;
bool_t is_suggest;
} candidates_t;
/**
* @method candidates_create
* 创建candidates对象
* @annotation ["constructor", "scriptable"]
* @param {widget_t*} parent 父控件
* @param {xy_t} x x坐标
* @param {xy_t} y y坐标
* @param {wh_t} w 宽度
* @param {wh_t} h 高度
*
* @return {widget_t*} 对象。
*/
widget_t* candidates_create(widget_t* parent, xy_t x, xy_t y, wh_t w, wh_t h);
/**
* @method candidates_cast
* 转换为candidates对象(供脚本语言使用)。
* @annotation ["cast", "scriptable"]
* @param {widget_t*} widget candidates对象。
*
* @return {widget_t*} candidates对象。
*/
widget_t* candidates_cast(widget_t* widget);
/**
* @method candidates_set_pre
* 设置是否为预候选字列表。
*
* > 为预候选字列表则注册EVT\_IM\_SHOW\_PRE\_CANDIDATES，否则注册EVT\_IM\_SHOW\_CANDIDATES事件。
*
* @annotation ["scriptable"]
* @param {widget_t*} widget 控件对象。
* @param {bool_t} pre 是否为预候选字列表。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t candidates_set_pre(widget_t* widget, bool_t pre);
/**
* @method candidates_set_select_by_num
* 设置是否启用用数字选择候选字。
*
* @annotation ["scriptable"]
* @param {widget_t*} widget 控件对象。
* @param {bool_t} select_by_num 是否启用用数字选择候选字。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t candidates_set_select_by_num(widget_t* widget, bool_t select_by_num);
/**
* @method candidates_set_auto_hide
* 设置是否自动隐藏。
*
* @annotation ["scriptable"]
* @param {widget_t*} widget 控件对象。
* @param {bool_t} auto_hide 是否自动隐藏。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t candidates_set_auto_hide(widget_t* widget, bool_t auto_hide);
/**
* @method candidates_set_button_style
* 设置按钮的style名称。
*
* @annotation ["scriptable"]
* @param {widget_t*} widget 控件对象。
* @param {const char*} button_style 按钮的style名称。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t candidates_set_button_style(widget_t* widget, const char* button_style);
#define CANDIDATES_PROP_PRE "pre"
#define CANDIDATES_PROP_AUTO_HIDE "auto_hide"
#define CANDIDATES_PROP_BUTTON_STYLE "button_style"
#define CANDIDATES_PROP_SELECT_BY_NUM "select_by_num"
#define CANDIDATES(widget) ((candidates_t*)(candidates_cast(WIDGET(widget))))
/*public for subclass and runtime type check*/
TK_EXTERN_VTABLE(candidates);
END_C_DECLS
#endif /*TK_CANDIDATES_H*/
|
0 |
repos/awtk/src/ext_widgets
|
repos/awtk/src/ext_widgets/mutable_image/mutable_image.c
|
/**
* File: mutable_image.h
* Author: AWTK Develop Team
* Brief: mutable_image
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2019-02-28 Li XianJing <[email protected]> created
*
*/
#include "tkc/mem.h"
#include "tkc/utils.h"
#include "base/timer.h"
#include "blend/image_g2d.h"
#include "base/widget_vtable.h"
#include "mutable_image/mutable_image.h"
static ret_t mutable_image_init_impl(widget_t* widget);
static ret_t mutable_image_invalidate(const timer_info_t* info);
static bitmap_format_t mutable_image_get_disire_format(widget_t* widget, canvas_t* c) {
bitmap_format_t format = BITMAP_FMT_NONE;
mutable_image_t* mutable_image = MUTABLE_IMAGE(widget);
return_value_if_fail(mutable_image != NULL, format);
if (mutable_image->fb != NULL) {
format = (bitmap_format_t)(mutable_image->fb->format);
} else {
format = lcd_get_desired_bitmap_format(c->lcd);
}
return format;
}
static bitmap_t* mutable_image_prepare_image(widget_t* widget, canvas_t* c) {
mutable_image_t* mutable_image = MUTABLE_IMAGE(widget);
bitmap_format_t format = mutable_image_get_disire_format(widget, c);
return_value_if_fail(mutable_image != NULL && mutable_image->prepare_image != NULL, NULL);
if (mutable_image->create_image != NULL) {
void* ctx = mutable_image->create_image_ctx;
mutable_image->image = mutable_image->create_image(ctx, format, mutable_image->image);
} else if (mutable_image->image == NULL) {
mutable_image->image = bitmap_create_ex(widget->w, widget->h, 0, format);
}
if (mutable_image->image == NULL) {
return NULL;
}
if (mutable_image->prepare_image != NULL) {
bitmap_t* image = mutable_image->image;
void* ctx = mutable_image->prepare_image_ctx;
return_value_if_fail(mutable_image->prepare_image(ctx, image) == RET_OK, NULL);
image->flags |= BITMAP_FLAG_CHANGED;
}
return mutable_image->image;
}
ret_t mutable_image_on_paint_self(widget_t* widget, canvas_t* canvas) {
bitmap_t* bitmap = NULL;
mutable_image_t* mutable_image = MUTABLE_IMAGE(widget);
ENSURE(mutable_image);
if (mutable_image->need_redraw != NULL &&
!mutable_image->need_redraw(mutable_image->need_redraw_ctx)) {
bitmap = mutable_image->user_image != NULL ? mutable_image->user_image : mutable_image->image;
} else {
bitmap = mutable_image->user_image != NULL ? mutable_image->user_image
: mutable_image_prepare_image(widget, canvas);
}
if (bitmap == NULL) {
return RET_FAIL;
}
if (mutable_image->fb != NULL) {
rect_t r = rect_init(0, 0, bitmap->w, bitmap->h);
image_copy(mutable_image->fb, bitmap, &r, canvas->ox, canvas->oy);
} else {
if (image_need_transform(widget)) {
vgcanvas_t* vg = canvas_get_vgcanvas(canvas);
if (vg != NULL) {
vgcanvas_save(vg);
image_transform(widget, canvas);
vgcanvas_draw_icon(vg, bitmap, 0, 0, bitmap->w, bitmap->h, 0, 0, widget->w, widget->h);
vgcanvas_restore(vg);
return RET_OK;
}
}
if (bitmap->buffer != NULL) {
rect_t dst = rect_init(0, 0, widget->w, widget->h);
canvas_draw_image_center(canvas, bitmap, &dst);
}
}
return RET_OK;
}
static const char* s_mutable_image_clone_properties[] = {WIDGET_PROP_SCALE_X, WIDGET_PROP_SCALE_Y,
WIDGET_PROP_ANCHOR_X, WIDGET_PROP_ANCHOR_Y,
WIDGET_PROP_ROTATION, NULL};
ret_t mutable_image_on_destroy(widget_t* widget) {
mutable_image_t* mutable_image = MUTABLE_IMAGE(widget);
return_value_if_fail(widget != NULL && mutable_image != NULL, RET_BAD_PARAMS);
if (mutable_image->fb != NULL) {
bitmap_destroy(mutable_image->fb);
mutable_image->fb = NULL;
}
if (mutable_image->image != NULL) {
bitmap_destroy(mutable_image->image);
mutable_image->image = NULL;
}
return image_base_on_destroy(widget);
}
ret_t mutable_image_on_attach_parent(widget_t* widget, widget_t* parent) {
widget_t* win = widget_get_window(parent);
mutable_image_t* mutable_image = MUTABLE_IMAGE(widget);
return_value_if_fail(mutable_image != NULL, RET_BAD_PARAMS);
if (widget_is_designing_window(win)) {
widget_remove_timer(widget, mutable_image->timer_id);
}
return RET_OK;
}
static ret_t mutable_image_set_prop(widget_t* widget, const char* name, const value_t* v) {
mutable_image_t* mutable_image = MUTABLE_IMAGE(widget);
ENSURE(mutable_image);
if (tk_str_eq(name, WIDGET_PROP_IMAGE) || tk_str_eq(name, WIDGET_PROP_VALUE)) {
mutable_image->user_image = (bitmap_t*)value_bitmap(v);
if (mutable_image->user_image != NULL && mutable_image->image != NULL) {
bitmap_destroy(mutable_image->image);
mutable_image->image = NULL;
}
return mutable_image->user_image != NULL ? RET_OK : RET_BAD_PARAMS;
}
return image_base_set_prop(widget, name, v);
}
TK_DECL_VTABLE(mutable_image) = {.size = sizeof(mutable_image_t),
.type = WIDGET_TYPE_MUTABLE_IMAGE,
.clone_properties = s_mutable_image_clone_properties,
.get_parent_vt = TK_GET_PARENT_VTABLE(image_base),
.create = mutable_image_create,
.init = mutable_image_init_impl,
.on_destroy = mutable_image_on_destroy,
.on_event = image_base_on_event,
.on_paint_self = mutable_image_on_paint_self,
.on_paint_background = widget_on_paint_null,
.on_attach_parent = mutable_image_on_attach_parent,
.set_prop = mutable_image_set_prop,
.get_prop = image_base_get_prop};
static ret_t mutable_image_init_impl(widget_t* widget) {
mutable_image_t* mutable_image = MUTABLE_IMAGE(widget);
return_value_if_fail(mutable_image != NULL, RET_BAD_PARAMS);
image_base_init(widget);
mutable_image->timer_id = widget_add_timer(widget, mutable_image_invalidate, 16);
if (widget != NULL && widget->parent != NULL) {
mutable_image_on_attach_parent(widget, widget->parent);
}
return RET_OK;
}
static ret_t mutable_image_invalidate(const timer_info_t* info) {
widget_t* widget = WIDGET(info->ctx);
mutable_image_t* mutable_image = MUTABLE_IMAGE(widget);
ENSURE(mutable_image);
if (mutable_image->need_redraw == NULL ||
mutable_image->need_redraw(mutable_image->need_redraw_ctx)) {
widget_invalidate_force(WIDGET(info->ctx), NULL);
}
return RET_REPEAT;
}
widget_t* mutable_image_create(widget_t* parent, xy_t x, xy_t y, wh_t w, wh_t h) {
widget_t* widget = widget_create(parent, TK_REF_VTABLE(mutable_image), x, y, w, h);
return_value_if_fail(mutable_image_init_impl(widget) == RET_OK, NULL);
return widget;
}
widget_t* mutable_image_init(widget_t* widget) {
return_value_if_fail(mutable_image_init_impl(widget) == RET_OK, NULL);
return widget;
}
ret_t mutable_image_set_prepare_image(widget_t* widget, mutable_image_prepare_image_t prepare_image,
void* prepare_image_ctx) {
mutable_image_t* mutable_image = MUTABLE_IMAGE(widget);
return_value_if_fail(mutable_image != NULL && prepare_image != NULL, RET_BAD_PARAMS);
mutable_image->prepare_image = prepare_image;
mutable_image->prepare_image_ctx = prepare_image_ctx;
return RET_OK;
}
ret_t mutable_image_set_need_redraw(widget_t* widget, mutable_image_need_redraw_t need_redraw,
void* need_redraw_ctx) {
mutable_image_t* mutable_image = MUTABLE_IMAGE(widget);
return_value_if_fail(mutable_image != NULL && need_redraw != NULL, RET_BAD_PARAMS);
mutable_image->need_redraw = need_redraw;
mutable_image->need_redraw_ctx = need_redraw_ctx;
return RET_OK;
}
ret_t mutable_image_set_create_image(widget_t* widget, mutable_image_create_image_t create_image,
void* create_image_ctx) {
mutable_image_t* mutable_image = MUTABLE_IMAGE(widget);
return_value_if_fail(mutable_image != NULL && create_image != NULL, RET_BAD_PARAMS);
mutable_image->create_image = create_image;
mutable_image->create_image_ctx = create_image_ctx;
return RET_OK;
}
ret_t mutable_image_set_framebuffer(widget_t* widget, uint32_t w, uint32_t h,
bitmap_format_t format, uint8_t* buff) {
mutable_image_t* mutable_image = MUTABLE_IMAGE(widget);
return_value_if_fail(mutable_image != NULL && buff != NULL, RET_BAD_PARAMS);
mutable_image->fb = bitmap_create();
return_value_if_fail(mutable_image->fb != NULL, RET_OOM);
bitmap_init(mutable_image->fb, w, h, format, buff);
mutable_image->fb->should_free_handle = TRUE;
return RET_OK;
}
widget_t* mutable_image_cast(widget_t* widget) {
return_value_if_fail(WIDGET_IS_INSTANCE_OF(widget, mutable_image), NULL);
return widget;
}
|
0 |
repos/awtk/src/ext_widgets
|
repos/awtk/src/ext_widgets/mutable_image/README.md
|
# mutable image
像摄像头和视频的图像是变化的，每一帧都不同，我们把这类图片称为mutable image。
|
0 |
repos/awtk/src/ext_widgets
|
repos/awtk/src/ext_widgets/mutable_image/mutable_image.h
|
/**
* File: mutable_image.h
* Author: AWTK Develop Team
* Brief: mutable_image
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2019-02-28 Li XianJing <[email protected]> created
*
*/
#ifndef TK_MUTABLE_IMAGE_H
#define TK_MUTABLE_IMAGE_H
#include "base/widget.h"
#include "base/image_base.h"
BEGIN_C_DECLS
typedef bool_t (*mutable_image_need_redraw_t)(void* ctx);
typedef ret_t (*mutable_image_prepare_image_t)(void* ctx, bitmap_t* image);
typedef bitmap_t* (*mutable_image_create_image_t)(void* ctx, bitmap_format_t format,
bitmap_t* old_image);
/**
* @class mutable_image_t
* @parent image_base_t
* @annotation ["scriptable","design","widget"]
*
* mutable图片控件。
*
* 像摄像头和视频的图像是变化的，每一帧都不同，我们把这类图片称为mutable image。
*
* 本控件辅助实现摄像头和视频的显示功能。
*
* mutable\_image\_t是[image\_base\_t](image_base_t.md)的子类控件，image\_base\_t的函数均适用于mutable\_image\_t控件。
*
* 在xml中使用"mutable\_image"标签创建mutable图片控件。如：
*
* ```xml
* <mutable_image w="100%" h="100%"/>
* ```
*
* >更多用法请参考：
* [mutable
* image](https://github.com/zlgopen/awtk/blob/master/design/default/ui/mutable_image.xml)
*
* 在c代码中使用函数mutable\_image\_create创建mutable图片控件。如：
*
* ```c
* widget_t* image = mutable_image_create(win, 10, 10, 200, 200);
* mutable_image_set_prepare_image(image, get_camera_image, camera);
* ```
*
* > 创建之后:
* >
* > 需要用mutable\_image\_set\_create\_image设置创建图片的回调函数。
* > 需要用mutable\_image\_set\_prepare\_image设置准备图片的回调函数。
*
* > 完整示例请参考：[mutable image demo](
* https://github.com/zlgopen/awtk-c-demos/blob/master/demos/mutable_image.c)
*
* 一般不需通过style来设置控件的显示风格，如果在特殊情况下需要，可以参考其它控件。
*
*/
typedef struct _mutable_image_t {
image_base_t image_base;
/*private*/
uint32_t timer_id;
void* prepare_image_ctx;
mutable_image_prepare_image_t prepare_image;
void* need_redraw_ctx;
mutable_image_need_redraw_t need_redraw;
void* create_image_ctx;
mutable_image_create_image_t create_image;
bitmap_t* fb;
bitmap_t* image;
bitmap_t* user_image;
canvas_t* canvas;
} mutable_image_t;
/**
* @method mutable_image_create
* 创建mutable_image对象
* @annotation ["constructor", "scriptable"]
* @param {widget_t*} parent 父控件
* @param {xy_t} x x坐标
* @param {xy_t} y y坐标
* @param {wh_t} w 宽度
* @param {wh_t} h 高度
*
* @return {widget_t*} 对象。
*/
widget_t* mutable_image_create(widget_t* parent, xy_t x, xy_t y, wh_t w, wh_t h);
/**
* @method mutable_image_set_need_redraw
* 设置need_redraw回调函数。
*
* 缺省每16ms刷新一次。但有时只是在变化时刷新，所以提供一个回调函数由用户决定是否需要重绘。
*
* @param {widget_t*} widget mutable_image对象。
* @param {mutable_image_need_redraw_t} need_redraw 检查是否需要重绘的回调函数。
* @param {void*} need_redraw_ctx need_redraw回调函数的上下文。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t mutable_image_set_need_redraw(widget_t* widget, mutable_image_need_redraw_t need_redraw,
void* need_redraw_ctx);
/**
* @method mutable_image_set_prepare_image
* 设置prepare_image回调函数。
*
* prepare_image回调函数在每次绘制之前被调用，用于准备下一帧要显示的图片。
* 比如获取摄像头的预览图片，将其设置到image参数中。
*
* 注意：在回调函数中，只能修改图片的内容，不用修改图片的大小和格式，如果不匹配请先转换。
*
* @param {widget_t*} widget mutable_image对象。
* @param {mutable_image_prepare_image_t} prepare_image 准备图片的回调函数。
* @param {void*} prepare_image_ctx prepare_image回调函数的上下文。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t mutable_image_set_prepare_image(widget_t* widget, mutable_image_prepare_image_t prepare_image,
void* prepare_image_ctx);
/**
* @method mutable_image_set_create_image
* 设置create_image回调函数。
*
* @param {widget_t*} widget mutable_image对象。
* @param {mutable_image_create_image_t} create_image 创建图片的回调函数。
* @param {void*} create_image_ctx create_image回调函数的上下文。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t mutable_image_set_create_image(widget_t* widget, mutable_image_create_image_t create_image,
void* create_image_ctx);
/**
* @method mutable_image_set_framebuffer
* 设置framebuffer(当硬件支持多层合成时才用)。
*
* 有的硬件支持多层framebuffer，一层用于视图/摄像头，一层用于GUI，由硬件合成最终图像。
* 此时可以设置用于摄像头的framebuffer，图像直接绘制到该framebuffer上。
*
* @param {widget_t*} widget mutable_image对象。
* @param {uint32_t} w framebuffer宽度。
* @param {uint32_t} h framebuffer高度。
* @param {bitmap_format_t} format framebuffer的格式。
* @param {uint8_t*} buff framebuffer内存。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t mutable_image_set_framebuffer(widget_t* widget, uint32_t w, uint32_t h,
bitmap_format_t format, uint8_t* buff);
/**
* @method mutable_image_cast
* 转换为mutable_image对象(供脚本语言使用)。
*
* @annotation ["cast"]
* @param {widget_t*} widget mutable_image对象。
*
* @return {widget_t*} mutable_image对象。
*/
widget_t* mutable_image_cast(widget_t* widget);
/**
* @method mutable_image_init
* 初始化 mutable_image （提供给继承的子类使用的）
*
* @annotation ["cast"]
* @param {widget_t*} widget mutable_image对象。
*
* @return {widget_t*} mutable_image对象。
*/
widget_t* mutable_image_init(widget_t* widget);
/**
* @method mutable_image_on_destroy
* 释放 mutable_image （提供给继承的子类使用的）
*
* @annotation ["cast"]
* @param {widget_t*} widget mutable_image对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t mutable_image_on_destroy(widget_t* widget);
/**
* @method mutable_image_on_paint_self
* mutable_image 的绘制函数 （提供给继承的子类使用的）
*
* @annotation ["cast"]
* @param {widget_t*} widget mutable_image对象。
* @param {canvas_t*} canvas 画布对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t mutable_image_on_paint_self(widget_t* widget, canvas_t* canvas);
#define WIDGET_TYPE_MUTABLE_IMAGE "mutable_image"
#define MUTABLE_IMAGE(widget) ((mutable_image_t*)(mutable_image_cast(WIDGET(widget))))
/*public for subclass and runtime type check*/
TK_EXTERN_VTABLE(mutable_image);
END_C_DECLS
#endif /*TK_MUTABLE_IMAGE_H*/
|
0 |
repos/awtk/src/ext_widgets
|
repos/awtk/src/ext_widgets/gif_image/gif_image.h
|
/**
* File: gif_image.h
* Author: AWTK Develop Team
* Brief: gif_image
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-11-25 Li XianJing <[email protected]> created
*
*/
#ifndef TK_GIF_IMAGE_H
#define TK_GIF_IMAGE_H
#include "base/widget.h"
#include "base/image_base.h"
BEGIN_C_DECLS
/**
* @class gif_image_t
* @parent image_base_t
* @annotation ["scriptable","design","widget"]
* GIF图片控件。
*
* > 注意：GIF图片的尺寸大于控件大小时会自动缩小图片，但一般的嵌入式系统的硬件加速都不支持图片缩放，
* 所以缩放图片会导致性能明显下降。如果性能不满意时，请确认一下GIF图片的尺寸是否小于控件大小。
*
* gif\_image\_t是[image\_base\_t](image_base_t.md)的子类控件，image\_base\_t的函数均适用于gif\_image\_t控件。
*
* 在xml中使用"gif"标签创建GIF图片控件。如：
*
* ```xml
* <gif image="bee"/>
* ```
*
* >更多用法请参考：
* [gif
* image](https://github.com/zlgopen/awtk/blob/master/design/default/ui/gif_image.xml)
*
* 在c代码中使用函数gif\_image\_create创建GIF图片控件。如：
*
* ```c
* widget_t* image = gif_image_create(win, 10, 10, 200, 200);
* image_set_image(image, "bee");
* ```
*
* > 创建之后:
* >
* > 需要用widget\_set\_image设置图片名称。
*
* > 完整示例请参考：[gif image demo](
* https://github.com/zlgopen/awtk-c-demos/blob/master/demos/gif_image.c)
*
* 可用通过style来设置控件的显示风格，如背景和边框等。如：
*
* ```xml
* <gif>
* <style name="border">
* <normal border_color="#000000" bg_color="#e0e0e0" text_color="black"/>
* </style>
* </gif>
* ```
*
* > 更多用法请参考：[theme default](
* https://github.com/zlgopen/awtk/blob/master/design/default/styles/default.xml)
*
*/
typedef struct _gif_image_t {
image_base_t image_base;
/**
* @property {bool_t} running
* @annotation ["set_prop","get_prop","readable"]
* 是否正在运行。
*
*/
bool_t running;
/**
* @property {uint32_t} loop
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 循环播放的次数。
*
*/
uint32_t loop;
/*private*/
uint32_t index;
uint32_t delay;
uint32_t timer_id;
uint32_t loop_done;
} gif_image_t;
/**
* @method gif_image_create
* 创建gif_image对象
* @annotation ["constructor", "scriptable"]
* @param {widget_t*} parent 父控件
* @param {xy_t} x x坐标
* @param {xy_t} y y坐标
* @param {wh_t} w 宽度
* @param {wh_t} h 高度
*
* @return {widget_t*} 对象。
*/
widget_t* gif_image_create(widget_t* parent, xy_t x, xy_t y, wh_t w, wh_t h);
/**
* @method gif_image_play
* 播放。
* @annotation ["scriptable"]
* @param {widget_t*} widget gif_image对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t gif_image_play(widget_t* widget);
/**
* @method gif_image_stop
* 停止(并重置index为0)。
* @annotation ["scriptable"]
* @param {widget_t*} widget gif_image对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t gif_image_stop(widget_t* widget);
/**
* @method gif_image_pause
* 暂停。
* @annotation ["scriptable"]
* @param {widget_t*} widget gif_image对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t gif_image_pause(widget_t* widget);
/**
* @method gif_image_set_loop
* 设置循环播放次数。
* @annotation ["scriptable"]
* @param {widget_t*} widget 控件对象。
* @param {uint32_t} loop 循环播放次数。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t gif_image_set_loop(widget_t* widget, uint32_t loop);
/**
* @method gif_image_cast
* 转换为gif_image对象(供脚本语言使用)。
* @annotation ["cast", "scriptable"]
* @param {widget_t*} widget gif_image对象。
*
* @return {widget_t*} gif_image对象。
*/
widget_t* gif_image_cast(widget_t* widget);
#define WIDGET_TYPE_GIF_IMAGE "gif"
#define GIF_IMAGE(widget) ((gif_image_t*)(gif_image_cast(WIDGET(widget))))
/*public for subclass and runtime type check*/
TK_EXTERN_VTABLE(gif_image);
END_C_DECLS
#endif /*TK_GIF_IMAGE_H*/
|
0 |
repos/awtk/src/ext_widgets
|
repos/awtk/src/ext_widgets/gif_image/gif_image.c
|
/**
* File: gif_image.h
* Author: AWTK Develop Team
* Brief: gif_image
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-11-25 Li XianJing <[email protected]> created
*
*/
#include "tkc/mem.h"
#include "tkc/utils.h"
#include "base/timer.h"
#include "base/widget_vtable.h"
#include "gif_image/gif_image.h"
#ifdef AWTK_WEB
static ret_t gif_image_on_timer(const timer_info_t* info) {
gif_image_t* image = GIF_IMAGE(info->ctx);
return_value_if_fail(image != NULL, RET_BAD_PARAMS);
image->index = 0;
if (WIDGET(image)->visible) {
widget_invalidate_force(WIDGET(image), NULL);
}
return RET_REPEAT;
}
#else
static ret_t gif_image_on_timer(const timer_info_t* info) {
gif_image_t* image = GIF_IMAGE(info->ctx);
return_value_if_fail(image != NULL, RET_BAD_PARAMS);
if (image->running) {
image->index++;
}
if (WIDGET(image)->visible) {
widget_invalidate_force(WIDGET(image), NULL);
}
return RET_REPEAT;
}
#endif /*AWTK_WEB*/
static ret_t gif_image_on_paint_self(widget_t* widget, canvas_t* c) {
wh_t y = 0;
wh_t h = 0;
rect_t src;
rect_t dst;
uint32_t frames_nr;
bitmap_t bitmap;
vgcanvas_t* vg = NULL;
gif_image_t* image = GIF_IMAGE(widget);
image_base_t* image_base = IMAGE_BASE(widget);
return_value_if_fail(image_base != NULL && image != NULL && widget != NULL && c != NULL,
RET_BAD_PARAMS);
if (image_base->image == NULL || image_base->image[0] == '\0') {
widget_paint_helper(widget, c, NULL, NULL);
return RET_OK;
}
vg = canvas_get_vgcanvas(c);
return_value_if_fail(widget_load_image(widget, image_base->image, &bitmap) == RET_OK,
RET_BAD_PARAMS);
#ifdef AWTK_WEB
bitmap.gif_frame_h = bitmap.h;
frames_nr = 1;
#else
if (!bitmap.is_gif) {
if (image->timer_id != TK_INVALID_ID) {
image->index = 0;
timer_remove(image->timer_id);
image->timer_id = TK_INVALID_ID;
}
return RET_OK;
}
frames_nr = bitmap.gif_frames_nr;
#endif /*AWTK_WEB*/
if (frames_nr > 0) {
image->index %= frames_nr;
if (image->loop > 0 && image->index == frames_nr - 1 && !image->loop_done) {
image->loop--;
}
} else {
image->index = 0;
}
if (image->loop == 0) {
if (frames_nr > 0) {
image->index = frames_nr - 1;
} else {
image->index = 0;
}
image->loop_done = TRUE;
}
#ifdef AWTK_WEB
if (image->timer_id == TK_INVALID_ID) {
image->timer_id = timer_add(gif_image_on_timer, image, 16);
}
#else
if (image->loop > 0 && frames_nr > 1) {
uint32_t delay = bitmap.gif_delays[image->index];
if (image->timer_id == TK_INVALID_ID) {
image->index = 0;
image->delay = delay;
image->timer_id = timer_add(gif_image_on_timer, image, image->delay);
} else if (image->delay != delay) {
image->delay = delay;
timer_info_t* timer = (timer_info_t*)timer_find(image->timer_id);
if (timer) timer->duration = image->delay;
}
} else if (image->timer_id != TK_INVALID_ID) {
timer_remove(image->timer_id);
image->timer_id = TK_INVALID_ID;
}
#endif /*AWTK_WEB*/
h = bitmap.gif_frame_h;
y = bitmap.gif_frame_h * image->index;
if (vg != NULL) {
if (image_need_transform(widget)) {
vgcanvas_save(vg);
image_transform(widget, c);
vgcanvas_draw_icon(vg, &bitmap, 0, y, bitmap.w, h, 0, 0, widget->w, widget->h);
vgcanvas_restore(vg);
return RET_OK;
}
}
src = rect_init(0, y, bitmap.w, h);
dst = rect_init(0, 0, widget->w, widget->h);
canvas_draw_image_scale_down(c, &bitmap, &src, &dst);
widget_paint_helper(widget, c, NULL, NULL);
return RET_OK;
}
static const char* s_gif_image_properties[] = {WIDGET_PROP_IMAGE, WIDGET_PROP_SCALE_X,
WIDGET_PROP_SCALE_Y, WIDGET_PROP_ANCHOR_X,
WIDGET_PROP_ANCHOR_Y, WIDGET_PROP_ROTATION,
WIDGET_PROP_CLICKABLE, WIDGET_PROP_SELECTABLE,
WIDGET_PROP_LOOP, NULL};
static ret_t gif_image_on_destroy(widget_t* widget) {
gif_image_t* image = GIF_IMAGE(widget);
return_value_if_fail(image != NULL, RET_BAD_PARAMS);
if (image->timer_id != TK_INVALID_ID) {
timer_remove(image->timer_id);
image->timer_id = TK_INVALID_ID;
}
return image_base_on_destroy(widget);
}
ret_t gif_image_play(widget_t* widget) {
gif_image_t* gif_image = GIF_IMAGE(widget);
return_value_if_fail(gif_image != NULL, RET_BAD_PARAMS);
gif_image->running = TRUE;
return RET_OK;
}
ret_t gif_image_pause(widget_t* widget) {
gif_image_t* gif_image = GIF_IMAGE(widget);
return_value_if_fail(gif_image != NULL, RET_BAD_PARAMS);
gif_image->running = FALSE;
return RET_OK;
}
ret_t gif_image_stop(widget_t* widget) {
gif_image_t* gif_image = GIF_IMAGE(widget);
return_value_if_fail(gif_image != NULL, RET_BAD_PARAMS);
gif_image->index = 0;
gif_image->running = FALSE;
return RET_OK;
}
ret_t gif_image_set_loop(widget_t* widget, uint32_t loop) {
gif_image_t* gif_image = GIF_IMAGE(widget);
return_value_if_fail(gif_image != NULL, RET_BAD_PARAMS);
if (gif_image->loop_done) {
gif_image->index = 0;
gif_image->loop_done = FALSE;
}
gif_image->loop = loop;
return RET_OK;
}
static ret_t gif_image_get_prop(widget_t* widget, const char* name, value_t* v) {
gif_image_t* image = GIF_IMAGE(widget);
return_value_if_fail(image != NULL && name != NULL && v != NULL, RET_BAD_PARAMS);
if (tk_str_eq(name, WIDGET_PROP_RUNNING)) {
value_set_bool(v, image->running);
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_LOOP)) {
value_set_uint32(v, image->loop);
return RET_OK;
} else {
return image_base_get_prop(widget, name, v);
}
}
static ret_t gif_image_set_prop(widget_t* widget, const char* name, const value_t* v) {
gif_image_t* gif_image = GIF_IMAGE(widget);
return_value_if_fail(widget != NULL && name != NULL && v != NULL, RET_BAD_PARAMS);
if (tk_str_eq(name, WIDGET_PROP_RUNNING)) {
gif_image->running = value_bool(v);
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_LOOP)) {
return gif_image_set_loop(widget, value_uint32(v));
} else {
return image_base_set_prop(widget, name, v);
}
}
static ret_t gif_image_init(widget_t* widget) {
gif_image_t* gif_image = GIF_IMAGE(widget);
return_value_if_fail(gif_image != NULL, RET_BAD_PARAMS);
image_base_init(widget);
gif_image_play(widget);
gif_image->loop = 0xffffffff;
gif_image->loop_done = FALSE;
return RET_OK;
}
TK_DECL_VTABLE(gif_image) = {.size = sizeof(gif_image_t),
.type = WIDGET_TYPE_GIF_IMAGE,
.space_key_to_activate = TRUE,
.return_key_to_activate = TRUE,
.clone_properties = s_gif_image_properties,
.persistent_properties = s_gif_image_properties,
.get_parent_vt = TK_GET_PARENT_VTABLE(image_base),
.create = gif_image_create,
.init = gif_image_init,
.on_destroy = gif_image_on_destroy,
.on_event = image_base_on_event,
.on_paint_self = gif_image_on_paint_self,
.on_copy = image_base_on_copy,
.set_prop = gif_image_set_prop,
.get_prop = gif_image_get_prop};
widget_t* gif_image_create(widget_t* parent, xy_t x, xy_t y, wh_t w, wh_t h) {
widget_t* widget = widget_create(parent, TK_REF_VTABLE(gif_image), x, y, w, h);
return_value_if_fail(gif_image_init(widget) == RET_OK, NULL);
return widget;
}
widget_t* gif_image_cast(widget_t* widget) {
return_value_if_fail(WIDGET_IS_INSTANCE_OF(widget, gif_image), NULL);
return widget;
}
|
0 |
repos/awtk/src/ext_widgets
|
repos/awtk/src/ext_widgets/gif_image/README.md
|
# GIF
用于显示GIF动态图片。
|
0 |
repos/awtk/src/ext_widgets
|
repos/awtk/src/ext_widgets/color_picker/color_picker_const.h
|
/**
* File: color_picker_const.h
* Author: AWTK Develop Team
* Brief: color_picker consts
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-08-21 Li XianJing <[email protected]> created
*
*/
#ifndef TK_COLOR_PICKER_CONST_H
#define TK_COLOR_PICKER_CONST_H
BEGIN_C_DECLS
#define COLOR_PICKER_CHILD_R "r"
#define COLOR_PICKER_CHILD_G "g"
#define COLOR_PICKER_CHILD_B "b"
#define COLOR_PICKER_CHILD_H "h"
#define COLOR_PICKER_CHILD_S "s"
#define COLOR_PICKER_CHILD_V "v"
#define COLOR_PICKER_CHILD_SV "sv"
#define COLOR_PICKER_CHILD_OLD "old"
#define COLOR_PICKER_CHILD_NEW "new"
END_C_DECLS
#endif /*TK_COLOR_PICKER_CONST_H*/
|
0 |
repos/awtk/src/ext_widgets
|
repos/awtk/src/ext_widgets/color_picker/rgb_and_hsv.h
|
/*
* Simple-color-conversions
*
* Copyright 2016 Jake Besworth
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
/*
* color.h
*
* Portable, simple, compact, color conversion library between color spaces, most notibly RGB ->
* CYM(K) and HSV Formulas derived from "Color Space Conversions" by Adrian Ford and Alan Roberts.
*
* Note: RGB values are 0-255 (unsigned char)
* CMY(K) values are 0.00-1.00 (0 to 100%) (float)
* HSV values are Hue: 0-360 (0 to 360 degrees) (float), Saturation: 0.00-1.00 (0 to 100%)
* (float), and Value: 0.00-1.00 (0 to 100%) (float)
*
*/
#ifndef COLOR_
#define COLOR_
#ifdef __cplusplus
extern "C" {
#endif
/*
* Converts RGB values to CMY storing in given addresses
*
* @param r Value of Red 0-255
* @param g Value of Green 0-255
* @param b Value of Blue 0-255
* @param c Address of Cyan
* @param m Address of Magenta
* @param y Address of Yellow
*
* @return void
*/
void convertRGBtoCMY(const unsigned char r, const unsigned char g, const unsigned char b, float* c,
float* m, float* y);
/*
* Converts CMY values to RGB storing in given addresses
*
* @param c Value of Cyan 0.00-1.00
* @param m Value of Magenta 0.00-1.00
* @param y Value of Yellow 0.00-1.00
* @param r Address of Red
* @param g Address of Green
* @param b Address of Blue
*
* @return void
*/
void convertCMYtoRGB(const float c, const float m, const float y, unsigned char* r,
unsigned char* g, unsigned char* b);
/*
* Converts CMY values to CMYK storing in given addresses
* Note: function overwrites input parameters, maybe can be changed later to accept some consts
* first
*
* @param c Address of Cyan value 0.00-1.00
* @param m Address of Magenta Value 0.00-1.00
* @param y Address of Yellow Value 0.00-1.00
* @param k Address of Black Value 0.00-1.00
*
* @return void
*/
void convertCMYtoCMYK(float* c, float* m, float* y, float* k);
/*
* Converts CMYK values to CMY storing in given addresses
* Note: function overwrites input parameters, maybe can be changed later to accept some consts
* first
*
* @param c Address of Cyan value 0.00-1.00
* @param m Address of Magenta Value 0.00-1.00
* @param y Address of Yellow Value 0.00-1.00
* @param k Value of Black Value 0.00-1.00
*
* @return void
*/
void convertCMYKtoCMY(float* c, float* m, float* y, const float k);
/*
* Converts RGB values to CMYK storing in given addresses
*
* @param r Value of Red 0-255
* @param g Value of Green 0-255
* @param b Value of Blue 0-255
* @param c Address of Cyan value 0.00-1.00
* @param m Address of Magenta Value 0.00-1.00
* @param y Address of Yellow Value 0.00-1.00
* @param k Address of Black Value 0.00-1.00
*
* @return void
*/
void convertRGBtoCMYK(const unsigned char r, const unsigned char g, const unsigned char b, float* c,
float* m, float* y, float* k);
/*
* Converts CMYK values to RGB storing in given addresses
*
* @param c Value of Cyan 0.00-1.00
* @param m Value of Magenta Value 0.00-1.00
* @param y Value of Yellow Value 0.00-1.00
* @param k Value of Black Value 0.00-1.00
* @param r Address of Red
* @param g Address of Green
* @param b Address of Blue
*
* @return void
*/
void convertCMYKtoRGB(const float c, const float m, const float y, const float k, unsigned char* r,
unsigned char* g, unsigned char* b);
/*
* Converts RGB values to HSV storing in given addresses
*
* @param r Value of Red 0-255
* @param g Value of Green 0-255
* @param b Value of Blue 0-255
* @param h Address of Hue
* @param s Address of Saturation
* @param v Address of Value
*
* @return void
*/
void convertRGBtoHSV(const unsigned char r, const unsigned char g, const unsigned char b, float* h,
float* s, float* v);
/*
* Converts HSV values to RGB storing in given addresses
*
* @param h Value of Hue 0-360
* @param s Value of Saturation 0.00-1.00
* @param v Value of Value 0.00-1.00
* @param r Address of Red
* @param g Adderss of Green
* @param b Address of Blue
*
* @return void
*/
void convertHSVtoRGB(const float h, const float s, const float v, unsigned char* r,
unsigned char* g, unsigned char* b);
#ifdef __cplusplus
}
#endif
#endif
|
0 |
repos/awtk/src/ext_widgets
|
repos/awtk/src/ext_widgets/color_picker/rgb_and_hsv.c
|
/*
* Simple-color-conversions
*
* Copyright 2016 Jake Besworth
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
#ifndef MIN
#define MIN(a, b) (((a) < (b)) ? (a) : (b))
#endif
#ifndef MAX
#define MAX(a, b) (((a) > (b)) ? (a) : (b))
#endif
#ifndef MAX3
#define MAX3(a, b, c) MAX(MAX(a, b), c)
#endif
#ifndef MIN3
#define MIN3(a, b, c) MIN(MIN(a, b), c)
#endif
void convertCMYtoRGB(const float c, const float m, const float y, unsigned char* r,
unsigned char* g, unsigned char* b) {
/* Perform a cheap ceiling because e.g. it returns 9.99~ which truncates to 9 */
*r = ((1.0f - c) * 255.0f) + 0.5f;
*g = ((1.0f - m) * 255.0f) + 0.5f;
*b = ((1.0f - y) * 255.0f) + 0.5f;
}
void convertRGBtoCMY(const unsigned char r, const unsigned char g, const unsigned char b, float* c,
float* m, float* y) {
*c = 1.0f - (r / 255.0f);
*m = 1.0f - (g / 255.0f);
*y = 1.0f - (b / 255.0f);
}
void convertCMYtoCMYK(float* c, float* m, float* y, float* k) {
*k = MIN3(*c, *m, *y);
*c = ((int)*k == 1) ? 1 : (*c - *k) / (1.0f - *k);
*m = ((int)*k == 1) ? 1 : (*m - *k) / (1.0f - *k);
*y = ((int)*k == 1) ? 1 : (*y - *k) / (1.0f - *k);
}
void convertCMYKtoCMY(float* c, float* m, float* y, const float k) {
*c = MIN(1.0f, (*c * (1.0f - k)) + k);
*m = MIN(1.0f, (*m * (1.0f - k)) + k);
*y = MIN(1.0f, (*y * (1.0f - k)) + k);
}
void convertCMYKtoRGB(const float c, const float m, const float y, const float k, unsigned char* r,
unsigned char* g, unsigned char* b) {
float c2 = c;
float m2 = m;
float y2 = y;
float k2 = k;
convertCMYKtoCMY(&c2, &m2, &y2, k2);
convertCMYtoRGB(c2, m2, y2, r, g, b);
}
void convertRGBtoCMYK(const unsigned char r, const unsigned char g, const unsigned char b, float* c,
float* m, float* y, float* k) {
convertRGBtoCMY(r, g, b, c, m, y);
convertCMYtoCMYK(c, m, y, k);
}
void convertHSVtoRGB_(const float h, const float s, const float v, unsigned char* r,
unsigned char* g, unsigned char* b) {
/* Convert hue back to 0-6 space, floor */
const float hex = h / 60.0f;
const unsigned char primary = (int)hex;
const float secondary = hex - primary;
/* a, b, c */
const float x = (1.0f - s) * v;
const float y = (1.0f - (s * secondary)) * v;
const float z = (1.0f - (s * (1.0f - secondary))) * v;
if (primary == 0) {
/* 0: R = v, G = c, B = a */
*r = (v * 255.0f) + 0.5f;
*g = (z * 255.0f) + 0.5f;
*b = (x * 255.0f) + 0.5f;
} else if (primary == 1) {
/* 1: R = b, G = v, B = a */
*r = (y * 255.0f) + 0.5f;
*g = (v * 255.0f) + 0.5f;
*b = (x * 255.0f) + 0.5f;
} else if (primary == 2) {
/* 2: R = a, G = v, B = c */
*r = (x * 255.0f) + 0.5f;
*g = (v * 255.0f) + 0.5f;
*b = (z * 255.0f) + 0.5f;
} else if (primary == 3) {
/* 3: R = a, G = b, B = v */
*r = (x * 255.0f) + 0.5f;
*g = (y * 255.0f) + 0.5f;
*b = (v * 255.0f) + 0.5f;
} else if (primary == 4) {
/* 4: R = c, G = a, B = v */
*r = (z * 255.0f) + 0.5f;
*g = (x * 255.0f) + 0.5f;
*b = (v * 255.0f) + 0.5f;
} else if (primary == 5) {
/* 5: R = v, G = a, B = b */
*r = (v * 255.0f) + 0.5f;
*g = (x * 255.0f) + 0.5f;
*b = (y * 255.0f) + 0.5f;
}
}
void convertHSVtoRGB(const float h, const float s, const float v, unsigned char* r,
unsigned char* g, unsigned char* b) {
float hh = h;
if (hh == 0) {
hh = 0.01f;
} else if (hh >= 360) {
hh = 359.99f;
}
convertHSVtoRGB_(hh, s, v, r, g, b);
}
void convertRGBtoHSV(const unsigned char r, const unsigned char g, const unsigned char b, float* h,
float* s, float* v) {
const unsigned char max = MAX3(r, g, b);
const float max2 = max / 255.0f;
const unsigned char min = MIN3(r, g, b);
const float min2 = min / 255.0f;
*s = (max2 < 0.0001f) ? 0 : (max2 - min2) / max2;
*v = max2;
/* Saturation is 0 */
if ((*s * 100.0f) < 0.1f) {
/* Hue is undefined, monochrome */
*h = 0;
return;
} else if (r == max) {
if (g == min) {
/* H = 5 + B' */
*h = 5 + ((max2 - (b / 255.0f)) / (max2 - min2));
} else {
/* H = 1 - G' */
*h = 1 - ((max2 - (g / 255.0f)) / (max2 - min2));
}
} else if (g == max) {
if (b == min) {
/* H = R' + 1 */
*h = ((max2 - (r / 255.0f)) / (max2 - min2)) + 1;
} else {
/* H = 3 - B' */
*h = 3 - ((max2 - (b / 255.0f)) / (max2 - min2));
}
}
/* This is actually a problem with the original paper, I've fixed it here, should email them... */
else if (b == max && r == min) {
/* H = 3 + G' */
*h = 3 + ((max2 - (g / 255.0f)) / (max2 - min2));
} else {
/* H = 5 - R' */
*h = 5 - ((max2 - (r / 255.0f)) / (max2 - min2));
}
/* Hue is then converted to degrees by multiplying by 60 */
*h = MIN(*h * 60, 360);
}
|
0 |
repos/awtk/src/ext_widgets
|
repos/awtk/src/ext_widgets/color_picker/color_component.h
|
/**
* File: color_component.h
* Author: AWTK Develop Team
* Brief: color_component
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-08-21 Li XianJing <[email protected]> created
*
*/
#ifndef TK_COLOR_COMPONENT_H
#define TK_COLOR_COMPONENT_H
#include "base/widget.h"
#include "base/bitmap.h"
#include "color_picker/color_picker_const.h"
BEGIN_C_DECLS
typedef ret_t (*color_component_update_t)(widget_t* widget);
/**
* @class color_component_t
* @parent widget_t
* @annotation ["scriptable","design","widget"]
* 颜色选择器的颜色分量。
* 控件的名称有严格规定：
* COLOR_PICKER_CHILD_SV: 水平为Value/Brightness(递增)，垂直为Saturation(递减)。
* COLOR_PICKER_CHILD_H: 水平为同色，垂直为Hue(递减)。
*/
typedef struct _color_component_t {
widget_t widget;
xy_t color_x;
xy_t color_y;
color_t c;
bitmap_t* image;
int32_t last_hue;
bool_t need_update;
color_component_update_t update;
bool_t pressed;
} color_component_t;
/**
* @event {value_change_event_t} EVT_VALUE_CHANGING
* 颜色正在改变事件。
*/
/**
* @method color_component_create
* 创建color_component对象
* @annotation ["constructor", "scriptable"]
* @param {widget_t*} parent 父控件
* @param {xy_t} x x坐标
* @param {xy_t} y y坐标
* @param {wh_t} w 宽度
* @param {wh_t} h 高度
*
* @return {widget_t*} 对象。
*/
widget_t* color_component_create(widget_t* parent, xy_t x, xy_t y, wh_t w, wh_t h);
/**
* @method color_component_set_color
* 设置颜色。
* @param {widget_t*} widget 控件对象。
* @param {color_t} c 颜色。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t color_component_set_color(widget_t* widget, color_t c);
/**
* @method color_component_set_hsv
* 设置颜色。
* @param {widget_t*} widget 控件对象。
* @param {float} h 色调。
* @param {float} s 饱和度。
* @param {float} v 明度。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t color_component_set_hsv(widget_t* widget, float h, float s, float v);
/**
* @method color_component_get_h
* 获取h分量。
* @param {widget_t*} widget color_component对象。
*
* @return {float} 返回h分量。
*/
float color_component_get_h(widget_t* widget);
/**
* @method color_component_get_s
* 获取s分量。
* @param {widget_t*} widget color_component对象。
*
* @return {float} 返回s分量。
*/
float color_component_get_s(widget_t* widget);
/**
* @method color_component_get_v
* 获取v分量。
* @param {widget_t*} widget color_component对象。
*
* @return {float} 返回v分量。
*/
float color_component_get_v(widget_t* widget);
/**
* @method color_component_cast
* 转换为color_component对象(供脚本语言使用)。
*
* @annotation ["cast", "scriptable"]
* @param {widget_t*} widget color_component对象。
*
* @return {widget_t*} color_component对象。
*/
widget_t* color_component_cast(widget_t* widget);
#define COLOR_COMPONENT(widget) ((color_component_t*)(color_component_cast(WIDGET(widget))))
/*public for subclass and runtime type check*/
TK_EXTERN_VTABLE(color_component);
END_C_DECLS
#endif /*TK_COLOR_COMPONENT_H*/
|
0 |
repos/awtk/src/ext_widgets
|
repos/awtk/src/ext_widgets/color_picker/color_picker.h
|
/**
* File: color_picker.h
* Author: AWTK Develop Team
* Brief: color_picker
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-08-21 Li XianJing <[email protected]> created
*
*/
#ifndef TK_COLOR_PICKER_H
#define TK_COLOR_PICKER_H
#include "base/widget.h"
#include "color_picker/color_picker_const.h"
BEGIN_C_DECLS
/**
* @class color_picker_t
* @parent widget_t
* @annotation ["scriptable","design","widget"]
* 颜色选择器。
*
* color\_picker\_t是[widget\_t](widget_t.md)的子类控件，widget\_t的函数均适用于color\_picker\_t控件。
*
* 在xml中使用"color\_picker"标签创建颜色选择器控件。如：
*
* ```xml
* <color_picker x="0" y="0" w="100%" h="100%" value="orange">
* <color_component x="0" y="0" w="200" h="200" name="sv"/>
* <color_component x="210" y="0" w="20" h="200" name="h"/>
* <color_tile x="0" y="210" w="50%" h="20" name="new" bg_color="green"/>
* <color_tile x="right" y="210" w="50%" h="20" name="old" bg_color="blue"/>
* </color_picker>
* ```
*
* > 更多用法请参考：
* [color\_picker](https://github.com/zlgopen/awtk/blob/master/design/default/ui/color_picker.xml)
*
* 其中的子控件必须按下列规则命名：
*
* * r 红色分量。可以是spin_box、edit和slider。
* * g 绿色分量。可以是spin_box、edit和slider。
* * b 蓝色分量。可以是spin_box、edit和slider。
* * h Hue分量。可以是spin_box、edit、slider和color_component。
* * s Saturation分量。可以是spin_box、edit和slider。
* * v Value/Brightness分量。可以是spin_box、edit和slider。
* * sv Saturation和Value/Brightness分量。可以是color_component。
* * old 旧的值。可以是spin_box、edit和color_tile。
* * new 新的值。可以是spin_box、edit和color_tile。
*
*/
typedef struct _color_picker_t {
widget_t widget;
/**
* @property {char*} value
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 颜色。
*/
char value[TK_COLOR_HEX_LEN + 1];
/*private*/
color_t c;
float_t c_r_value;
float_t c_g_value;
float_t c_b_value;
bool_t inited;
color_t init_c;
int32_t last_hue;
widget_t* trigger_child;
} color_picker_t;
/**
* @event {value_change_event_t} EVT_VALUE_WILL_CHANGE
* 值(颜色)即将改变事件。
*/
/**
* @event {value_change_event_t} EVT_VALUE_CHANGED
* 值(颜色)改变事件。
*/
/**
* @method color_picker_create
* 创建color_picker对象
* @annotation ["constructor", "scriptable"]
* @param {widget_t*} parent 父控件
* @param {xy_t} x x坐标
* @param {xy_t} y y坐标
* @param {wh_t} w 宽度
* @param {wh_t} h 高度
*
* @return {widget_t*} 对象。
*/
widget_t* color_picker_create(widget_t* parent, xy_t x, xy_t y, wh_t w, wh_t h);
/**
* @method color_picker_set_color
* 设置颜色。
*
* @annotation ["scriptable"]
* @param {widget_t*} widget 控件对象。
* @param {const char*} color 颜色。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t color_picker_set_color(widget_t* widget, const char* color);
/**
* @method color_picker_cast
* 转换为color_picker对象(供脚本语言使用)。
*
* @annotation ["cast", "scriptable"]
* @param {widget_t*} widget color_picker对象。
*
* @return {widget_t*} color_picker对象。
*/
widget_t* color_picker_cast(widget_t* widget);
#define COLOR_PICKER(widget) ((color_picker_t*)(color_picker_cast(WIDGET(widget))))
/*public for subclass and runtime type check*/
TK_EXTERN_VTABLE(color_picker);
END_C_DECLS
#endif /*TK_COLOR_PICKER_H*/
|
0 |
repos/awtk/src/ext_widgets
|
repos/awtk/src/ext_widgets/color_picker/color_component.c
|
/**
* File: color_component.
* Author: AWTK Develop Team
* Brief: color_component
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-08-21 Li XianJing <[email protected]> created
*
*/
#include "tkc/mem.h"
#include "base/image_manager.h"
#include "base/pixel_pack_unpack.h"
#include "color_picker/rgb_and_hsv.h"
#include "color_picker/color_component.h"
static ret_t color_component_init(widget_t* widget);
static ret_t color_component_update_h(widget_t* widget);
static ret_t color_component_update_sv(widget_t* widget);
static ret_t color_component_ensure_image(widget_t* widget);
static ret_t color_component_set_type(widget_t* widget, const char* type);
static ret_t color_component_dispatch_change_event(widget_t* widget, uint32_t etype) {
uint32_t value = 0;
value_change_event_t evt;
value_change_event_init(&evt, etype, widget);
color_component_t* color_component = COLOR_COMPONENT(widget);
return_value_if_fail(color_component != NULL, RET_BAD_PARAMS);
value = (color_component->color_x & 0xffff) << 16;
value |= color_component->color_y;
value_set_uint32(&(evt.old_value), value);
value_set_uint32(&(evt.new_value), value);
widget_dispatch(widget, (event_t*)&evt);
widget_invalidate_force(widget, NULL);
return RET_OK;
}
static ret_t color_component_update_pressed(widget_t* widget, pointer_event_t* e) {
point_t p = {e->x, e->y};
color_component_t* color_component = COLOR_COMPONENT(widget);
return_value_if_fail(color_component != NULL, RET_BAD_PARAMS);
widget_to_local(widget, &p);
color_component->color_x = tk_clampi(p.x, 0, widget->w);
color_component->color_y = tk_clampi(p.y, 0, widget->h);
color_component_dispatch_change_event(widget, EVT_VALUE_CHANGING);
return RET_OK;
}
static ret_t color_component_on_event(widget_t* widget, event_t* e) {
uint16_t type = e->type;
color_component_t* component = COLOR_COMPONENT(widget);
return_value_if_fail(component != NULL, RET_BAD_PARAMS);
switch (type) {
case EVT_POINTER_DOWN: {
pointer_event_t* evt = (pointer_event_t*)e;
color_component_update_pressed(widget, evt);
widget_grab(widget->parent, widget);
component->pressed = TRUE;
} break;
case EVT_POINTER_MOVE: {
pointer_event_t* evt = (pointer_event_t*)e;
if (component->pressed) {
color_component_update_pressed(widget, evt);
return RET_STOP;
}
break;
}
case EVT_POINTER_UP: {
widget_ungrab(widget->parent, widget);
if (component->pressed) {
color_component_dispatch_change_event(widget, EVT_VALUE_CHANGING);
component->pressed = FALSE;
}
break;
}
default:
break;
}
return RET_OK;
}
static ret_t color_component_on_paint_self(widget_t* widget, canvas_t* c) {
rect_t src;
rect_t dst;
wh_t w = widget->w;
wh_t h = widget->h;
bitmap_t* image = NULL;
color_component_t* color_component = COLOR_COMPONENT(widget);
return_value_if_fail(color_component != NULL, RET_BAD_PARAMS);
xy_t x = tk_max(0, tk_min(color_component->color_x, (w - 1)));
xy_t y = tk_max(0, tk_min(color_component->color_y, (h - 1)));
dst = rect_init(0, 0, w, h);
if (color_component_ensure_image(widget) == RET_OK) {
image = (color_component->image);
src = rect_init(0, 0, image->w, image->h);
canvas_draw_image(c, image, &src, &dst);
}
if (color_component->update == color_component_update_sv) {
canvas_set_stroke_color(c, color_init(0, 0, 0, 0xff));
canvas_draw_hline(c, 0, y, w);
canvas_set_stroke_color(c, color_init(0xd0, 0xd0, 0xd0, 0xff));
if (y > 0) {
canvas_draw_hline(c, 0, y - 1, w);
}
if ((y + 1) < h) {
canvas_draw_hline(c, 0, y + 1, w);
}
canvas_set_stroke_color(c, color_init(0, 0, 0, 0xff));
canvas_draw_vline(c, x, 0, h);
canvas_set_stroke_color(c, color_init(0xd0, 0xd0, 0xd0, 0xff));
if (x > 0) {
canvas_draw_vline(c, x - 1, 0, h);
}
if ((x + 1) < w) {
canvas_draw_vline(c, x + 1, 0, h);
}
} else {
canvas_set_stroke_color(c, color_init(0, 0, 0, 0xff));
canvas_draw_hline(c, 0, y, w);
}
return RET_OK;
}
static ret_t color_component_on_destroy(widget_t* widget) {
color_component_t* color_component = COLOR_COMPONENT(widget);
return_value_if_fail(color_component != NULL, RET_BAD_PARAMS);
if (color_component->image != NULL) {
bitmap_destroy((color_component->image));
}
return RET_OK;
}
TK_DECL_VTABLE(color_component) = {.size = sizeof(color_component_t),
.inputable = TRUE,
.type = WIDGET_TYPE_COLOR_COMPONENT,
.get_parent_vt = TK_GET_PARENT_VTABLE(widget),
.create = color_component_create,
.init = color_component_init,
.on_destroy = color_component_on_destroy,
.on_event = color_component_on_event,
.on_paint_self = color_component_on_paint_self};
static bitmap_t* color_component_create_image(int32_t w, int32_t h) {
#ifdef WITH_BITMAP_BGRA
bitmap_format_t format = BITMAP_FMT_BGRA8888;
#else
bitmap_format_t format = BITMAP_FMT_RGBA8888;
#endif /*WITH_BITMAP_BGRA*/
return bitmap_create_ex(w, h, 0, format);
}
static ret_t color_component_ensure_image(widget_t* widget) {
color_component_t* color_component = COLOR_COMPONENT(widget);
return_value_if_fail(color_component != NULL, RET_BAD_PARAMS);
if (widget->w < 1 || widget->h < 1) {
return RET_FAIL;
}
if (color_component->image != NULL) {
if (color_component->image->w != widget->w || color_component->image->h != widget->h) {
bitmap_destroy(color_component->image);
color_component->image = NULL;
}
}
if (color_component->image == NULL) {
color_component->need_update = TRUE;
color_component->image = color_component_create_image(widget->w, widget->h);
}
return_value_if_fail(color_component->image != NULL, RET_FAIL);
if (color_component->update == NULL) {
color_component_set_type(widget, widget->name);
}
if (color_component->need_update && color_component->update != NULL) {
bitmap_t* image = color_component->image;
color_component->update(widget);
image->flags |= BITMAP_FLAG_CHANGED;
color_component->need_update = FALSE;
}
return RET_OK;
}
static ret_t color_component_update_sv(widget_t* widget) {
rgba_t rgba;
float H = 0;
float S = 0;
float V = 0;
uint8_t r = 0;
uint8_t g = 0;
uint8_t b = 0;
int32_t x = 0;
int32_t y = 0;
int32_t w = 0;
int32_t h = 0;
uint32_t* dst = NULL;
bitmap_t* image = NULL;
uint8_t* image_data = NULL;
color_component_t* color_component = COLOR_COMPONENT(widget);
return_value_if_fail(widget != NULL && color_component != NULL, RET_BAD_PARAMS);
rgba = color_component->c.rgba;
image = color_component->image;
w = image->w;
h = image->h;
image_data = bitmap_lock_buffer_for_write(image);
dst = (uint32_t*)(image_data);
if (color_component->last_hue != -1) {
H = color_component->last_hue;
} else {
convertRGBtoHSV(rgba.r, rgba.g, rgba.b, &H, &S, &V);
color_component->last_hue = H;
}
for (y = 0; y < h; y++) {
dst = (uint32_t*)(image_data + y * image->line_length);
for (x = 0; x < w; x++) {
V = (float)x / (float)w;
S = 1 - (float)y / (float)h;
convertHSVtoRGB(H, S, V, &r, &g, &b);
*dst++ = rgb_to_image8888(r, g, b);
}
}
bitmap_unlock_buffer(image);
return RET_OK;
}
static ret_t color_component_update_h(widget_t* widget) {
float H = 0;
float S = 1;
float V = 1;
uint8_t r = 0;
uint8_t g = 0;
uint8_t b = 0;
int32_t x = 0;
int32_t y = 0;
uint32_t v = 0;
int32_t w = 0;
int32_t h = 0;
uint32_t* dst = NULL;
bitmap_t* image = NULL;
uint8_t* image_data = NULL;
color_component_t* color_component = COLOR_COMPONENT(widget);
return_value_if_fail(widget != NULL && color_component != NULL, RET_BAD_PARAMS);
image = color_component->image;
w = image->w;
h = image->h;
image_data = bitmap_lock_buffer_for_write(image);
dst = (uint32_t*)(image_data);
for (y = 0; y < h; y++) {
dst = (uint32_t*)(image_data + y * image->line_length);
H = (1 - (float)y / (float)h) * 360;
convertHSVtoRGB(H, S, V, &r, &g, &b);
v = rgb_to_image8888(r, g, b);
for (x = 0; x < w; x++) {
*dst++ = v;
}
}
bitmap_unlock_buffer(image);
return RET_OK;
}
static ret_t color_component_init(widget_t* widget) {
color_component_t* color_component = COLOR_COMPONENT(widget);
return_value_if_fail(color_component != NULL, RET_BAD_PARAMS);
color_component->c = color_init(0xff, 0xff, 0xff, 0xff);
color_component->last_hue = -1;
return RET_OK;
}
widget_t* color_component_create(widget_t* parent, xy_t x, xy_t y, wh_t w, wh_t h) {
widget_t* widget = widget_create(parent, TK_REF_VTABLE(color_component), x, y, w, h);
return_value_if_fail(color_component_init(widget) == RET_OK, NULL);
return widget;
}
ret_t color_component_set_color(widget_t* widget, color_t c) {
float H = 0;
float S = 0;
float V = 0;
color_component_t* color_component = COLOR_COMPONENT(widget);
return_value_if_fail(color_component != NULL, RET_BAD_PARAMS);
color_component->c = c;
convertRGBtoHSV(c.rgba.r, c.rgba.g, c.rgba.b, &H, &S, &V);
if (color_component->update == color_component_update_sv) {
if ((int32_t)H != color_component->last_hue) {
color_component->need_update = TRUE;
log_debug("hue changed(%d != %d)\n", color_component->last_hue, (int32_t)H);
color_component->last_hue = -1;
}
color_component->color_x = V * widget->w;
color_component->color_y = (1 - S) * widget->h;
} else {
color_component->color_y = (1 - H / 360.0f) * widget->h;
}
widget_invalidate(widget, NULL);
return RET_OK;
}
ret_t color_component_set_hsv(widget_t* widget, float h, float s, float v) {
color_t* c;
color_component_t* color_component = COLOR_COMPONENT(widget);
return_value_if_fail(color_component != NULL, RET_BAD_PARAMS);
c = &(color_component->c);
convertHSVtoRGB(h, s, v, &(c->rgba.r), &(c->rgba.g), &(c->rgba.b));
if (color_component->update == color_component_update_sv) {
if ((int32_t)h != color_component->last_hue) {
color_component->need_update = TRUE;
log_debug("hue changed(%d != %d)\n", color_component->last_hue, (int32_t)h);
color_component->last_hue = h;
}
color_component->color_x = v * widget->w;
color_component->color_y = (1 - s) * widget->h;
} else {
color_component->color_y = (1 - h / 360.0f) * widget->h;
}
widget_invalidate(widget, NULL);
return RET_OK;
}
static ret_t color_component_set_type(widget_t* widget, const char* type) {
color_component_t* color_component = COLOR_COMPONENT(widget);
return_value_if_fail(color_component != NULL && type != NULL, RET_BAD_PARAMS);
color_component->image->name = type;
if (tk_str_eq(type, COLOR_PICKER_CHILD_SV)) {
color_component->update = color_component_update_sv;
} else if (tk_str_eq(type, COLOR_PICKER_CHILD_H)) {
color_component->update = color_component_update_h;
} else {
log_debug("not supported color type\n");
}
return RET_OK;
}
float color_component_get_h(widget_t* widget) {
color_component_t* color_component = COLOR_COMPONENT(widget);
return_value_if_fail(widget != NULL && color_component != NULL, 0);
return 360 - color_component->color_y * 360 / widget->h;
}
float color_component_get_s(widget_t* widget) {
color_component_t* color_component = COLOR_COMPONENT(widget);
return_value_if_fail(widget != NULL && color_component != NULL, 0);
return 1 - (float)(color_component->color_y) / (float)(widget->h);
}
float color_component_get_v(widget_t* widget) {
color_component_t* color_component = COLOR_COMPONENT(widget);
return_value_if_fail(widget != NULL && color_component != NULL, 0);
return (float)(color_component->color_x) / (float)(widget->w);
}
widget_t* color_component_cast(widget_t* widget) {
return_value_if_fail(WIDGET_IS_INSTANCE_OF(widget, color_component), NULL);
return widget;
}
|
0 |
repos/awtk/src/ext_widgets
|
repos/awtk/src/ext_widgets/color_picker/color_picker.c
|
/**
* File: color_picker.
* Author: AWTK Develop Team
* Brief: color_picker
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-08-21 Li XianJing <[email protected]> created
*
*/
#include "tkc/mem.h"
#include "widgets/edit.h"
#include "widgets/slider.h"
#include "widgets/color_tile.h"
#include "tkc/color_parser.h"
#include "color_picker/rgb_and_hsv.h"
#include "color_picker/color_picker.h"
#include "color_picker/color_component.h"
static ret_t color_picker_init(widget_t* widget);
static ret_t color_picker_on_paint_begin(widget_t* widget, canvas_t* c);
static ret_t color_picker_get_prop(widget_t* widget, const char* name, value_t* v) {
color_picker_t* color_picker = COLOR_PICKER(widget);
return_value_if_fail(color_picker != NULL && name != NULL && v != NULL, RET_BAD_PARAMS);
if (tk_str_eq(name, WIDGET_PROP_VALUE)) {
value_set_str(v, color_picker->value);
return RET_OK;
}
return RET_NOT_FOUND;
}
static ret_t color_picker_set_prop(widget_t* widget, const char* name, const value_t* v) {
return_value_if_fail(widget != NULL && name != NULL && v != NULL, RET_BAD_PARAMS);
if (tk_str_eq(name, WIDGET_PROP_VALUE)) {
return color_picker_set_color(widget, value_str(v));
}
return RET_NOT_FOUND;
}
TK_DECL_VTABLE(color_picker) = {.size = sizeof(color_picker_t),
.inputable = TRUE,
.type = WIDGET_TYPE_COLOR_PICKER,
.set_prop = color_picker_set_prop,
.get_prop = color_picker_get_prop,
.get_parent_vt = TK_GET_PARENT_VTABLE(widget),
.on_paint_begin = color_picker_on_paint_begin,
.init = color_picker_init,
.create = color_picker_create};
static ret_t color_picker_update_child(void* ctx, const void* iter) {
color_t c;
float h = 0;
float s = 0;
float v = 0;
int32_t value = 0;
widget_t* child = NULL;
const char* name = NULL;
const char* type = NULL;
color_picker_t* color_picker = COLOR_PICKER(ctx);
return_value_if_fail(ctx != NULL && color_picker != NULL && iter != NULL, RET_REMOVE);
child = WIDGET(iter);
return_value_if_fail(child != NULL, RET_REMOVE);
name = child->name;
type = child->vt->type;
c = color_picker->c;
if (color_picker->trigger_child == child) {
return RET_OK;
}
if (child->emitter) {
emitter_disable(child->emitter);
}
if (tk_str_eq(type, WIDGET_TYPE_EDIT) || tk_str_eq(type, WIDGET_TYPE_SPIN_BOX)) {
if (tk_str_eq(name, COLOR_PICKER_CHILD_R)) {
value = c.rgba.r;
edit_set_int(child, value);
} else if (tk_str_eq(name, COLOR_PICKER_CHILD_G)) {
value = c.rgba.g;
edit_set_int(child, value);
} else if (tk_str_eq(name, COLOR_PICKER_CHILD_B)) {
value = c.rgba.b;
edit_set_int(child, value);
} else if (tk_str_eq(name, COLOR_PICKER_CHILD_H)) {
value = color_picker->last_hue;
edit_set_int(child, value);
} else if (tk_str_eq(name, COLOR_PICKER_CHILD_S)) {
convertRGBtoHSV(c.rgba.r, c.rgba.g, c.rgba.b, &h, &s, &v);
value = s * 100;
edit_set_int(child, value);
} else if (tk_str_eq(name, COLOR_PICKER_CHILD_V)) {
convertRGBtoHSV(c.rgba.r, c.rgba.g, c.rgba.b, &h, &s, &v);
value = v * 100;
edit_set_int(child, value);
} else if (tk_str_eq(name, COLOR_PICKER_CHILD_NEW)) {
char hex[TK_COLOR_HEX_LEN + 1];
color_hex_str(color_picker->c, hex);
widget_set_text_utf8(child, hex + 1);
} else if (tk_str_eq(name, COLOR_PICKER_CHILD_OLD)) {
char hex[TK_COLOR_HEX_LEN + 1];
color_hex_str(color_picker->init_c, hex);
widget_set_text_utf8(child, hex + 1);
}
} else if (tk_str_eq(type, WIDGET_TYPE_SLIDER)) {
if (tk_str_eq(name, COLOR_PICKER_CHILD_R)) {
value = color_picker->c_r_value * 100 / 255;
} else if (tk_str_eq(name, COLOR_PICKER_CHILD_G)) {
value = color_picker->c_g_value * 100 / 255;
} else if (tk_str_eq(name, COLOR_PICKER_CHILD_B)) {
value = color_picker->c_b_value * 100 / 255;
} else if (tk_str_eq(name, COLOR_PICKER_CHILD_H)) {
value = color_picker->last_hue * 100 / 360;
} else if (tk_str_eq(name, COLOR_PICKER_CHILD_S)) {
convertRGBtoHSV(c.rgba.r, c.rgba.g, c.rgba.b, &h, &s, &v);
value = s * 100;
} else if (tk_str_eq(name, COLOR_PICKER_CHILD_V)) {
convertRGBtoHSV(c.rgba.r, c.rgba.g, c.rgba.b, &h, &s, &v);
value = v * 100;
}
widget_set_value(child, value);
} else if (tk_str_eq(type, WIDGET_TYPE_COLOR_COMPONENT)) {
if (tk_str_eq(name, COLOR_PICKER_CHILD_SV)) {
convertRGBtoHSV(c.rgba.r, c.rgba.g, c.rgba.b, &h, &s, &v);
color_component_set_hsv(child, color_picker->last_hue, s, v);
} else if (tk_str_eq(name, COLOR_PICKER_CHILD_H)) {
convertRGBtoHSV(c.rgba.r, c.rgba.g, c.rgba.b, &h, &s, &v);
color_component_set_hsv(child, color_picker->last_hue, s, v);
}
} else if (tk_str_eq(type, WIDGET_TYPE_COLOR_TILE)) {
if (tk_str_eq(name, COLOR_PICKER_CHILD_NEW)) {
color_tile_set_value(child, c);
} else if (tk_str_eq(name, COLOR_PICKER_CHILD_OLD)) {
color_tile_set_value(child, color_picker->init_c);
}
}
if (child->emitter) {
emitter_enable(child->emitter);
}
return RET_OK;
}
static ret_t color_picker_sync_children(widget_t* widget) {
widget_foreach(widget, color_picker_update_child, widget);
return RET_OK;
}
static ret_t color_picker_update_color(widget_t* widget, color_t color);
static ret_t color_picker_set_color_r(widget_t* widget, float_t r) {
color_t c;
color_picker_t* color_picker = COLOR_PICKER(widget);
return_value_if_fail(widget != NULL && color_picker != NULL, RET_BAD_PARAMS);
c = color_picker->c;
c.rgba.r = (uint8_t)r;
color_picker->c_r_value = r;
return color_picker_update_color(widget, c);
}
static ret_t color_picker_set_color_g(widget_t* widget, float_t g) {
color_t c;
color_picker_t* color_picker = COLOR_PICKER(widget);
return_value_if_fail(widget != NULL && color_picker != NULL, RET_BAD_PARAMS);
c = color_picker->c;
c.rgba.g = (uint8_t)g;
color_picker->c_g_value = g;
return color_picker_update_color(widget, c);
}
static ret_t color_picker_set_color_b(widget_t* widget, float_t b) {
color_t c;
color_picker_t* color_picker = COLOR_PICKER(widget);
return_value_if_fail(widget != NULL && color_picker != NULL, RET_BAD_PARAMS);
c = color_picker->c;
c.rgba.b = (uint8_t)b;
color_picker->c_b_value = b;
return color_picker_update_color(widget, c);
}
static ret_t color_picker_set_color_h(widget_t* widget, float hh) {
color_t c;
float h = 0;
float s = 0;
float v = 0;
color_picker_t* color_picker = COLOR_PICKER(widget);
return_value_if_fail(widget != NULL && color_picker != NULL, RET_BAD_PARAMS);
color_picker->last_hue = hh;
c = color_picker->c;
convertRGBtoHSV(c.rgba.r, c.rgba.g, c.rgba.b, &h, &s, &v);
convertHSVtoRGB(hh, s, v, &(c.rgba.r), &(c.rgba.g), &(c.rgba.b));
return color_picker_update_color(widget, c);
}
static ret_t color_picker_set_color_s(widget_t* widget, float ss) {
color_t c;
float h = 0;
float s = 0;
float v = 0;
color_picker_t* color_picker = COLOR_PICKER(widget);
return_value_if_fail(widget != NULL && color_picker != NULL, RET_BAD_PARAMS);
c = color_picker->c;
convertRGBtoHSV(c.rgba.r, c.rgba.g, c.rgba.b, &h, &s, &v);
convertHSVtoRGB(h, ss, v, &(c.rgba.r), &(c.rgba.g), &(c.rgba.b));
return color_picker_update_color(widget, c);
}
static ret_t color_picker_set_color_v(widget_t* widget, float vv) {
color_t c;
float h = 0;
float s = 0;
float v = 0;
color_picker_t* color_picker = COLOR_PICKER(widget);
return_value_if_fail(widget != NULL && color_picker != NULL, RET_BAD_PARAMS);
c = color_picker->c;
convertRGBtoHSV(c.rgba.r, c.rgba.g, c.rgba.b, &h, &s, &v);
convertHSVtoRGB(h, s, vv, &(c.rgba.r), &(c.rgba.g), &(c.rgba.b));
return color_picker_update_color(widget, c);
}
static ret_t color_picker_set_color_sv(widget_t* widget, float ss, float vv) {
color_t c;
float h = 0;
float s = 0;
float v = 0;
color_picker_t* color_picker = COLOR_PICKER(widget);
return_value_if_fail(widget != NULL && color_picker != NULL, RET_BAD_PARAMS);
c = color_picker->c;
convertRGBtoHSV(c.rgba.r, c.rgba.g, c.rgba.b, &h, &s, &v);
if (color_picker->last_hue != -1) h = color_picker->last_hue;
convertHSVtoRGB(h, ss, vv, &(c.rgba.r), &(c.rgba.g), &(c.rgba.b));
return color_picker_update_color(widget, c);
}
static ret_t color_picker_on_child_value_changing(void* ctx, event_t* e) {
widget_t* widget = NULL;
widget_t* child = NULL;
const char* name = NULL;
const char* type = NULL;
color_picker_t* color_picker = COLOR_PICKER(ctx);
return_value_if_fail(e != NULL && color_picker != NULL, RET_BAD_PARAMS);
color_picker->last_hue = -1;
widget = WIDGET(ctx);
child = WIDGET(e->target);
name = child->name;
return_value_if_fail(child != NULL && child->vt != NULL, RET_BAD_PARAMS);
type = widget_get_type(child);
color_picker->trigger_child = child;
if (tk_str_eq(type, WIDGET_TYPE_EDIT) || tk_str_eq(type, WIDGET_TYPE_SPIN_BOX)) {
int32_t v = edit_get_int(child);
if (tk_str_eq(name, COLOR_PICKER_CHILD_R)) {
color_picker_set_color_r(widget, v);
} else if (tk_str_eq(name, COLOR_PICKER_CHILD_G)) {
color_picker_set_color_g(widget, v);
} else if (tk_str_eq(name, COLOR_PICKER_CHILD_B)) {
color_picker_set_color_b(widget, v);
} else if (tk_str_eq(name, COLOR_PICKER_CHILD_H)) {
color_picker_set_color_h(widget, v);
} else if (tk_str_eq(name, COLOR_PICKER_CHILD_S)) {
color_picker_set_color_s(widget, (float)v / 100.0f);
} else if (tk_str_eq(name, COLOR_PICKER_CHILD_V)) {
color_picker_set_color_v(widget, (float)v / 100.0f);
} else if (tk_str_eq(name, COLOR_PICKER_CHILD_NEW)) {
char color[32];
uint32_t len = 0;
memset(color, 0x00, sizeof(color));
color[0] = '#';
wstr_get_utf8(&(child->text), color + 1, sizeof(color) - 2);
len = strlen(color);
if (len == 1) {
color_picker_set_color(widget, "rgba(0,0,0,0)");
} else if (len == 7 || len == 9) {
color_picker_set_color(widget, color);
}
}
} else if (tk_str_eq(type, WIDGET_TYPE_SLIDER)) {
int32_t v = widget_get_value(child);
if (tk_str_eq(name, COLOR_PICKER_CHILD_R)) {
color_picker_set_color_r(widget, v * 255 / 100.0f);
} else if (tk_str_eq(name, COLOR_PICKER_CHILD_G)) {
color_picker_set_color_g(widget, v * 255 / 100.0f);
} else if (tk_str_eq(name, COLOR_PICKER_CHILD_B)) {
color_picker_set_color_b(widget, v * 255 / 100.0f);
} else if (tk_str_eq(name, COLOR_PICKER_CHILD_H)) {
color_picker_set_color_h(widget, v * 360 / 100);
} else if (tk_str_eq(name, COLOR_PICKER_CHILD_S)) {
color_picker_set_color_s(widget, (float)v / 100.0f);
} else if (tk_str_eq(name, COLOR_PICKER_CHILD_V)) {
color_picker_set_color_v(widget, (float)v / 100.0f);
}
} else if (tk_str_eq(type, WIDGET_TYPE_COLOR_COMPONENT)) {
color_picker->c.rgba.a = 0xff;
if (tk_str_eq(name, COLOR_PICKER_CHILD_SV)) {
color_component_t* color_cmp = COLOR_COMPONENT(child);
float s = color_component_get_s(child);
float v = color_component_get_v(child);
color_picker->last_hue = color_cmp->last_hue;
color_picker_set_color_sv(widget, s, v);
} else if (tk_str_eq(name, COLOR_PICKER_CHILD_H)) {
float h = color_component_get_h(child);
color_picker_set_color_h(widget, h);
}
}
color_picker->trigger_child = NULL;
return RET_OK;
}
static ret_t color_picker_hook_children(void* ctx, const void* iter) {
const char* name = NULL;
const char* type = NULL;
widget_t* child = WIDGET(iter);
return_value_if_fail(child != NULL, RET_BAD_PARAMS);
name = child->name;
type = widget_get_type(child);
if (name != NULL) {
if (tk_str_eq(type, WIDGET_TYPE_EDIT) || tk_str_eq(type, WIDGET_TYPE_SLIDER) ||
tk_str_eq(type, WIDGET_TYPE_COLOR_COMPONENT) || tk_str_eq(type, WIDGET_TYPE_SPIN_BOX)) {
widget_on(WIDGET(iter), EVT_VALUE_CHANGING, color_picker_on_child_value_changing, ctx);
widget_on(WIDGET(iter), EVT_VALUE_CHANGED, color_picker_on_child_value_changing, ctx);
}
}
return RET_OK;
}
static ret_t color_picker_init(widget_t* widget) {
color_picker_t* color_picker = COLOR_PICKER(widget);
return_value_if_fail(color_picker != NULL, RET_BAD_PARAMS);
color_picker->inited = FALSE;
color_picker_set_color(widget, "gold");
return RET_OK;
}
widget_t* color_picker_create(widget_t* parent, xy_t x, xy_t y, wh_t w, wh_t h) {
widget_t* widget = widget_create(parent, TK_REF_VTABLE(color_picker), x, y, w, h);
return_value_if_fail(color_picker_init(widget) == RET_OK, NULL);
return widget;
}
static ret_t color_picker_update_color(widget_t* widget, color_t color) {
color_picker_t* color_picker = COLOR_PICKER(widget);
return_value_if_fail(widget != NULL && color_picker != NULL, RET_BAD_PARAMS);
if (color_picker->last_hue == -1) {
float h = 0;
float s = 0;
float v = 0;
convertRGBtoHSV(color.rgba.r, color.rgba.g, color.rgba.b, &h, &s, &v);
color_picker->last_hue = h;
}
if (color_picker->c.color != color.color) {
value_change_event_t evt;
value_change_event_init(&evt, EVT_VALUE_WILL_CHANGE, widget);
value_set_uint32(&(evt.old_value), color_picker->c.color);
value_set_uint32(&(evt.new_value), color.color);
if (widget_dispatch(widget, (event_t*)&evt) != RET_STOP) {
color_picker->c = color;
color_picker->c_r_value = color.rgba.r;
color_picker->c_g_value = color.rgba.g;
color_picker->c_b_value = color.rgba.b;
color_hex_str(color_picker->c, color_picker->value);
color_picker_sync_children(widget);
evt.e.type = EVT_VALUE_CHANGED;
widget_dispatch(widget, (event_t*)&evt);
widget_invalidate(widget, NULL);
}
}
return RET_OK;
}
ret_t color_picker_set_color(widget_t* widget, const char* color) {
color_picker_t* color_picker = COLOR_PICKER(widget);
return_value_if_fail(color_picker != NULL && color != NULL, RET_BAD_PARAMS);
float h = 0;
float s = 0;
float v = 0;
color_picker->init_c = color_parse(color);
convertRGBtoHSV(color_picker->init_c.rgba.r, color_picker->init_c.rgba.g,
color_picker->init_c.rgba.b, &h, &s, &v);
color_picker->last_hue = h;
color_picker_update_color(widget, color_picker->init_c);
return RET_OK;
}
widget_t* color_picker_cast(widget_t* widget) {
return_value_if_fail(WIDGET_IS_INSTANCE_OF(widget, color_picker), NULL);
return widget;
}
static ret_t color_picker_init_if_not_inited(widget_t* widget) {
color_picker_t* color_picker = COLOR_PICKER(widget);
return_value_if_fail(color_picker != NULL, RET_BAD_PARAMS);
if (!(color_picker->inited)) {
widget_foreach(WIDGET(widget), color_picker_hook_children, widget);
color_picker_sync_children(WIDGET(widget));
color_picker->inited = TRUE;
}
return RET_OK;
}
static ret_t color_picker_on_paint_begin(widget_t* widget, canvas_t* c) {
return color_picker_init_if_not_inited(widget);
}
|
0 |
repos/awtk/src/ext_widgets
|
repos/awtk/src/ext_widgets/rich_text/rich_text_parser.h
|
/**
* File: rich_text_parser.h
* Author: AWTK Develop Team
* Brief: rich_text_parser
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is dirich_text_parseributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-07-27 Li XianJing <[email protected]> created
*
*/
#ifndef TK_RICH_TEXT_PARSER_H
#define TK_RICH_TEXT_PARSER_H
#include "rich_text/rich_text_node.h"
BEGIN_C_DECLS
rich_text_node_t* rich_text_parse(const char* str, uint32_t size, const char* font_name,
uint16_t font_size, color_t color, align_v_t align_v);
END_C_DECLS
#endif /*TK_RICH_TEXT_PARSER_H*/
|
0 |
repos/awtk/src/ext_widgets
|
repos/awtk/src/ext_widgets/rich_text/rich_text_view.h
|
/**
* File: rich_text_view.h
* Author: AWTK Develop Team
* Brief: rich_text_view
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2020-04-24 Li XianJing <[email protected]> created
*
*/
#ifndef TK_RICH_TEXT_VIEW_H
#define TK_RICH_TEXT_VIEW_H
#include "base/widget.h"
BEGIN_C_DECLS
/**
* @class rich_text_view_t
* @parent widget_t
* @annotation ["scriptable","design","widget"]
*
* rich_text_view是一个专用容器，用来放rich text和 scroll bar，并在两者之间建立联系。
*
* rich_text_view\_t是[widget\_t](widget_t.md)的子类控件，widget\_t的函数均适用于rich_text_view\_t控件。
*
* 在xml中使用"rich_text_view"标签创建rich_text_view。如：
*
* ```xml
* <rich_text_view x="0" y="10" w="100%" h="300">
* <rich_text line_gap="5" x="0" y="10" w="-12" h="100%" margin="10">
* ...
* </rich_text>
* <scroll_bar_d name="bar" x="right" y="0" w="12" h="100%" value="0"/>
* </rich_text_view>
* ```
*
* 可用通过style来设置控件的显示风格，如背景颜色等。如：
*
* ```xml
* <style name="default" border_color="#a0a0a0">
* <normal bg_color="#f0f0f0" />
* </style>
* ```
*/
typedef struct _rich_text_view_t {
widget_t widget;
/*private*/
widget_t* scroll_bar;
widget_t* rich_text;
} rich_text_view_t;
/**
* @method rich_text_view_create
* 创建rich_text_view对象
* @annotation ["constructor", "scriptable"]
* @param {widget_t*} parent 父控件
* @param {xy_t} x x坐标
* @param {xy_t} y y坐标
* @param {wh_t} w 宽度
* @param {wh_t} h 高度
*
* @return {widget_t*} 对象。
*/
widget_t* rich_text_view_create(widget_t* parent, xy_t x, xy_t y, wh_t w, wh_t h);
/**
* @method rich_text_view_cast
* 转换为rich_text_view对象(供脚本语言使用)。
* @annotation ["cast", "scriptable"]
* @param {widget_t*} widget rich_text_view对象。
*
* @return {widget_t*} rich_text_view对象。
*/
widget_t* rich_text_view_cast(widget_t* widget);
#define WIDGET_TYPE_RICH_TEXT_VIEW "rich_text_view"
#define RICH_TEXT_VIEW(widget) ((rich_text_view_t*)(rich_text_view_cast(WIDGET(widget))))
END_C_DECLS
#endif /*TK_RICH_TEXT_VIEW_H*/
|
0 |
repos/awtk/src/ext_widgets
|
repos/awtk/src/ext_widgets/rich_text/rich_text_node.c
|
/**
* File: rich_text_node.h
* Author: AWTK Develop Team
* Brief: rich_text_node
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is dirich_text_nodeibuted in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-07-27 Li XianJing <[email protected]> created
*
*/
#include "tkc/str.h"
#include "tkc/mem.h"
#include "tkc/utf8.h"
#include "tkc/utils.h"
#include "rich_text/rich_text_node.h"
rich_text_node_t* rich_text_text_create_with_len(rich_text_font_t* font, const char* text,
uint32_t len) {
rich_text_node_t* node = NULL;
return_value_if_fail(font != NULL && text != NULL, NULL);
node = TKMEM_ZALLOC(rich_text_node_t);
return_value_if_fail(node != NULL, NULL);
node->next = NULL;
node->type = RICH_TEXT_TEXT;
node->u.text.font = *font;
if (font->name != NULL) {
node->u.text.font.name = tk_strdup(font->name);
goto_error_if_fail(node->u.text.font.name != NULL);
}
node->u.text.text = (wchar_t*)TKMEM_ALLOC(sizeof(wchar_t) * (len + 1));
goto_error_if_fail(node->u.text.text != NULL);
tk_utf8_to_utf16(text, node->u.text.text, len + 1);
return node;
error:
TKMEM_FREE(node->u.text.font.name);
TKMEM_FREE(node);
return NULL;
}
rich_text_node_t* rich_text_text_create(rich_text_font_t* font, const char* text) {
return_value_if_fail(font != NULL && text != NULL, NULL);
return rich_text_text_create_with_len(font, text, strlen(text));
}
rich_text_node_t* rich_text_image_create(const char* name, uint32_t w, uint32_t h,
uint32_t draw_type) {
rich_text_node_t* node = NULL;
return_value_if_fail(name != NULL, NULL);
node = TKMEM_ZALLOC(rich_text_node_t);
return_value_if_fail(node != NULL, NULL);
node->next = NULL;
node->type = RICH_TEXT_IMAGE;
node->u.image.w = w;
node->u.image.h = h;
node->u.image.draw_type = (image_draw_type_t)draw_type;
node->u.image.name = tk_strdup(name);
goto_error_if_fail(node->u.image.name != NULL);
return node;
error:
TKMEM_FREE(node);
return NULL;
}
ret_t rich_text_text_destroy(rich_text_node_t* node) {
return_value_if_fail(node != NULL && node->type == RICH_TEXT_TEXT, RET_BAD_PARAMS);
TKMEM_FREE(node->u.text.text);
TKMEM_FREE(node->u.text.font.name);
memset(node, 0x00, sizeof(rich_text_node_t));
TKMEM_FREE(node);
return RET_OK;
}
ret_t rich_text_image_destroy(rich_text_node_t* node) {
return_value_if_fail(node != NULL && node->type == RICH_TEXT_IMAGE, RET_BAD_PARAMS);
TKMEM_FREE(node->u.image.name);
memset(node, 0x00, sizeof(rich_text_node_t));
TKMEM_FREE(node);
return RET_OK;
}
rich_text_node_t* rich_text_node_append(rich_text_node_t* node, rich_text_node_t* next) {
rich_text_node_t* iter = node;
return_value_if_fail(next != NULL, node);
if (node == NULL) {
return next;
}
while (iter->next != NULL) {
iter = iter->next;
}
iter->next = next;
return node;
}
ret_t rich_text_node_destroy(rich_text_node_t* node) {
rich_text_node_t* next = NULL;
rich_text_node_t* iter = node;
return_value_if_fail(node != NULL, RET_BAD_PARAMS);
while (iter != NULL) {
next = iter->next;
if (iter->type == RICH_TEXT_TEXT) {
rich_text_text_destroy(iter);
} else if (iter->type == RICH_TEXT_IMAGE) {
rich_text_image_destroy(iter);
}
iter = next;
}
return RET_OK;
}
int32_t rich_text_node_count(rich_text_node_t* node) {
int32_t nr = 0;
rich_text_node_t* iter = node;
return_value_if_fail(node != NULL, RET_BAD_PARAMS);
while (iter != NULL) {
nr++;
iter = iter->next;
}
return nr;
}
|
0 |
repos/awtk/src/ext_widgets
|
repos/awtk/src/ext_widgets/rich_text/rich_text.h
|
/**
* File: rich_text.h
* Author: AWTK Develop Team
* Brief: rich_text
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-07-28 Li XianJing <[email protected]> created
*
*/
#ifndef TK_RICH_TEXT_H
#define TK_RICH_TEXT_H
#include "base/widget.h"
#include "base/velocity.h"
#include "base/widget_animator.h"
#include "rich_text/rich_text_render_node.h"
BEGIN_C_DECLS
/**
* @class rich_text_t
* @parent widget_t
* @annotation ["scriptable","design","widget"]
* 图文混排控件，实现简单的图文混排。
*
* rich\_text\_t是[widget\_t](widget_t.md)的子类控件，widget\_t的函数均适用于rich\_text\_t控件。
*
* 在xml中使用"rich\_text"标签创建图文混排控件。如：
*
* ```xml
* <rich_text x="0" y="0" w="100%" h="60"
* text="<image name="a;bricks"a;/><font align_v="a;middle"a;>hello awtk!</font>" />
* ```
* >
*
* > 更多用法请参考：
* [rich_text.xml](https://github.com/zlgopen/awtk/blob/master/design/default/ui/rich_text.xml)
*
* 在c代码中使用函数rich\_text\_create创建图文混排控件。如：
*
* ```c
* widget_t* rich_text = rich_text_create(win, 0, 0, 0, 0);
* widget_set_text_utf8(rich_text,
* "<image name=\"bricks\"/><font color=\"gold\" align_v=\"bottom\" "
* "size=\"24\">hello awtk!</font><font color=\"green\" size=\"20\">ProTip! The "
* "feed shows you events from people you follow and repositories you watch. "
* "nhello world. </font><font color=\"red\" "
* "size=\"20\">确定取消中文字符测试。确定。取消。中文字符测试。</font>");
*
* widget_set_self_layout_params(rich_text, "center", "middle", "100%", "100%");
* ```
*
* > 完整示例请参考：
* [rich_text demo](https://github.com/zlgopen/awtk-c-demos/blob/master/demos/rich_text.c)
*
* 可用通过style来设置控件的显示风格，如背景颜色等等。而字体的大小和颜色则由文本内部的属性决定。
*
* 目前支持image和font两个tag：
*
* * image 支持的属性有：
* * name 图片的名称。
* * w 图片的宽度。
* * h 图片的高度。
*
* * font 支持的属性有：
* * color 颜色。
* * size 大小。
* * align_v 垂直方向对齐的方式(top|middle|bottom)。
* * bold 粗体(暂不支持)
* * italic 斜体(暂不支持)
* * underline 下划线(暂不支持)
*
*/
typedef struct _rich_text_t {
widget_t widget;
/**
* @property {uint32_t} line_gap
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 行间距。
*/
uint32_t line_gap;
/**
* @property {int32_t} yoffset
* @annotation ["set_prop","get_prop","readable"]
* y偏移。
*/
int32_t yoffset;
/**
* @property {bool_t} yslidable
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 标识控件是否允许上下拖动。
*/
bool_t yslidable;
/**
* @property {bool_t} need_reset
* @annotation ["readable"]
* 标识控件是否需要重新绘图。
*/
bool_t need_reset;
/*private*/
bool_t pressed;
int32_t ydown;
int32_t yoffset_end;
uint32_t content_h;
rich_text_node_t* node;
widget_animator_t* wa;
velocity_t velocity;
int32_t yoffset_save;
rich_text_render_node_t* render_node;
int32_t margin;
int32_t attribute_margin;
color_t default_color;
align_v_t default_align_v;
uint16_t default_font_size;
const char* default_font_name;
} rich_text_t;
/**
* @method rich_text_create
* 创建rich_text对象
* @annotation ["constructor", "scriptable"]
* @param {widget_t*} parent 父控件
* @param {xy_t} x x坐标
* @param {xy_t} y y坐标
* @param {wh_t} w 宽度
* @param {wh_t} h 高度
*
* @return {widget_t*} 对象。
*/
widget_t* rich_text_create(widget_t* parent, xy_t x, xy_t y, wh_t w, wh_t h);
/**
* @method rich_text_set_text
* 设置文本。
* @annotation ["scriptable"]
* @param {widget_t*} widget 控件对象。
* @param {const char*} text 文本。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t rich_text_set_text(widget_t* widget, const char* text);
/**
* @method rich_text_set_yslidable
* 设置是否允许y方向滑动。
* @annotation ["scriptable"]
* @param {widget_t*} widget 控件对象。
* @param {bool_t} yslidable 是否允许滑动。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t rich_text_set_yslidable(widget_t* widget, bool_t yslidable);
/**
* @method rich_text_cast
* 转换为rich_text对象(供脚本语言使用)。
* @annotation ["cast", "scriptable"]
* @param {widget_t*} widget rich_text对象。
*
* @return {widget_t*} rich_text对象。
*/
widget_t* rich_text_cast(widget_t* widget);
#define RICH_TEXT(widget) ((rich_text_t*)(rich_text_cast(WIDGET(widget))))
/*public for subclass and runtime type check*/
TK_EXTERN_VTABLE(rich_text);
END_C_DECLS
#endif /*TK_RICH_TEXT_H*/
|
0 |
repos/awtk/src/ext_widgets
|
repos/awtk/src/ext_widgets/rich_text/rich_text.c
|
/**
* File: rich_text.h
* Author: AWTK Develop Team
* Brief: rich_text
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-07-28 Li XianJing <[email protected]> created
*
*/
#include "tkc/mem.h"
#include "base/timer.h"
#include "tkc/utils.h"
#include "base/image_manager.h"
#include "rich_text/rich_text.h"
#include "rich_text/rich_text_parser.h"
#include "widget_animators/widget_animator_scroll.h"
static bool_t rich_text_is_scollable(widget_t* widget) {
rich_text_t* rich_text = RICH_TEXT(widget);
return_value_if_fail(rich_text != NULL, FALSE);
return (rich_text->content_h + rich_text->margin * 2) > widget->h;
}
static ret_t rich_text_reset(widget_t* widget) {
rich_text_t* rich_text = RICH_TEXT(widget);
return_value_if_fail(rich_text != NULL, RET_BAD_PARAMS);
if (rich_text->node != NULL) {
rich_text_node_destroy(rich_text->node);
rich_text->node = NULL;
}
if (rich_text->render_node != NULL) {
rich_text_render_node_destroy(rich_text->render_node);
rich_text->render_node = NULL;
}
return RET_OK;
}
static ret_t rich_text_get_margin(widget_t* widget) {
int32_t margin = 0;
int32_t tmp_margin = 0;
rich_text_t* rich_text = RICH_TEXT(widget);
ENSURE(rich_text);
return_value_if_fail(widget != NULL, RET_BAD_PARAMS);
margin = style_get_int(widget->astyle, STYLE_ID_MARGIN, 0);
tmp_margin = rich_text->margin;
if (margin != 0) {
rich_text->margin = margin;
} else {
rich_text->margin = rich_text->attribute_margin;
}
if (tmp_margin != rich_text->margin) {
rich_text->need_reset = TRUE;
}
return RET_OK;
}
static ret_t rich_text_on_paint_text(widget_t* widget, canvas_t* c) {
rect_t r;
rect_t r_save;
int32_t yoffset = 0;
int32_t align_h = ALIGN_H_LEFT;
rich_text_render_node_t* iter = NULL;
rich_text_t* rich_text = RICH_TEXT(widget);
return_value_if_fail(widget != NULL && rich_text != NULL && c != NULL, RET_BAD_PARAMS);
yoffset = rich_text->yoffset;
if (widget->w <= rich_text->margin << 1 || widget->h <= rich_text->margin << 1) {
return RET_OK;
}
r = rect_init(c->ox, c->oy, widget->w, widget->h);
r.x += rich_text->margin;
r.y += rich_text->margin;
r.w -= rich_text->margin << 1;
r.h -= rich_text->margin << 1;
canvas_get_clip_rect(c, &r_save);
r = rect_intersect(&r, &r_save);
canvas_set_clip_rect(c, &r);
if (widget->astyle) {
align_h = style_get_int(widget->astyle, STYLE_ID_TEXT_ALIGN_H, ALIGN_H_LEFT);
}
iter = rich_text->render_node;
while (iter != NULL) {
r = iter->rect;
r.y -= yoffset;
if ((r.y + r.h) <= 0) {
iter = iter->next;
continue;
}
if (r.y > widget->h) {
break;
}
if (align_h == ALIGN_H_CENTER) {
r.x += iter->align_h_w >> 1;
} else if (align_h == ALIGN_H_RIGHT) {
r.x += iter->align_h_w;
}
switch (iter->node->type) {
case RICH_TEXT_TEXT: {
rect_t cr;
int32_t i = 0;
float_t x = r.x;
wchar_t* text = iter->text;
int32_t spacing = iter->spacing;
rich_text_font_t* font = &(iter->node->u.text.font);
canvas_set_text_color(c, font->color);
canvas_set_font(c, font->name, font->size);
canvas_set_text_align(c, ALIGN_H_LEFT, font->align_v);
for (i = 0; i < iter->size; i++) {
float_t cw = canvas_measure_text(c, text + i, 1);
cr.x = x;
cr.y = r.y;
cr.h = r.h;
cr.w = cw + 1;
canvas_draw_text_in_rect(c, text + i, 1, &cr);
x += cw;
if (spacing > 0) {
if (rich_text_is_flexable_w_char(text[i])) {
x += iter->flexible_w_char_delta_w;
spacing -= iter->flexible_w_char_delta_w;
}
}
}
break;
}
case RICH_TEXT_IMAGE: {
bitmap_t bitmap;
const char* name = iter->node->u.image.name;
image_draw_type_t draw_type = iter->node->u.image.draw_type;
if (widget_load_image(widget, name, &bitmap) == RET_OK) {
canvas_draw_image_ex(c, &bitmap, draw_type, &r);
}
break;
}
default:
break;
}
iter = iter->next;
}
canvas_set_clip_rect(c, &r_save);
return RET_OK;
}
static bool_t rich_text_is_need_reset_from_style(rich_text_t* rich_text, const char* font_name,
uint16_t font_size, color_t color,
align_v_t align_v) {
return_value_if_fail(rich_text != NULL, FALSE);
if (font_name != NULL && tk_str_cmp(rich_text->default_font_name, font_name) != 0) {
return TRUE;
}
if (rich_text->default_font_size != font_size) {
return TRUE;
}
if (rich_text->default_color.color != color.color) {
return TRUE;
}
if (rich_text->default_align_v != align_v) {
return TRUE;
}
return FALSE;
}
static ret_t rich_text_ensure_render_node(widget_t* widget, canvas_t* c) {
rich_text_t* rich_text = RICH_TEXT(widget);
style_t* style = widget != NULL ? widget->astyle : NULL;
const char* default_font_name = style_get_str(style, STYLE_ID_FONT_NAME, NULL);
uint16_t default_font_size = style_get_int(style, STYLE_ID_FONT_SIZE, TK_DEFAULT_FONT_SIZE);
color_t default_color = style_get_color(style, STYLE_ID_TEXT_COLOR, color_init(0, 0, 0, 0xff));
align_v_t default_align_v =
(align_v_t)style_get_int(style, STYLE_ID_TEXT_ALIGN_V, ALIGN_V_BOTTOM);
return_value_if_fail(widget != NULL && rich_text != NULL && style != NULL, RET_BAD_PARAMS);
rich_text->need_reset =
rich_text->need_reset ||
rich_text_is_need_reset_from_style(rich_text, default_font_name, default_font_size,
default_color, default_align_v);
if (rich_text->need_reset) {
str_t str;
str_init(&str, widget->text.size * 4 + 1);
str_from_wstr(&str, widget->text.str);
rich_text_reset(widget);
rich_text->node = rich_text_parse(str.str, str.size, default_font_name, default_font_size,
default_color, default_align_v);
str_reset(&str);
rich_text->need_reset = FALSE;
rich_text->default_color = default_color;
rich_text->default_align_v = default_align_v;
rich_text->default_font_size = default_font_size;
rich_text->default_font_name = default_font_name;
}
if (rich_text->render_node != NULL) {
return RET_OK;
}
if (rich_text->node == NULL) {
return RET_FAIL;
}
if (rich_text->render_node == NULL) {
int32_t w = widget->w;
int32_t h = widget->h;
int32_t line_gap = rich_text->line_gap;
int32_t margin = rich_text->margin;
rich_text->render_node =
rich_text_render_node_layout(widget, rich_text->node, c, w, h, margin, line_gap);
widget_set_prop_int(WIDGET(rich_text), WIDGET_PROP_YOFFSET, 0);
}
return_value_if_fail(rich_text->render_node != NULL, RET_OOM);
return RET_OK;
}
static ret_t rich_text_on_paint_self(widget_t* widget, canvas_t* c) {
rich_text_get_margin(widget);
if (rich_text_ensure_render_node(widget, c) == RET_OK) {
return rich_text_on_paint_text(widget, c);
}
return RET_OK;
}
static ret_t rich_text_on_scroll_done(void* ctx, event_t* e) {
widget_t* widget = WIDGET(ctx);
rich_text_t* rich_text = RICH_TEXT(ctx);
return_value_if_fail(widget != NULL && rich_text != NULL, RET_BAD_PARAMS);
rich_text->wa = NULL;
return RET_REMOVE;
}
ret_t rich_text_scroll_to(widget_t* widget, int32_t yoffset_end) {
int32_t yoffset = 0;
int32_t virtual_h = 0;
rich_text_t* rich_text = RICH_TEXT(widget);
return_value_if_fail(rich_text != NULL, RET_FAIL);
virtual_h = rich_text->content_h + rich_text->margin * 2;
if (!rich_text_is_scollable(widget)) {
rich_text->yoffset = 0;
return RET_OK;
}
if (yoffset_end < 0) {
yoffset_end = 0;
}
if ((yoffset_end + widget->h) > virtual_h) {
yoffset_end = virtual_h - widget->h;
}
if (yoffset_end == rich_text->yoffset) {
return RET_OK;
}
yoffset = rich_text->yoffset;
if (rich_text->wa != NULL) {
widget_animator_scroll_t* wa = (widget_animator_scroll_t*)rich_text->wa;
if (yoffset_end != rich_text->yoffset) {
bool_t changed = wa->y_to != yoffset_end;
bool_t in_range = wa->y_to >= 0 && wa->y_to < (virtual_h - widget->h);
if (changed && in_range) {
wa->y_to = yoffset_end;
wa->y_from = rich_text->yoffset;
wa->base.now = 0;
wa->base.start_time = 0;
}
}
} else {
rich_text->wa = widget_animator_scroll_create(widget, TK_ANIMATING_TIME, 0, EASING_SIN_INOUT);
return_value_if_fail(rich_text->wa != NULL, RET_OOM);
widget_animator_scroll_set_params(rich_text->wa, 0, yoffset, 0, yoffset_end);
widget_animator_on(rich_text->wa, EVT_ANIM_END, rich_text_on_scroll_done, rich_text);
widget_animator_start(rich_text->wa);
}
return RET_OK;
}
ret_t rich_text_scroll_delta_to(widget_t* widget, int32_t yoffset_delta) {
rich_text_t* rich_text = RICH_TEXT(widget);
return_value_if_fail(rich_text != NULL, RET_FAIL);
rich_text->yoffset_end = rich_text->yoffset + yoffset_delta;
return rich_text_scroll_to(widget, rich_text->yoffset_end);
}
static uint32_t rich_text_get_row_height(widget_t* widget) {
rich_text_t* rich_text = RICH_TEXT(widget);
return_value_if_fail(rich_text != NULL, 30);
if (rich_text->render_node != NULL) {
int32_t row_height = tk_max(rich_text->render_node->rect.h, 30);
return tk_min(row_height, widget->h / 2);
} else {
return 30;
}
}
static ret_t rich_text_on_pointer_down(rich_text_t* rich_text, pointer_event_t* e) {
velocity_t* v = &(rich_text->velocity);
return_value_if_fail(v != NULL, RET_BAD_PARAMS);
velocity_reset(v);
rich_text->ydown = e->y;
rich_text->yoffset_save = rich_text->yoffset;
velocity_update(v, e->e.time, e->x, e->y);
return RET_OK;
}
static ret_t rich_text_on_pointer_move(rich_text_t* rich_text, pointer_event_t* e) {
int32_t dy = 0;
velocity_t* v = NULL;
return_value_if_fail(rich_text != NULL, RET_BAD_PARAMS);
v = &(rich_text->velocity);
dy = e->y - rich_text->ydown;
velocity_update(v, e->e.time, e->x, e->y);
if (rich_text->wa == NULL && dy) {
int32_t yoffset = rich_text->yoffset_save - dy;
widget_set_prop_int(WIDGET(rich_text), WIDGET_PROP_YOFFSET, yoffset);
}
return RET_OK;
}
static ret_t rich_text_on_pointer_up(rich_text_t* rich_text, pointer_event_t* e) {
velocity_t* v = NULL;
int32_t yoffset_end = 0;
widget_t* widget = WIDGET(rich_text);
return_value_if_fail(rich_text != NULL && widget != NULL, RET_BAD_PARAMS);
v = &(rich_text->velocity);
velocity_update(v, e->e.time, e->x, e->y);
yoffset_end = rich_text->yoffset - v->yv;
rich_text_scroll_to(widget, yoffset_end);
return RET_OK;
}
static ret_t rich_text_down(widget_t* widget) {
uint32_t row_height = rich_text_get_row_height(widget);
return rich_text_scroll_delta_to(widget, row_height);
}
static ret_t rich_text_up(widget_t* widget) {
uint32_t row_height = rich_text_get_row_height(widget);
return rich_text_scroll_delta_to(widget, -row_height);
}
static ret_t rich_text_pagedown(widget_t* widget) {
int32_t h = 0;
int32_t pageh = 0;
rich_text_t* rich_text = RICH_TEXT(widget);
uint32_t row_height = rich_text_get_row_height(widget);
return_value_if_fail(rich_text != NULL && widget != NULL, RET_BAD_PARAMS);
h = widget->h - rich_text->margin * 2 - 30;
pageh = tk_max(h, row_height);
return rich_text_scroll_delta_to(widget, pageh);
}
static ret_t rich_text_pageup(widget_t* widget) {
int32_t h = 0;
int32_t pageh = 0;
rich_text_t* rich_text = RICH_TEXT(widget);
uint32_t row_height = rich_text_get_row_height(widget);
return_value_if_fail(rich_text != NULL && widget != NULL, RET_BAD_PARAMS);
h = widget->h - rich_text->margin * 2 - 30;
pageh = tk_max(h, row_height);
return rich_text_scroll_delta_to(widget, -pageh);
}
static ret_t rich_text_on_key_down(widget_t* widget, key_event_t* evt) {
ret_t ret = RET_OK;
return_value_if_fail(evt != NULL, RET_BAD_PARAMS);
if (evt->key == TK_KEY_PAGEDOWN) {
rich_text_pagedown(widget);
ret = RET_STOP;
} else if (evt->key == TK_KEY_PAGEUP) {
rich_text_pageup(widget);
ret = RET_STOP;
} else if (evt->key == TK_KEY_UP) {
rich_text_up(widget);
ret = RET_STOP;
} else if (evt->key == TK_KEY_DOWN) {
rich_text_down(widget);
ret = RET_STOP;
}
return ret;
}
static ret_t rich_text_on_event(widget_t* widget, event_t* e) {
ret_t ret = RET_OK;
uint16_t type = 0;
bool_t yslidable = FALSE;
rich_text_t* rich_text = RICH_TEXT(widget);
bool_t scrollable = rich_text_is_scollable(widget);
return_value_if_fail(rich_text != NULL && e != NULL, RET_BAD_PARAMS);
type = e->type;
yslidable = rich_text->yslidable;
switch (type) {
case EVT_POINTER_DOWN:
rich_text->pressed = TRUE;
if (scrollable && yslidable) {
widget_grab(widget->parent, widget);
rich_text_on_pointer_down(rich_text, (pointer_event_t*)e);
}
break;
case EVT_POINTER_MOVE: {
if (scrollable && yslidable) {
pointer_event_t* evt = (pointer_event_t*)e;
if (evt->pressed && rich_text->pressed) {
rich_text_on_pointer_move(rich_text, evt);
widget_invalidate(widget, NULL);
ret = RET_STOP;
}
}
break;
}
case EVT_POINTER_UP: {
rich_text->pressed = FALSE;
if (scrollable && yslidable) {
rich_text_on_pointer_up(rich_text, (pointer_event_t*)e);
widget_ungrab(widget->parent, widget);
ret = RET_STOP;
}
break;
}
case EVT_WHEEL: {
if (scrollable) {
wheel_event_t* evt = (wheel_event_t*)e;
if (evt->dy < 0) {
rich_text_down(widget);
} else if (evt->dy > 0) {
rich_text_up(widget);
}
ret = RET_STOP;
}
break;
}
case EVT_POINTER_DOWN_ABORT: {
rich_text->pressed = FALSE;
rich_text->yoffset = rich_text->yoffset_save;
break;
}
case EVT_POINTER_LEAVE:
break;
case EVT_POINTER_ENTER:
break;
case EVT_KEY_DOWN: {
if (scrollable) {
ret = rich_text_on_key_down(widget, (key_event_t*)e);
}
break;
}
case EVT_RESIZE:
case EVT_MOVE_RESIZE: {
rich_text->need_reset = TRUE;
break;
}
default:
break;
}
return ret;
}
static ret_t rich_text_set_text_form_value(widget_t* widget, const value_t* v) {
rich_text_t* rich_text = RICH_TEXT(widget);
return_value_if_fail(rich_text != NULL, RET_BAD_PARAMS);
wstr_from_value(&(widget->text), v);
rich_text->need_reset = TRUE;
rich_text->line_gap = 5;
rich_text->margin = 2;
return RET_OK;
}
static ret_t rich_text_set_prop(widget_t* widget, const char* name, const value_t* v) {
rich_text_t* rich_text = RICH_TEXT(widget);
return_value_if_fail(rich_text != NULL && name != NULL && v != NULL, RET_BAD_PARAMS);
if (tk_str_eq(name, WIDGET_PROP_TEXT)) {
return rich_text_set_text_form_value(widget, v);
} else if (tk_str_eq(name, WIDGET_PROP_LINE_GAP)) {
rich_text->line_gap = value_int(v);
rich_text->need_reset = TRUE;
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_MARGIN)) {
rich_text->attribute_margin = value_int(v);
rich_text->need_reset = TRUE;
rich_text_get_margin(widget);
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_YOFFSET)) {
rich_text->yoffset = value_int(v);
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_YSLIDABLE)) {
rich_text->yslidable = value_bool(v);
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_XOFFSET)) {
return RET_OK;
}
return RET_NOT_FOUND;
}
static ret_t rich_text_get_prop(widget_t* widget, const char* name, value_t* v) {
rich_text_t* rich_text = RICH_TEXT(widget);
return_value_if_fail(rich_text != NULL && name != NULL && v != NULL, RET_BAD_PARAMS);
if (tk_str_eq(name, WIDGET_PROP_LINE_GAP)) {
value_set_int(v, rich_text->line_gap);
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_MARGIN)) {
rich_text_get_margin(widget);
value_set_int(v, rich_text->margin);
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_YOFFSET)) {
value_set_int(v, rich_text->yoffset);
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_XOFFSET)) {
value_set_int(v, 0);
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_VIRTUAL_H)) {
value_set_int(v, rich_text->content_h + 2 * rich_text->margin);
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_YSLIDABLE)) {
value_set_bool(v, rich_text->yslidable);
return RET_OK;
}
return RET_NOT_FOUND;
}
static ret_t rich_text_on_destroy(widget_t* widget) {
return rich_text_reset(widget);
}
ret_t rich_text_set_yslidable(widget_t* widget, bool_t yslidable) {
rich_text_t* rich_text = RICH_TEXT(widget);
return_value_if_fail(rich_text != NULL, RET_FAIL);
rich_text->yslidable = yslidable;
return RET_OK;
}
static ret_t rich_text_init(widget_t* widget) {
rich_text_t* rich_text = RICH_TEXT(widget);
return_value_if_fail(rich_text != NULL, RET_BAD_PARAMS);
rich_text->yslidable = TRUE;
return RET_OK;
}
static const char* s_rich_text_clone_properties[] = {WIDGET_PROP_MARGIN, WIDGET_PROP_LINE_GAP,
NULL};
TK_DECL_VTABLE(rich_text) = {.size = sizeof(rich_text_t),
.type = "rich_text",
.get_parent_vt = TK_GET_PARENT_VTABLE(widget),
.create = rich_text_create,
.init = rich_text_init,
.clone_properties = s_rich_text_clone_properties,
.on_event = rich_text_on_event,
.set_prop = rich_text_set_prop,
.get_prop = rich_text_get_prop,
.on_destroy = rich_text_on_destroy,
.on_paint_self = rich_text_on_paint_self};
widget_t* rich_text_create(widget_t* parent, xy_t x, xy_t y, wh_t w, wh_t h) {
widget_t* widget = widget_create(parent, TK_REF_VTABLE(rich_text), x, y, w, h);
return_value_if_fail(rich_text_init(widget) == RET_OK, NULL);
return widget;
}
ret_t rich_text_set_text(widget_t* widget, const char* text) {
wstr_t str;
wstr_init(&str, 0);
rich_text_t* rich_text = RICH_TEXT(widget);
return_value_if_fail(rich_text != NULL, RET_BAD_PARAMS);
return_value_if_fail(wstr_set_utf8(&str, text) == RET_OK, RET_BAD_PARAMS);
wstr_set_utf8(&(widget->text), text);
rich_text->need_reset = TRUE;
rich_text->line_gap = 5;
rich_text->margin = 2;
wstr_reset(&str);
return RET_OK;
}
widget_t* rich_text_cast(widget_t* widget) {
return_value_if_fail(WIDGET_IS_INSTANCE_OF(widget, rich_text), NULL);
return widget;
}
|
0 |
repos/awtk/src/ext_widgets
|
repos/awtk/src/ext_widgets/rich_text/rich_text_node.h
|
/**
* File: rich_text_node.h
* Author: AWTK Develop Team
* Brief: rich_text_node
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is dirich_text_nodeibuted in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-07-27 Li XianJing <[email protected]> created
*
*/
#ifndef TK_RICH_TEXT_NODE_H
#define TK_RICH_TEXT_NODE_H
#include "tkc/color.h"
#include "base/bitmap.h"
BEGIN_C_DECLS
typedef struct _rich_text_font_t {
char* name;
color_t color;
align_v_t align_v;
uint16_t size;
uint16_t bold : 1;
uint16_t italic : 1;
uint16_t underline : 1;
} rich_text_font_t;
typedef struct _rich_text_image_t {
char* name;
uint32_t w;
uint32_t h;
image_draw_type_t draw_type;
} rich_text_image_t;
typedef struct _rich_text_text_t {
wchar_t* text;
rich_text_font_t font;
} rich_text_text_t;
typedef enum _rich_text_node_type_t {
RICH_TEXT_TEXT = 0,
RICH_TEXT_IMAGE = 1
} rich_text_node_type_t;
typedef struct _rich_text_node_t {
rich_text_node_type_t type;
union {
rich_text_text_t text;
rich_text_image_t image;
} u;
struct _rich_text_node_t* next;
} rich_text_node_t;
rich_text_node_t* rich_text_text_create(rich_text_font_t* font, const char* text);
rich_text_node_t* rich_text_text_create_with_len(rich_text_font_t* font, const char* text,
uint32_t len);
rich_text_node_t* rich_text_image_create(const char* name, uint32_t w, uint32_t h,
uint32_t draw_type);
rich_text_node_t* rich_text_node_append(rich_text_node_t* node, rich_text_node_t* next);
int32_t rich_text_node_count(rich_text_node_t* node);
ret_t rich_text_text_destroy(rich_text_node_t* node);
ret_t rich_text_image_destroy(rich_text_node_t* node);
ret_t rich_text_node_destroy(rich_text_node_t* node);
END_C_DECLS
#endif /*TK_RICH_TEXT_NODE_H*/
|
0 |
repos/awtk/src/ext_widgets
|
repos/awtk/src/ext_widgets/rich_text/rich_text_render_node.c
|
/**
* File: rich_text_render_node.c
* Author: AWTK Develop Team
* Brief: rich_text_render_node
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is dirich_text_render_nodeibuted in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-07-28 Li XianJing <[email protected]> created
*
*/
#include "tkc/mem.h"
#include "base/line_break.h"
#include "base/image_manager.h"
#include "rich_text/rich_text.h"
#include "rich_text/rich_text_render_node.h"
#define ICON_SIZE 128
rich_text_render_node_t* rich_text_render_node_create(rich_text_node_t* node) {
rich_text_render_node_t* render_node = NULL;
return_value_if_fail(node != NULL, NULL);
render_node = TKMEM_ZALLOC(rich_text_render_node_t);
return_value_if_fail(render_node != NULL, NULL);
render_node->node = node;
return render_node;
}
static const wchar_t* s_flexable_w_chars = L" ,.?!;:>}] ，。？！；：》｝】』";
bool_t rich_text_is_flexable_w_char(wchar_t c) {
return wcschr(s_flexable_w_chars, c) != NULL;
}
ret_t rich_text_render_node_tune_row(rich_text_render_node_t* row_first_node, int32_t row_h,
int32_t flexible_w, int32_t client_w) {
int32_t dx = 0;
int32_t flexible_w_chars = 0;
int32_t flexible_w_chars_w = 0;
int32_t align_h_w = flexible_w > 0 ? 0 : client_w;
rich_text_render_node_t* iter = row_first_node;
while (iter != NULL) {
if (flexible_w > 0) {
if (iter->node->type == RICH_TEXT_TEXT) {
int32_t i = 0;
for (i = 0; i < iter->size; i++) {
if (rich_text_is_flexable_w_char(iter->text[i])) {
iter->flexible_w_chars++;
flexible_w_chars++;
}
}
}
} else {
align_h_w -= iter->rect.w;
}
iter = iter->next;
}
if (flexible_w_chars > 0) {
flexible_w_chars_w = tk_max(1, (flexible_w / flexible_w_chars));
} else {
flexible_w_chars_w = 0;
}
iter = row_first_node;
while (iter != NULL) {
iter->align_h_w = align_h_w;
iter->rect.h = row_h;
iter->rect.x += dx;
switch (iter->node->type) {
case RICH_TEXT_TEXT: {
if (flexible_w > 0) {
int32_t spacing = iter->flexible_w_chars * flexible_w_chars_w;
iter->spacing = tk_min(spacing, flexible_w);
iter->flexible_w_char_delta_w = flexible_w_chars_w;
flexible_w -= iter->spacing;
dx += iter->spacing;
}
break;
}
case RICH_TEXT_IMAGE: {
break;
}
default:
break;
}
iter = iter->next;
}
return RET_OK;
}
#define MOVE_TO_NEXT_ROW() \
x = margin; \
y += row_h + line_gap; \
if (row_first_node != NULL) { \
rich_text_render_node_tune_row(row_first_node, row_h, flexible_w, client_w); \
row_first_node = NULL; \
} \
row_h = 0;
break_type_t rich_text_line_break_check(wchar_t c1, wchar_t c2) {
break_type_t break_type = line_break_check(c1, c2);
if (break_type == LINE_BREAK_NO) {
break_type = word_break_check(c1, c2);
}
return break_type;
}
rich_text_render_node_t* rich_text_render_node_layout(widget_t* widget, rich_text_node_t* node,
canvas_t* c, int32_t w, int32_t h,
int32_t margin, int32_t line_gap) {
int32_t row_h = 0;
int32_t x = margin;
int32_t y = margin;
int32_t right = w - margin;
int32_t client_w = w - 2 * margin;
int32_t client_h = h - 2 * margin;
rich_text_node_t* iter = node;
rich_text_t* rich_text = RICH_TEXT(widget);
rich_text_render_node_t* new_node = NULL;
rich_text_render_node_t* render_node = NULL;
rich_text_render_node_t* row_first_node = NULL;
return_value_if_fail(node != NULL && c != NULL && client_w > 0 && client_h > 0, NULL);
while (iter != NULL) {
switch (iter->type) {
case RICH_TEXT_IMAGE: {
bitmap_t bitmap;
int32_t flexible_w = 0;
rich_text_image_t* image = &(iter->u.image);
const char* name = image->name;
new_node = rich_text_render_node_create(iter);
return_value_if_fail(new_node != NULL, render_node);
if (widget_load_image(widget, name, &bitmap) == RET_OK) {
if (image->w == 0) {
image->w = bitmap.w;
}
if (image->h == 0) {
image->h = bitmap.h;
}
}
if (x > margin && (image->w > ICON_SIZE || x + image->w > right)) {
MOVE_TO_NEXT_ROW();
}
new_node->rect.x = x;
new_node->rect.y = y;
new_node->rect.w = image->w;
new_node->rect.h = image->h;
if (image->w > ICON_SIZE) {
new_node->rect.w = client_w;
}
if (row_h < image->h) {
row_h = image->h;
}
render_node = rich_text_render_node_append(render_node, new_node);
if (x + image->w >= right) {
MOVE_TO_NEXT_ROW();
} else {
if (row_first_node == NULL) {
row_first_node = new_node;
}
x += new_node->rect.w + 1;
}
rich_text->content_h = new_node->rect.y + new_node->rect.h;
break;
}
case RICH_TEXT_TEXT: {
int32_t i = 0;
float_t tw = 0;
float_t cw = 0;
int32_t start = 0;
int32_t flexible_w = 0;
int32_t last_breakable = 0;
wchar_t* str = iter->u.text.text;
break_type_t break_type = LINE_BREAK_ALLOW;
int32_t font_size = iter->u.text.font.size;
if (row_h < font_size) {
row_h = font_size;
}
canvas_set_font(c, iter->u.text.font.name, font_size);
for (i = 0; str[i]; i++) {
cw = canvas_measure_text(c, str + i, 1);
if (i > 0) {
break_type = rich_text_line_break_check(str[i - 1], str[i]);
}
if (str[i] == '\r' || str[i] == '\n') {
break_type = LINE_BREAK_MUST;
}
if ((x + tw + cw) > right || break_type == LINE_BREAK_MUST) {
if (break_type != LINE_BREAK_MUST) {
if (last_breakable > start) {
if (i != last_breakable + 1 || break_type != LINE_BREAK_ALLOW) {
tw -= canvas_measure_text(c, str + last_breakable, i - last_breakable);
i = last_breakable;
}
}
if (x == margin) {
// 一行的起始不需要换行，且最少包含一个字符
if (i == start) {
i = start + 1;
}
} else if (start == 0 && last_breakable == 0) {
// 不是起始，换行,重新计算
MOVE_TO_NEXT_ROW();
row_h = font_size;
--i;
continue;
}
}
new_node = rich_text_render_node_create(iter);
return_value_if_fail(new_node != NULL, render_node);
new_node->text = str + start;
new_node->size = i - start;
new_node->rect = rect_init(x, y, tw, font_size);
render_node = rich_text_render_node_append(render_node, new_node);
if (row_first_node == NULL) {
row_first_node = new_node;
}
if (break_type == LINE_BREAK_MUST) {
++i;
if (str[i - 1] == '\r' && str[i] == '\n') ++i;
} else {
if (str[i] == ' ' || str[i] == '\t') {
i++;
}
}
MOVE_TO_NEXT_ROW();
row_h = font_size;
while (str[i] == '\r' || str[i] == '\n') {
if (str[i] == '\r' && str[i + 1] == '\n') {
++i;
}
MOVE_TO_NEXT_ROW();
row_h = font_size;
++i;
}
start = i;
if (!str[i]) break;
last_breakable = i;
tw = canvas_measure_text(c, str + i, 1);
} else {
if (i > 0) {
if (rich_text_line_break_check(str[i - 1], str[i]) == LINE_BREAK_ALLOW) {
last_breakable = i;
}
}
tw += cw;
}
}
if (i > start) {
new_node = rich_text_render_node_create(iter);
return_value_if_fail(new_node != NULL, render_node);
new_node->text = str + start;
new_node->size = i - start;
new_node->rect = rect_init(x, y, tw, font_size);
x += tw + 1;
tw = 0;
render_node = rich_text_render_node_append(render_node, new_node);
if (row_first_node == NULL) {
row_first_node = new_node;
}
}
rich_text->content_h = new_node->rect.y + new_node->rect.h;
break;
}
default:
break;
}
iter = iter->next;
}
if (row_first_node != NULL) {
rich_text_render_node_tune_row(row_first_node, row_h, 0, client_w);
}
return render_node;
}
rich_text_render_node_t* rich_text_render_node_append(rich_text_render_node_t* node,
rich_text_render_node_t* next) {
rich_text_render_node_t* iter = node;
return_value_if_fail(next != NULL, node);
if (node == NULL) {
return next;
}
while (iter->next != NULL) {
iter = iter->next;
}
iter->next = next;
return node;
}
int32_t rich_text_render_node_count(rich_text_render_node_t* node) {
int32_t nr = 0;
rich_text_render_node_t* iter = node;
return_value_if_fail(node != NULL, RET_BAD_PARAMS);
while (iter != NULL) {
nr++;
iter = iter->next;
}
return nr;
}
ret_t rich_text_render_node_destroy(rich_text_render_node_t* node) {
rich_text_render_node_t* iter = node;
rich_text_render_node_t* next = node;
return_value_if_fail(node != NULL, RET_BAD_PARAMS);
while (iter != NULL) {
next = iter->next;
memset(iter, 0x00, sizeof(rich_text_render_node_t));
TKMEM_FREE(iter);
iter = next;
}
return RET_OK;
}
|
0 |
repos/awtk/src/ext_widgets
|
repos/awtk/src/ext_widgets/rich_text/rich_text_parser.c
|
/**
* File: rich_text_parser.c
* Author: AWTK Develop Team
* Brief: rich_text_parser
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is dirich_text_parseributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-07-27 Li XianJing <[email protected]> created
*
*/
#include "tkc/mem.h"
#include "tkc/str.h"
#include "tkc/utils.h"
#include "base/enums.h"
#include "base/bitmap.h"
#include "xml/xml_parser.h"
#include "tkc/color_parser.h"
#include "rich_text/rich_text_node.h"
#include "rich_text/rich_text_parser.h"
#define MAX_FONT_LEVEL 8
typedef struct _xml_builder_t {
XmlBuilder builder;
int32_t font_level;
rich_text_font_t fonts[MAX_FONT_LEVEL];
rich_text_font_t* font;
rich_text_node_t* node;
str_t temp;
} xml_builder_t;
static void xml_rich_text_push_font(xml_builder_t* b) {
b->font_level++;
b->fonts[b->font_level] = b->fonts[b->font_level - 1];
b->font = b->fonts + b->font_level;
if (b->font->name != NULL) {
b->font->name = tk_strdup(b->font->name);
}
}
static void xml_rich_text_pop_font(xml_builder_t* b) {
rich_text_font_t* font = b->fonts + b->font_level;
if (font->name != NULL) {
TKMEM_FREE(font->name);
font->name = NULL;
}
b->font_level--;
b->font = b->fonts + b->font_level;
}
static void xml_rich_text_on_start(XmlBuilder* thiz, const char* tag, const char** attrs) {
int32_t i = 0;
xml_builder_t* b = (xml_builder_t*)thiz;
if (tk_str_eq(tag, "font")) {
xml_rich_text_push_font(b);
b->font->align_v = ALIGN_V_BOTTOM;
while (attrs[i]) {
const char* key = attrs[i];
const char* value = attrs[i + 1];
if (tk_str_eq(key, "size")) {
b->font->size = tk_atoi(value);
} else if (tk_str_eq(key, "color")) {
b->font->color = color_parse(value);
} else if (tk_str_eq(key, "align_v")) {
const key_type_value_t* kv = align_v_type_find(value);
if (kv != NULL) {
b->font->align_v = (align_v_t)(kv->value);
}
} else if (tk_str_eq(key, "name")) {
TKMEM_FREE(b->font->name);
b->font->name = tk_strdup(value);
}
i += 2;
}
} else if (tk_str_eq(tag, "b")) {
xml_rich_text_push_font(b);
b->font->bold = TRUE;
} else if (tk_str_eq(tag, "i")) {
xml_rich_text_push_font(b);
b->font->italic = TRUE;
} else if (tk_str_eq(tag, "u")) {
xml_rich_text_push_font(b);
b->font->underline = TRUE;
} else if (tk_str_eq(tag, "image")) {
int32_t w = 0;
int32_t h = 0;
int32_t draw_type = IMAGE_DRAW_CENTER;
const char* image_name = NULL;
while (attrs[i]) {
const char* key = attrs[i];
const char* value = attrs[i + 1];
if (tk_str_eq(key, "name")) {
image_name = value;
} else if (tk_str_eq(key, "w")) {
w = tk_atoi(value);
} else if (tk_str_eq(key, "h")) {
h = tk_atoi(value);
} else if (tk_str_eq(key, "draw_type")) {
const key_type_value_t* kv = image_draw_type_find(value);
if (kv != NULL) {
draw_type = kv->value;
}
}
i += 2;
}
if (image_name != NULL) {
b->node = rich_text_node_append(b->node, rich_text_image_create(image_name, w, h, draw_type));
}
}
return;
}
static void xml_rich_text_on_end(XmlBuilder* thiz, const char* tag) {
xml_builder_t* b = (xml_builder_t*)thiz;
if (tk_str_eq(tag, "font") || tk_str_eq(tag, "b") || tk_str_eq(tag, "i") || tk_str_eq(tag, "u")) {
xml_rich_text_pop_font(b);
}
return;
}
static void xml_rich_text_on_text(XmlBuilder* thiz, const char* text, size_t length) {
xml_builder_t* b = (xml_builder_t*)thiz;
rich_text_font_t* font = b->font;
str_decode_xml_entity_with_len(&(b->temp), text, length);
b->node = rich_text_node_append(b->node, rich_text_text_create(font, b->temp.str));
return;
}
static void xml_rich_text_on_error(XmlBuilder* thiz, int line, int row, const char* message) {
(void)thiz;
log_debug("parse error: %d:%d %s\n", line, row, message);
return;
}
static void xml_rich_text_destroy(XmlBuilder* thiz) {
xml_builder_t* b = (xml_builder_t*)thiz;
str_reset(&(b->temp));
return;
}
static XmlBuilder* builder_init(xml_builder_t* b, const char* font_name, uint16_t font_size,
color_t color, align_v_t align_v) {
int32_t i = 0;
memset(b, 0x00, sizeof(xml_builder_t));
b->builder.on_start = xml_rich_text_on_start;
b->builder.on_end = xml_rich_text_on_end;
b->builder.on_text = xml_rich_text_on_text;
b->builder.on_error = xml_rich_text_on_error;
b->builder.destroy = xml_rich_text_destroy;
b->font = b->fonts;
for (i = 0; i < MAX_FONT_LEVEL; i++) {
rich_text_font_t* iter = b->fonts + i;
iter->size = font_size;
iter->color = color;
iter->align_v = align_v;
iter->name = font_name == NULL ? NULL : tk_strdup(font_name);
}
str_init(&(b->temp), 100);
return &(b->builder);
}
rich_text_node_t* rich_text_parse(const char* str, uint32_t size, const char* font_name,
uint16_t font_size, color_t color, align_v_t align_v) {
xml_builder_t b;
XmlParser* parser = NULL;
rich_text_node_t* node = NULL;
return_value_if_fail(str != NULL, NULL);
parser = xml_parser_create();
xml_parser_set_builder(parser, builder_init(&b, font_name, font_size, color, align_v));
xml_parser_set_trim_text(parser, FALSE);
xml_parser_parse(parser, str, size);
node = b.node;
xml_parser_destroy(parser);
xml_builder_destroy(&(b.builder));
return node;
}
|
0 |
repos/awtk/src/ext_widgets
|
repos/awtk/src/ext_widgets/rich_text/rich_text_view.c
|
/**
* File: rich_text_view.h
* Author: AWTK Develop Team
* Brief: rich_text_view
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-04-05 Li XianJing <[email protected]> created
*
*/
#include "tkc/mem.h"
#include "tkc/utils.h"
#include "scroll_view/scroll_bar.h"
#include "rich_text/rich_text.h"
#include "rich_text/rich_text_view.h"
static ret_t rich_text_view_sync_scroll_bar_to_rich_text(widget_t* widget) {
int32_t yoffset = 0;
rich_text_t* rich_text = NULL;
rich_text_view_t* rich_text_view = RICH_TEXT_VIEW(widget);
return_value_if_fail(rich_text_view != NULL, RET_BAD_PARAMS);
rich_text = RICH_TEXT(rich_text_view->rich_text);
yoffset = widget_get_value(rich_text_view->scroll_bar);
if (rich_text != NULL) {
emitter_disable(rich_text_view->rich_text->emitter);
widget_set_prop_int(rich_text_view->rich_text, WIDGET_PROP_YOFFSET, yoffset);
emitter_enable(rich_text_view->rich_text->emitter);
}
return RET_OK;
}
static ret_t rich_text_view_on_scroll_bar_changed(void* ctx, event_t* e) {
rich_text_view_sync_scroll_bar_to_rich_text(WIDGET(ctx));
return RET_OK;
}
static ret_t rich_text_view_sync_rich_text_to_scroll_bar(widget_t* widget) {
int32_t h = 0;
int32_t max = 0;
int32_t value = 0;
int32_t yoffset = 0;
int32_t virtual_h = 0;
rich_text_view_t* rich_text_view = RICH_TEXT_VIEW(widget);
return_value_if_fail(rich_text_view != NULL, RET_BAD_PARAMS);
yoffset = widget_get_prop_int(rich_text_view->rich_text, WIDGET_PROP_YOFFSET, 0);
virtual_h = widget_get_prop_int(rich_text_view->rich_text, WIDGET_PROP_VIRTUAL_H, 0);
h = rich_text_view->rich_text->h;
max = tk_max(virtual_h, h);
if (max > h) {
value = (yoffset * max) / (max - h);
}
if (rich_text_view->scroll_bar != NULL) {
emitter_disable(rich_text_view->scroll_bar->emitter);
widget_set_prop_int(rich_text_view->scroll_bar, WIDGET_PROP_MAX, tk_max(0, max - h));
widget_set_prop_int(rich_text_view->scroll_bar, WIDGET_PROP_VALUE, tk_max(0, value));
emitter_enable(rich_text_view->scroll_bar->emitter);
widget_layout(widget);
}
return RET_OK;
}
static ret_t rich_text_view_on_rich_text_scrolled(void* ctx, event_t* e) {
prop_change_event_t* evt = (prop_change_event_t*)e;
return_value_if_fail(evt != NULL, RET_BAD_PARAMS);
if (tk_str_eq(evt->name, WIDGET_PROP_YOFFSET)) {
rich_text_view_sync_rich_text_to_scroll_bar(WIDGET(ctx));
}
return RET_OK;
}
static ret_t rich_text_view_on_add_child(widget_t* widget, widget_t* child) {
rich_text_view_t* rich_text_view = RICH_TEXT_VIEW(widget);
return_value_if_fail(rich_text_view != NULL, RET_BAD_PARAMS);
if (tk_str_eq(widget_get_type(child), WIDGET_TYPE_RICH_TEXT)) {
rich_text_view->rich_text = child;
widget_on(child, EVT_PROP_CHANGED, rich_text_view_on_rich_text_scrolled, widget);
} else if (tk_str_eq(widget_get_type(child), WIDGET_TYPE_SCROLL_BAR) ||
tk_str_eq(widget_get_type(child), WIDGET_TYPE_SCROLL_BAR_DESKTOP) ||
tk_str_eq(widget_get_type(child), WIDGET_TYPE_SCROLL_BAR_MOBILE)) {
rich_text_view->scroll_bar = child;
widget_on(child, EVT_VALUE_CHANGED, rich_text_view_on_scroll_bar_changed, widget);
}
return RET_FAIL;
}
static ret_t rich_text_view_on_remove_child(widget_t* widget, widget_t* child) {
rich_text_view_t* rich_text_view = RICH_TEXT_VIEW(widget);
return_value_if_fail(rich_text_view != NULL, RET_BAD_PARAMS);
widget_off_by_ctx(child, widget);
if (rich_text_view->rich_text == child) {
rich_text_view->rich_text = NULL;
}
if (rich_text_view->scroll_bar == child) {
rich_text_view->scroll_bar = NULL;
}
return RET_FAIL;
}
TK_DECL_VTABLE(rich_text_view) = {.size = sizeof(rich_text_view_t),
.type = WIDGET_TYPE_RICH_TEXT_VIEW,
.get_parent_vt = TK_GET_PARENT_VTABLE(widget),
.on_add_child = rich_text_view_on_add_child,
.on_remove_child = rich_text_view_on_remove_child,
.create = rich_text_view_create};
widget_t* rich_text_view_create(widget_t* parent, xy_t x, xy_t y, wh_t w, wh_t h) {
return widget_create(parent, TK_REF_VTABLE(rich_text_view), x, y, w, h);
}
widget_t* rich_text_view_cast(widget_t* widget) {
return_value_if_fail(WIDGET_IS_INSTANCE_OF(widget, rich_text_view), NULL);
return widget;
}
|
0 |
repos/awtk/src/ext_widgets
|
repos/awtk/src/ext_widgets/rich_text/rich_text_render_node.h
|
/**
* File: rich_text_render_node.h
* Author: AWTK Develop Team
* Brief: rich_text_render_node
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is dirich_text_render_nodeibuted in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-07-28 Li XianJing <[email protected]> created
*
*/
#ifndef TK_RICH_TEXT_RENDER_NODE_H
#define TK_RICH_TEXT_RENDER_NODE_H
#include "base/widget.h"
#include "rich_text/rich_text_node.h"
BEGIN_C_DECLS
/*
* 表示一个渲染节点。
* 对于文本节点，当一行显示不下一个rich_text_node_t时，rich_text_node_t被拆分成多个rich_text_render_node_t。
* 在排版进行自动换行时，右边可能会有多余的空间，为了让整行排满，我们需要把多余的空间分散开。具体做法是：
*
* 把多余的空间均匀的加到弹性宽度字符(flexible_w_char)的宽度中。
*
*/
typedef struct _rich_text_render_node_t {
rich_text_node_t* node;
/*该节点显示的区域*/
rect_t rect;
/*文本节点的文本*/
wchar_t* text;
/*文本节点的文本的长度*/
uint16_t size;
/*该行剩余空间水平对齐使用*/
int16_t align_h_w;
/*该结点总共需要承担的多余空间*/
uint16_t spacing;
/*该结点中存在的弹性宽度字符个数*/
uint8_t flexible_w_chars;
/*每个弹性宽度字符应该承担的多余空间*/
uint8_t flexible_w_char_delta_w;
struct _rich_text_render_node_t* next;
} rich_text_render_node_t;
bool_t rich_text_is_flexable_w_char(wchar_t c);
rich_text_render_node_t* rich_text_render_node_layout(widget_t* widget, rich_text_node_t* node,
canvas_t* c, int32_t w, int32_t h,
int32_t margin, int32_t line_gap);
rich_text_render_node_t* rich_text_render_node_append(rich_text_render_node_t* node,
rich_text_render_node_t* next);
int32_t rich_text_render_node_count(rich_text_render_node_t* render_node);
ret_t rich_text_render_node_destroy(rich_text_render_node_t* render_node);
/*public for test*/
rich_text_render_node_t* rich_text_render_node_create(rich_text_node_t* node);
END_C_DECLS
#endif /*TK_RICH_TEXT_RENDER_NODE_H*/
|
0 |
repos/awtk/src/ext_widgets
|
repos/awtk/src/ext_widgets/slide_menu/slide_menu.h
|
/**
* File: slide_menu.h
* Author: AWTK Develop Team
* Brief: slide_menu
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-12-08 Li XianJing <[email protected]> created
*
*/
#ifndef TK_SLIDE_MENU_H
#define TK_SLIDE_MENU_H
#include "base/widget.h"
#include "base/velocity.h"
#include "base/widget_animator.h"
BEGIN_C_DECLS
/**
* @class slide_menu_t
* @parent widget_t
* @annotation ["scriptable","design","widget"]
* 左右滑动菜单控件。
*
* 一般用一组按钮作为子控件，通过左右滑动改变当前的项。除了当菜单使用外，也可以用来切换页面。
*
* slide\_menu\_t是[widget\_t](widget_t.md)的子类控件，widget\_t的函数均适用于slide\_menu\_t控件。
*
* 在xml中使用"slide\_menu"标签创建左右滑动菜单控件。如：
*
* ```xml
* <slide_menu style="mask" align_v="top">
* <button style="slide_button" text="0"/>
* <button style="slide_button" text="1"/>
* <button style="slide_button" text="2"/>
* <button style="slide_button" text="3"/>
* <button style="slide_button" text="4"/>
* </slide_menu>
* ```
*
* > 更多用法请参考：[slide_menu.xml](
* https://github.com/zlgopen/awtk/blob/master/design/default/ui/slide_menu.xml)
*
* 在c代码中使用函数slide\_menu\_create创建左右滑动菜单控件。如：
*
* ```c
* slide_menu = slide_menu_create(win, 10, 10, 300, 60);
* b = button_create(slide_menu, 0, 0, 0, 0);
* widget_set_text_utf8(b, "1");
* b = button_create(slide_menu, 0, 0, 0, 0);
* widget_set_text_utf8(b, "2");
* b = button_create(slide_menu, 0, 0, 0, 0);
* widget_set_text_utf8(b, "3");
* b = button_create(slide_menu, 0, 0, 0, 0);
* widget_set_text_utf8(b, "4");
* ```
*
* 可按下面的方法关注当前项改变的事件：
*
* ```c
* widget_on(slide_menu, EVT_VALUE_CHANGED, on_current_changed, slide_menu);
* ```
*
* 可按下面的方法关注当前按钮被点击的事件：
*
* ```c
* widget_on(b, EVT_CLICK, on_button_click, b);
* ```
*
* > 完整示例请参考：[slide_menu demo](
* https://github.com/zlgopen/awtk-c-demos/blob/master/demos/slide_menu.c)
*
* 可用通过style来设置控件的显示风格，如背景颜色和蒙版颜色等等。如：
*
* ```xml
* <style name="mask">
* <normal bg_color="#f0f0f0" mask_color="#f0f0f0"/>
* </style>
* ```
*
* > 更多用法请参考：[theme default](
* https://github.com/zlgopen/awtk/blob/master/design/default/styles/default.xml#L493)
*
*/
typedef struct _slide_menu_t {
widget_t widget;
/**
* @property {int32_t} value
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 值。代表当前选中项的索引。
*/
int32_t value;
/**
* @property {align_v_t} align_v
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 垂直对齐方式。
*/
align_v_t align_v;
/**
* @property {float_t} min_scale
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 最小缩放比例。
*/
float_t min_scale;
/**
* @property {int32_t} spacer
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 菜单项之间的间距。
*/
int32_t spacer;
/**
* @property {char*} menu_w
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 菜单项的宽度(后面加上px为像素点，不加px为相对百分比坐标0.0f到1.0f)(空字符串则使用控件高度)。
*/
char* menu_w;
/**
* @property {bool_t} clip
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 是否动态裁剪菜单项(默认裁剪，不裁剪时，如果显示偶数项，左边会多一项)。
*/
bool_t clip;
/*private*/
int32_t xdown;
int32_t xoffset;
bool_t dragged;
bool_t pressed;
bool_t is_activated;
velocity_t velocity;
widget_animator_t* wa;
} slide_menu_t;
/**
* @event {value_change_event_t} EVT_VALUE_WILL_CHANGE
* 值(当前项)即将改变事件。
*/
/**
* @event {value_change_event_t} EVT_VALUE_CHANGED
* 值(当前项)改变事件。
*/
/**
* @method slide_menu_create
* 创建slide_menu对象
* @annotation ["constructor", "scriptable"]
* @param {widget_t*} parent 父控件
* @param {xy_t} x x坐标
* @param {xy_t} y y坐标
* @param {wh_t} w 宽度
* @param {wh_t} h 高度
*
* @return {widget_t*} 对象。
*/
widget_t* slide_menu_create(widget_t* parent, xy_t x, xy_t y, wh_t w, wh_t h);
/**
* @method slide_menu_cast
* 转换slide_menu对象(供脚本语言使用)。
* @annotation ["cast", "scriptable"]
* @param {widget_t*} widget slide_menu对象。
*
* @return {widget_t*} slide_menu对象。
*/
widget_t* slide_menu_cast(widget_t* widget);
/**
* @method slide_menu_set_value
* 设置当前项。
* @annotation ["scriptable"]
* @param {widget_t*} widget slide_menu对象。
* @param {uint32_t} value 当前项的索引。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t slide_menu_set_value(widget_t* widget, uint32_t value);
/**
* @method slide_menu_set_align_v
* 设置垂直对齐方式。
* @annotation ["scriptable"]
* @param {widget_t*} widget slide_menu对象。
* @param {align_v_t} align_v 对齐方式。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t slide_menu_set_align_v(widget_t* widget, align_v_t align_v);
/**
* @method slide_menu_set_min_scale
* 设置最小缩放比例。
* @annotation ["scriptable"]
* @param {widget_t*} widget slide_menu对象。
* @param {float_t} min_scale 最小缩放比例，范围[0.5-1]。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t slide_menu_set_min_scale(widget_t* widget, float_t min_scale);
/**
* @method slide_menu_set_spacer
* 设置菜单项之间的间距。
* @annotation ["scriptable"]
* @param {widget_t*} widget slide_menu对象。
* @param {int32_t} spacer 菜单项之间的间距。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t slide_menu_set_spacer(widget_t* widget, int32_t spacer);
/**
* @method slide_menu_set_menu_w
* 设置菜单项的宽度。
* @annotation ["scriptable"]
* @param {widget_t*} widget slide_menu对象。
* @param {const char*} menu_w 菜单项的宽度。(后面加上px为像素点，不加px为相对百分比坐标0.0f到1.0f)(空字符串则使用控件高度)
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t slide_menu_set_menu_w(widget_t* widget, const char* menu_w);
/**
* @method slide_menu_set_clip
* 设置是否动态裁剪菜单项。
* @annotation ["scriptable"]
* @param {widget_t*} widget slide_menu对象。
* @param {bool_t} clip 是否动态裁剪菜单项。(关闭后，如果显示偶数项，左边会多一项)
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t slide_menu_set_clip(widget_t* widget, bool_t clip);
/**
* @method slide_menu_scroll_to_prev
* 切换至上一项。
* @annotation ["scriptable"]
* @param {widget_t*} widget slide_menu对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t slide_menu_scroll_to_prev(widget_t* widget);
/**
* @method slide_menu_scroll_to_next
* 切换至下一项。
* @annotation ["scriptable"]
* @param {widget_t*} widget slide_menu对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t slide_menu_scroll_to_next(widget_t* widget);
#define SLIDE_MENU_PROP_MIN_SCALE "min_scale"
#define SLIDE_MENU_PROP_SPACER "spacer"
#define SLIDE_MENU_PROP_MENU_W "menu_w"
#define SLIDE_MENU_PROP_CLIP "clip"
#define WIDGET_TYPE_SLIDE_MENU "slide_menu"
#define SLIDE_MENU(widget) ((slide_menu_t*)(slide_menu_cast(WIDGET(widget))))
/*public for subclass and runtime type check*/
TK_EXTERN_VTABLE(slide_menu);
/*public for test*/
int32_t slide_menu_fix_index(widget_t* widget, int32_t index);
END_C_DECLS
#endif /*TK_SLIDE_MENU_H*/
|
0 |
repos/awtk/src/ext_widgets
|
repos/awtk/src/ext_widgets/slide_menu/slide_menu.c
|
/**
* File: slide_menu.h
* Author: AWTK Develop Team
* Brief: slide_menu
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-12-04 Li XianJing <[email protected]> created
*
*/
#include "tkc/mem.h"
#include "base/enums.h"
#include "tkc/utils.h"
#include "widgets/button.h"
#include "base/layout.h"
#include "base/widget_vtable.h"
#include "slide_menu/slide_menu.h"
#include "widget_animators/widget_animator_scroll.h"
#define MAX_VISIBLE_NR 10
#ifndef SLIDE_MENU_MIN_SCALE
#define SLIDE_MENU_MIN_SCALE 0.5f
#endif
static uint32_t slide_menu_get_visible_children(widget_t* widget,
widget_t* children[MAX_VISIBLE_NR]);
static int32_t slide_menu_get_menu_w(slide_menu_t* slide_menu) {
if (TK_STR_IS_EMPTY(slide_menu->menu_w)) {
return slide_menu->widget.h;
} else {
return tk_eval_ratio_or_px(slide_menu->menu_w, slide_menu->widget.w);
}
}
static ret_t slide_menu_set_xoffset(slide_menu_t* slide_menu, int32_t xoffset) {
if (slide_menu->xoffset != xoffset) {
slide_menu->xoffset = xoffset;
widget_layout_children(WIDGET(slide_menu));
widget_invalidate(WIDGET(slide_menu), NULL);
}
return RET_OK;
}
int32_t slide_menu_fix_index(widget_t* widget, int32_t index) {
uint32_t nr = widget_count_children(widget);
while (index < 0) {
index += nr;
}
return (index % nr);
}
static widget_t* slide_menu_get_child(widget_t* widget, int32_t index) {
widget_t** children = NULL;
return_value_if_fail(widget != NULL && widget->children, NULL);
children = (widget_t**)(widget->children->elms);
return_value_if_fail(children != NULL, NULL);
return children[slide_menu_fix_index(widget, index)];
}
static widget_t* slide_menu_find_target(widget_t* widget, xy_t x, xy_t y) {
widget_t* current = NULL;
int32_t r = 0;
int32_t b = 0;
int32_t xx = 0;
int32_t yy = 0;
point_t p = {x, y};
slide_menu_t* slide_menu = SLIDE_MENU(widget);
return_value_if_fail(widget != NULL && slide_menu != NULL, NULL);
if (widget->grab_widget != NULL) {
return widget->grab_widget;
}
widget_to_local(widget, &p);
current = slide_menu_get_child(widget, slide_menu->value);
return_value_if_fail(current != NULL, NULL);
r = current->x + current->w;
b = current->y + current->h;
xx = p.x;
yy = p.y;
if (current->enable && xx >= current->x && yy >= current->y && xx <= r && yy <= b) {
return current;
}
return NULL;
}
static int32_t slide_menu_get_visible_nr(widget_t* widget) {
int32_t n = 0;
int32_t menu_w = 0;
slide_menu_t* slide_menu = SLIDE_MENU(widget);
ENSURE(slide_menu);
if (widget->w == 0 || widget->h == 0) return 0;
menu_w = slide_menu_get_menu_w(slide_menu);
n = (widget->w - menu_w) / (menu_w * slide_menu->min_scale + slide_menu->spacer) + 1;
n = tk_min(n, MAX_VISIBLE_NR);
n = tk_min(n, widget_count_children(widget));
return n > 0 ? n : 0;
}
static rect_t slide_menu_get_clip_r(widget_t* widget) {
int32_t x = 0;
int32_t w = 0;
int32_t h = widget->h;
slide_menu_t* slide_menu = SLIDE_MENU(widget);
ENSURE(slide_menu);
if (slide_menu->clip) {
int32_t nr = slide_menu_get_visible_nr(widget) - 1;
int32_t menu_w = slide_menu_get_menu_w(slide_menu);
nr = tk_max(1, nr);
if (nr > 0 && (nr % 2) != 0) {
nr--;
/*keep nr is odd*/
}
w = menu_w + (menu_w * slide_menu->min_scale + slide_menu->spacer) * nr;
x = tk_roundi((widget->w - w) / 2.0f);
} else {
w = widget->w;
}
return rect_init(x, 0, w, h);
}
static ret_t slide_menu_paint_children_impl(widget_t* iter, canvas_t* c, xy_t clip_left,
xy_t clip_right) {
int32_t left = c->ox + iter->x;
int32_t right = left + iter->w;
if (left >= (clip_right - 1) || right <= (clip_left + 1)) {
iter->dirty = FALSE;
return RET_OK;
}
return widget_paint(iter, c);
}
static ret_t slide_menu_paint_children(widget_t* widget, canvas_t* c) {
int32_t i = 0;
widget_t* iter = NULL;
rect_t save_r = {0, 0, 0, 0};
rect_t clip_r = {0, 0, 0, 0};
rect_t widget_r = {0, 0, 0, 0};
xy_t clip_right, clip_left;
widget_t* children[MAX_VISIBLE_NR];
uint32_t curr = slide_menu_get_visible_children(widget, children);
canvas_get_clip_rect(c, &save_r);
widget_r = rect_init(c->ox, c->oy, widget->w, widget->h);
clip_r = rect_intersect(&save_r, &widget_r);
canvas_set_clip_rect(c, &clip_r);
clip_left = clip_r.x;
clip_right = clip_r.x + clip_r.w - 1;
/*left*/
for (i = 0; i <= curr - 1; i++) {
iter = children[i];
if (iter != NULL) {
slide_menu_paint_children_impl(iter, c, clip_left, clip_right);
}
}
/*right*/
for (i = MAX_VISIBLE_NR - 1; i >= curr + 1; i--) {
iter = children[i];
if (iter != NULL) {
slide_menu_paint_children_impl(iter, c, clip_left, clip_right);
}
}
/*curr*/
slide_menu_paint_children_impl(children[curr], c, clip_left, clip_right);
canvas_set_clip_rect(c, &save_r);
return RET_OK;
}
static ret_t slide_menu_paint_mask(widget_t* widget, canvas_t* c, rect_t* r) {
int32_t i = 0;
int32_t x = 0;
int32_t n = r->w / 2 + 2;
int32_t cx = widget->w / 2;
style_t* style = widget->astyle;
color_t trans = color_init(0, 0, 0, 0);
easing_func_t easing = easing_get(EASING_LINEAR);
color_t mask_color = style_get_color(style, STYLE_ID_MASK_COLOR, trans);
if (mask_color.rgba.a) {
for (i = 0; i < n; i++) {
x = cx - i;
if (x >= 0) {
mask_color.rgba.a = 0xff * easing((float_t)i / (float_t)n);
canvas_set_stroke_color(c, mask_color);
canvas_draw_vline(c, x, 0, widget->h);
}
}
for (i = 0; i < n; i++) {
x = cx + i;
if (x < widget->w) {
mask_color.rgba.a = 0xff * easing((float_t)i / (float_t)n);
canvas_set_stroke_color(c, mask_color);
canvas_draw_vline(c, x, 0, widget->h);
}
}
}
return RET_OK;
}
static ret_t slide_menu_on_paint_children(widget_t* widget, canvas_t* c) {
if (slide_menu_get_visible_nr(widget) >= 1) {
rect_t r;
rect_t save_r;
rect_t clip_r = slide_menu_get_clip_r(widget);
vgcanvas_t* vg = canvas_get_vgcanvas(c);
clip_r.x += c->ox;
clip_r.y += c->oy;
canvas_get_clip_rect(c, &save_r);
r = rect_intersect(&save_r, &clip_r);
canvas_save(c);
if (vg != NULL) {
vgcanvas_save(vg);
vgcanvas_clip_rect(vg, (float_t)r.x, (float_t)r.y, (float_t)r.w, (float_t)r.h);
}
canvas_set_clip_rect(c, &r);
slide_menu_paint_children(widget, c);
canvas_set_clip_rect(c, &save_r);
if (vg != NULL) {
vgcanvas_clip_rect(vg, (float_t)save_r.x, (float_t)save_r.y, (float_t)save_r.w,
(float_t)save_r.h);
vgcanvas_restore(vg);
}
canvas_restore(c);
slide_menu_paint_mask(widget, c, &clip_r);
}
return RET_OK;
}
static int32_t slide_menu_get_delta_index(widget_t* widget) {
int32_t menu_w_s = 0;
slide_menu_t* slide_menu = SLIDE_MENU(widget);
return_value_if_fail(widget != NULL && slide_menu != NULL, 0);
menu_w_s = slide_menu_get_menu_w(slide_menu) + slide_menu->spacer;
return tk_roundi((float_t)(slide_menu->xoffset) / (float_t)(menu_w_s));
}
static uint32_t slide_menu_get_visible_children(widget_t* widget,
widget_t* children[MAX_VISIBLE_NR]) {
int32_t i = 0;
int32_t curr = 0;
uint32_t nr = widget_count_children(widget);
slide_menu_t* slide_menu = SLIDE_MENU(widget);
ENSURE(slide_menu);
rect_t clip_rect = slide_menu_get_clip_r(widget);
int32_t delta_index = slide_menu_get_delta_index(widget);
int32_t index = slide_menu_fix_index(widget, slide_menu->value - delta_index);
int32_t rounded_xoffset = delta_index * (slide_menu_get_menu_w(slide_menu) + slide_menu->spacer);
int32_t xoffset = slide_menu->xoffset - rounded_xoffset;
for (i = 0; i < MAX_VISIBLE_NR; i++) {
children[i] = NULL;
}
for (i = 0; i < nr; i++) {
widget_get_child(widget, i)->visible = FALSE;
}
nr = slide_menu_get_visible_nr(widget);
if (nr == 0) return 0;
if (xoffset >= 0) {
curr = MAX_VISIBLE_NR / 2;
} else {
curr = MAX_VISIBLE_NR / 2 - 1;
}
children[curr] = slide_menu_get_child(widget, index);
for (i = 1; i <= (nr - 1) / 2; i++) {
children[curr - i] = slide_menu_get_child(widget, index - i);
children[curr + i] = slide_menu_get_child(widget, index + i);
}
if (nr % 2 == 0) {
if (xoffset >= 0) {
children[curr - i] = slide_menu_get_child(widget, index - i);
} else {
children[curr + i] = slide_menu_get_child(widget, index + i);
}
}
/* 保持边缘的 iter 不会突然消失 */
if (children[curr - i + 1]->x > clip_rect.x && curr - i >= 0 && nr < widget->children->size) {
children[curr - i] = slide_menu_get_child(widget, index - i);
}
if (children[curr + i - 1]->x + children[curr + i - 1]->w < clip_rect.x + clip_rect.w &&
curr + i < MAX_VISIBLE_NR && nr < widget->children->size) {
children[curr + i] = slide_menu_get_child(widget, index + i);
}
for (i = 0; i < MAX_VISIBLE_NR; i++) {
widget_t* iter = children[i];
if (iter != NULL) {
iter->visible = TRUE;
/*log_debug("nr=%d %d %s\n", nr, i, iter->name);*/
}
}
return curr;
}
static float_t slide_menu_calc_child_scale(slide_menu_t* slide_menu, int32_t i, int32_t curr,
int32_t xo) {
float_t scale = 0;
int32_t menu_w_s = slide_menu_get_menu_w(slide_menu) + slide_menu->spacer;
float_t min_scale = slide_menu->min_scale;
int32_t xoffset = xo + menu_w_s * (i - curr);
if (tk_abs(xoffset) < menu_w_s) {
scale = 1 + tk_abs(xoffset) * (min_scale - 1) / menu_w_s;
} else {
scale = min_scale;
}
return scale;
}
static int32_t slide_menu_calc_child_y(align_v_t align_v, int32_t max_size, int32_t size) {
int32_t y = 0;
switch (align_v) {
case ALIGN_V_TOP: {
y = 0;
break;
}
case ALIGN_V_MIDDLE: {
y = (max_size - size) / 2;
break;
}
default: {
y = max_size - size;
break;
}
}
return y;
}
static ret_t slide_menu_do_layout_children(widget_t* widget) {
int32_t i = 0;
int32_t x = 0;
int32_t y = 0;
int32_t w = 0;
int32_t h = 0;
float_t scale = 0;
widget_t* iter = NULL;
int32_t visible_nr = MAX_VISIBLE_NR;
widget_t* children[MAX_VISIBLE_NR];
slide_menu_t* slide_menu = SLIDE_MENU(widget);
ENSURE(slide_menu);
int32_t menu_h = widget->h;
int32_t menu_w = slide_menu_get_menu_w(slide_menu);
int32_t menu_w_s = menu_w + slide_menu->spacer;
uint32_t curr = slide_menu_get_visible_children(widget, children);
int32_t rounded_xoffset = slide_menu_get_delta_index(widget) * menu_w_s;
int32_t xoffset = slide_menu->xoffset - rounded_xoffset;
float_t max_crevice_scale = 1 - slide_menu_calc_child_scale(slide_menu, 0, 0, menu_w_s >> 1);
/*curr widget*/
iter = children[curr];
scale = slide_menu_calc_child_scale(slide_menu, curr, curr, xoffset);
w = tk_roundi(menu_w * scale);
h = tk_roundi(menu_h * scale);
/* 由于菜单控件滑块一半的 menu_w_s 的时候 children[curr] 就会交换为下一个或者上一个控件，所以写的一套公式来配合这个逻辑来移动 */
x = (widget->w - menu_w) * 0.5f + xoffset - (xoffset * max_crevice_scale * menu_w / menu_w_s);
y = slide_menu_calc_child_y(slide_menu->align_v, menu_h, h);
widget_move_resize(iter, x, y, w, h);
widget_layout_children(iter);
/*left*/
for (i = curr - 1; i >= 0; i--) {
iter = children[i];
if (iter == NULL) break;
scale = slide_menu_calc_child_scale(slide_menu, i, curr, xoffset);
w = tk_roundi(menu_w * scale);
h = tk_roundi(menu_h * scale);
x = children[i + 1]->x - w - slide_menu->spacer;
y = slide_menu_calc_child_y(slide_menu->align_v, menu_h, h);
widget_move_resize(iter, x, y, w, h);
widget_layout_children(iter);
}
/*right*/
for (i = curr + 1; i < visible_nr; i++) {
iter = children[i];
if (iter == NULL) break;
if (i > 0) {
scale = slide_menu_calc_child_scale(slide_menu, i, curr, xoffset);
w = tk_roundi(menu_w * scale);
h = tk_roundi(menu_h * scale);
x = children[i - 1]->x + children[i - 1]->w + slide_menu->spacer;
y = slide_menu_calc_child_y(slide_menu->align_v, menu_h, h);
widget_move_resize(iter, x, y, w, h);
widget_layout_children(iter);
}
}
return RET_OK;
}
static ret_t slide_menu_layout_children(widget_t* widget) {
return_value_if_fail(widget->w >= 2 * widget->h, RET_BAD_PARAMS);
if (widget_count_children(widget) > 0) {
slide_menu_do_layout_children(widget);
}
return RET_OK;
}
static ret_t slide_menu_get_prop(widget_t* widget, const char* name, value_t* v) {
slide_menu_t* slide_menu = SLIDE_MENU(widget);
ENSURE(slide_menu);
if (tk_str_eq(name, WIDGET_PROP_VALUE)) {
value_set_int(v, slide_menu->value);
return RET_OK;
} else if (tk_str_eq(name, SLIDE_MENU_PROP_MIN_SCALE)) {
value_set_float(v, slide_menu->min_scale);
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_ALIGN_V)) {
value_set_int(v, slide_menu->align_v);
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_YOFFSET)) {
value_set_int(v, 0);
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_XOFFSET)) {
value_set_int(v, slide_menu->xoffset);
return RET_OK;
} else if (tk_str_eq(name, SLIDE_MENU_PROP_SPACER)) {
value_set_int(v, slide_menu->spacer);
return RET_OK;
} else if (tk_str_eq(name, SLIDE_MENU_PROP_MENU_W)) {
value_set_str(v, slide_menu->menu_w);
return RET_OK;
} else if (tk_str_eq(name, SLIDE_MENU_PROP_CLIP)) {
value_set_bool(v, slide_menu->clip);
return RET_OK;
}
return RET_NOT_FOUND;
}
static ret_t slide_menu_set_prop(widget_t* widget, const char* name, const value_t* v) {
slide_menu_t* slide_menu = SLIDE_MENU(widget);
ENSURE(slide_menu);
if (tk_str_eq(name, WIDGET_PROP_VALUE)) {
slide_menu_set_value(widget, value_int(v));
return RET_OK;
} else if (tk_str_eq(name, SLIDE_MENU_PROP_MIN_SCALE)) {
slide_menu_set_min_scale(widget, value_float(v));
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_XOFFSET)) {
slide_menu_set_xoffset(slide_menu, value_int(v));
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_YOFFSET)) {
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_ALIGN_V)) {
if (v->type == VALUE_TYPE_STRING) {
const key_type_value_t* kv = align_v_type_find(value_str(v));
if (kv != NULL) {
slide_menu_set_align_v(widget, (align_v_t)(kv->value));
}
} else {
slide_menu_set_align_v(widget, (align_v_t)(value_int(v)));
}
return RET_OK;
} else if (tk_str_eq(name, SLIDE_MENU_PROP_SPACER)) {
slide_menu_set_spacer(widget, value_int(v));
return RET_OK;
} else if (tk_str_eq(name, SLIDE_MENU_PROP_MENU_W)) {
slide_menu_set_menu_w(widget, value_str(v));
return RET_OK;
} else if (tk_str_eq(name, SLIDE_MENU_PROP_CLIP)) {
slide_menu_set_clip(widget, value_bool(v));
return RET_OK;
}
return RET_NOT_FOUND;
}
static ret_t slide_menu_on_pointer_down(slide_menu_t* slide_menu, pointer_event_t* e) {
velocity_t* v = &(slide_menu->velocity);
slide_menu->xdown = e->x;
velocity_reset(v);
velocity_update(v, e->e.time, e->x, e->y);
return RET_OK;
}
static ret_t slide_menu_on_pointer_move(slide_menu_t* slide_menu, pointer_event_t* e) {
velocity_t* v = &(slide_menu->velocity);
velocity_update(v, e->e.time, e->x, e->y);
slide_menu_set_xoffset(slide_menu, e->x - slide_menu->xdown);
return RET_OK;
}
static ret_t slide_menu_focus_active_child(slide_menu_t* slide_menu) {
ret_t ret = RET_NOT_FOUND;
widget_t* focused_child = widget_get_child(WIDGET(slide_menu), slide_menu->value);
if (focused_child != NULL) {
ret = widget_set_focused(focused_child, TRUE);
}
return ret;
}
static ret_t slide_menu_set_value_only(slide_menu_t* slide_menu, int32_t index) {
widget_t* widget = WIDGET(slide_menu);
if (index != slide_menu->value) {
value_change_event_t evt;
value_change_event_init(&evt, EVT_VALUE_WILL_CHANGE, widget);
value_set_int(&(evt.old_value), slide_menu->value);
value_set_int(&(evt.new_value), index);
if (widget_dispatch(widget, (event_t*)&evt) != RET_STOP) {
slide_menu->value = index;
slide_menu_focus_active_child(slide_menu);
evt.e.type = EVT_VALUE_CHANGED;
widget_dispatch(widget, (event_t*)&evt);
widget_invalidate(widget, NULL);
}
}
return RET_OK;
}
static ret_t slide_menu_on_scroll_done(void* ctx, event_t* e) {
int32_t index = 0;
int32_t delta_index = 0;
widget_t* widget = WIDGET(ctx);
slide_menu_t* slide_menu = SLIDE_MENU(ctx);
return_value_if_fail(widget != NULL && slide_menu != NULL && widget->children != NULL,
RET_BAD_PARAMS);
delta_index = slide_menu_get_delta_index(widget);
index = slide_menu_fix_index(widget, slide_menu->value - delta_index);
slide_menu->wa = NULL;
slide_menu->xoffset = 0;
slide_menu_set_value_only(slide_menu, index);
widget_invalidate_force(widget, NULL);
return RET_REMOVE;
}
static ret_t slide_menu_scroll_to(widget_t* widget, int32_t xoffset_end) {
int32_t xoffset = 0;
slide_menu_t* slide_menu = SLIDE_MENU(widget);
return_value_if_fail(slide_menu != NULL, RET_FAIL);
xoffset = slide_menu->xoffset;
if (xoffset == xoffset_end) {
return RET_OK;
}
slide_menu->wa = widget_animator_scroll_create(widget, TK_ANIMATING_TIME, 0, EASING_SIN_INOUT);
return_value_if_fail(slide_menu->wa != NULL, RET_OOM);
widget_set_focused(widget_get_child(widget, slide_menu->value), FALSE);
widget_animator_scroll_set_params(slide_menu->wa, xoffset, 0, xoffset_end, 0);
widget_animator_on(slide_menu->wa, EVT_ANIM_END, slide_menu_on_scroll_done, slide_menu);
widget_animator_start(slide_menu->wa);
return RET_OK;
}
ret_t slide_menu_scroll_to_prev(widget_t* widget) {
int32_t menu_w_s = 0;
slide_menu_t* slide_menu = SLIDE_MENU(widget);
return_value_if_fail(slide_menu != NULL, RET_FAIL);
menu_w_s = slide_menu_get_menu_w(slide_menu) + slide_menu->spacer;
return slide_menu_scroll_to(widget, slide_menu->xoffset + menu_w_s);
}
ret_t slide_menu_scroll_to_next(widget_t* widget) {
int32_t menu_w_s = 0;
slide_menu_t* slide_menu = SLIDE_MENU(widget);
return_value_if_fail(slide_menu != NULL, RET_FAIL);
menu_w_s = slide_menu_get_menu_w(slide_menu) + slide_menu->spacer;
return slide_menu_scroll_to(widget, slide_menu->xoffset - menu_w_s);
}
static ret_t slide_menu_on_pointer_up(slide_menu_t* slide_menu, pointer_event_t* e) {
int32_t xoffset_end = 0;
point_t p = {e->x, e->y};
velocity_t* v = &(slide_menu->velocity);
widget_t* widget = WIDGET(slide_menu);
int32_t nr = widget_count_children(widget);
int32_t menu_w = slide_menu_get_menu_w(slide_menu);
int32_t menu_w_s = menu_w + slide_menu->spacer;
velocity_update(v, e->e.time, e->x, e->y);
if (!slide_menu->dragged) {
widget_to_local(widget, &p);
if (nr > 1) {
int32_t right = (widget->w + menu_w_s) / 2;
int32_t left = (widget->w - menu_w_s) / 2;
int32_t min_menu_w_s = menu_w * slide_menu->min_scale + slide_menu->spacer;
if (p.x > right) {
int32_t delta = (p.x - right) / min_menu_w_s + 1;
xoffset_end = -menu_w_s * delta;
} else if (p.x < left) {
int32_t delta = (left - p.x) / min_menu_w_s + 1;
xoffset_end = menu_w_s * delta;
}
}
if (xoffset_end == 0) {
widget_invalidate(WIDGET(slide_menu), NULL);
widget_layout_children(WIDGET(slide_menu));
return RET_OK;
}
} else {
xoffset_end = slide_menu->xoffset + v->xv;
xoffset_end = tk_roundi((float_t)xoffset_end / (float_t)(menu_w_s)) * menu_w_s;
}
slide_menu_scroll_to(WIDGET(slide_menu), xoffset_end);
return RET_OK;
}
static ret_t slide_menu_on_event(widget_t* widget, event_t* e) {
ret_t ret = RET_OK;
uint16_t type = e->type;
slide_menu_t* slide_menu = SLIDE_MENU(widget);
return_value_if_fail(widget != NULL && slide_menu != NULL, RET_BAD_PARAMS);
if (slide_menu->wa != NULL) {
return RET_STOP;
}
switch (type) {
case EVT_WIDGET_LOAD: {
if (widget->focused) {
slide_menu_focus_active_child(slide_menu);
}
break;
}
case EVT_POINTER_DOWN:
slide_menu->dragged = FALSE;
slide_menu->pressed = TRUE;
widget_grab(widget->parent, widget);
slide_menu_on_pointer_down(slide_menu, (pointer_event_t*)e);
break;
case EVT_POINTER_UP: {
if (slide_menu->pressed) {
slide_menu_on_pointer_up(slide_menu, (pointer_event_t*)e);
ret = slide_menu->dragged ? RET_STOP : RET_OK;
widget_ungrab(widget->parent, widget);
slide_menu->pressed = FALSE;
slide_menu->dragged = FALSE;
}
break;
}
case EVT_POINTER_DOWN_ABORT: {
if (slide_menu->pressed) {
slide_menu->xoffset = 0;
slide_menu->pressed = FALSE;
slide_menu->dragged = FALSE;
widget_ungrab(widget->parent, widget);
log_debug("slide menu: EVT_POINTER_DOWN_ABORT\n");
}
break;
}
case EVT_POINTER_MOVE: {
pointer_event_t* evt = (pointer_event_t*)e;
if (slide_menu->dragged) {
slide_menu_on_pointer_move(slide_menu, evt);
} else if (evt->pressed && slide_menu->pressed) {
int32_t delta = evt->x - slide_menu->xdown;
if (tk_abs(delta) >= TK_DRAG_THRESHOLD) {
pointer_event_t abort;
pointer_event_init(&abort, EVT_POINTER_DOWN_ABORT, widget, evt->x, evt->y);
widget_dispatch_event_to_target_recursive(widget, (event_t*)(&abort));
slide_menu->dragged = TRUE;
}
}
ret = slide_menu->dragged ? RET_STOP : RET_OK;
break;
}
case EVT_ACTIVATED: {
slide_menu->is_activated = TRUE;
ret = RET_STOP;
break;
}
case EVT_UNACTIVATED: {
slide_menu->is_activated = FALSE;
break;
}
case EVT_KEY_UP: {
key_event_t* evt = (key_event_t*)e;
keyboard_type_t keyboard_type = system_info()->keyboard_type;
if (keyboard_type == KEYBOARD_3KEYS || keyboard_type == KEYBOARD_5KEYS) {
if (!slide_menu->is_activated) {
break;
} else if (evt->key == TK_KEY_RETURN) {
slide_menu_focus_active_child(slide_menu);
ret = RET_STOP;
}
}
if (evt->key == TK_KEY_LEFT) {
slide_menu_scroll_to_prev(widget);
ret = RET_STOP;
} else if (evt->key == TK_KEY_RIGHT) {
ret = RET_STOP;
slide_menu_scroll_to_next(widget);
}
break;
}
default:
break;
}
return ret;
}
static ret_t slide_menu_on_destroy(widget_t* widget) {
slide_menu_t* slide_menu = SLIDE_MENU(widget);
return_value_if_fail(slide_menu != NULL, RET_BAD_PARAMS);
TKMEM_FREE(slide_menu->menu_w);
return RET_OK;
}
static ret_t slide_menu_init(widget_t* widget) {
slide_menu_t* slide_menu = SLIDE_MENU(widget);
return_value_if_fail(slide_menu != NULL, RET_BAD_PARAMS);
slide_menu->value = 1;
slide_menu->min_scale = 0.8f;
slide_menu->align_v = ALIGN_V_BOTTOM;
slide_menu->spacer = 0;
slide_menu->menu_w = tk_strdup("");
slide_menu->clip = TRUE;
return RET_OK;
}
const char* s_slide_menu_properties[] = {WIDGET_PROP_VALUE,
WIDGET_PROP_ALIGN_V,
SLIDE_MENU_PROP_MIN_SCALE,
SLIDE_MENU_PROP_SPACER,
SLIDE_MENU_PROP_MENU_W,
SLIDE_MENU_PROP_CLIP,
NULL};
TK_DECL_VTABLE(slide_menu) = {.size = sizeof(slide_menu_t),
.inputable = TRUE,
.type = WIDGET_TYPE_SLIDE_MENU,
.clone_properties = s_slide_menu_properties,
.persistent_properties = s_slide_menu_properties,
.get_parent_vt = TK_GET_PARENT_VTABLE(widget),
.create = slide_menu_create,
.init = slide_menu_init,
.set_prop = slide_menu_set_prop,
.get_prop = slide_menu_get_prop,
.find_target = slide_menu_find_target,
.on_paint_children = slide_menu_on_paint_children,
.on_layout_children = slide_menu_layout_children,
.on_event = slide_menu_on_event,
.on_destroy = slide_menu_on_destroy};
widget_t* slide_menu_create(widget_t* parent, xy_t x, xy_t y, wh_t w, wh_t h) {
widget_t* widget = widget_create(parent, TK_REF_VTABLE(slide_menu), x, y, w, h);
return_value_if_fail(slide_menu_init(widget) == RET_OK, NULL);
return widget;
}
ret_t slide_menu_set_value(widget_t* widget, uint32_t index) {
slide_menu_t* slide_menu = SLIDE_MENU(widget);
return_value_if_fail(slide_menu != NULL, RET_BAD_PARAMS);
slide_menu_set_value_only(slide_menu, index);
widget_layout_children(widget);
return widget_invalidate(widget, NULL);
}
ret_t slide_menu_set_min_scale(widget_t* widget, float_t min_scale) {
slide_menu_t* slide_menu = SLIDE_MENU(widget);
return_value_if_fail(slide_menu != NULL, RET_BAD_PARAMS);
slide_menu->min_scale = tk_max(SLIDE_MENU_MIN_SCALE, tk_min(min_scale, 1));
return widget_invalidate(widget, NULL);
}
ret_t slide_menu_set_align_v(widget_t* widget, align_v_t align_v) {
slide_menu_t* slide_menu = SLIDE_MENU(widget);
return_value_if_fail(slide_menu != NULL, RET_BAD_PARAMS);
slide_menu->align_v = align_v;
return widget_invalidate(widget, NULL);
}
ret_t slide_menu_set_spacer(widget_t* widget, int32_t spacer) {
slide_menu_t* slide_menu = SLIDE_MENU(widget);
return_value_if_fail(slide_menu != NULL, RET_BAD_PARAMS);
slide_menu->spacer = spacer;
return widget_invalidate(widget, NULL);
}
ret_t slide_menu_set_menu_w(widget_t* widget, const char* menu_w) {
slide_menu_t* slide_menu = SLIDE_MENU(widget);
return_value_if_fail(slide_menu != NULL && menu_w != NULL, RET_BAD_PARAMS);
slide_menu->menu_w = tk_str_copy(slide_menu->menu_w, menu_w);
return widget_invalidate(widget, NULL);
}
ret_t slide_menu_set_clip(widget_t* widget, bool_t clip) {
slide_menu_t* slide_menu = SLIDE_MENU(widget);
return_value_if_fail(slide_menu != NULL, RET_BAD_PARAMS);
slide_menu->clip = clip;
return widget_invalidate(widget, NULL);
}
widget_t* slide_menu_cast(widget_t* widget) {
return_value_if_fail(WIDGET_IS_INSTANCE_OF(widget, slide_menu), NULL);
return widget;
}
|
0 |
repos/awtk/src/ext_widgets
|
repos/awtk/src/ext_widgets/serial_widget/serial_widget.c
|
/**
* File: serial_widget.c
* Author: AWTK Develop Team
* Brief: 用于串口通信的控件
*
* Copyright (c) 2022 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2022-07-08 Li XianJing <[email protected]> created
*
*/
#include "tkc/mem.h"
#include "tkc/utils.h"
#include "tkc/event_source_fd.h"
#include "base/main_loop.h"
#include "serial_widget.h"
#include "tkc/serial_helper.h"
#include "streams/serial/iostream_serial.h"
#ifdef AWTK_WEB
#define tk_iostream_serial_wait_for_data(a, b) RET_NOT_IMPL
#define tk_iostream_serial_create(a) NULL
#define tk_iostream_serial_config(a, b, c, d, e, f)
#endif/*AWTK_WEB*/
static ret_t serial_widget_apply_props(widget_t* widget);
ret_t serial_widget_set_baudrate(widget_t* widget, uint32_t baudrate) {
serial_widget_t* serial_widget = SERIAL_WIDGET(widget);
return_value_if_fail(serial_widget != NULL, RET_BAD_PARAMS);
serial_widget->baudrate = baudrate;
serial_widget_apply_props(widget);
return RET_OK;
}
ret_t serial_widget_set_device(widget_t* widget, const char* device) {
serial_widget_t* serial_widget = SERIAL_WIDGET(widget);
return_value_if_fail(serial_widget != NULL, RET_BAD_PARAMS);
serial_widget->device = tk_str_copy(serial_widget->device, device);
serial_widget_apply_props(widget);
return RET_OK;
}
ret_t serial_widget_set_bytesize(widget_t* widget, uint32_t bytesize) {
serial_widget_t* serial_widget = SERIAL_WIDGET(widget);
return_value_if_fail(serial_widget != NULL, RET_BAD_PARAMS);
serial_widget->bytesize = bytesize;
serial_widget_apply_props(widget);
return RET_OK;
}
ret_t serial_widget_set_parity(widget_t* widget, uint32_t parity) {
serial_widget_t* serial_widget = SERIAL_WIDGET(widget);
return_value_if_fail(serial_widget != NULL, RET_BAD_PARAMS);
serial_widget->parity = parity;
serial_widget_apply_props(widget);
return RET_OK;
}
ret_t serial_widget_set_stopbits(widget_t* widget, uint32_t stopbits) {
serial_widget_t* serial_widget = SERIAL_WIDGET(widget);
return_value_if_fail(serial_widget != NULL, RET_BAD_PARAMS);
serial_widget->stopbits = stopbits;
serial_widget_apply_props(widget);
return RET_OK;
}
ret_t serial_widget_set_flowcontrol(widget_t* widget, uint32_t flowcontrol) {
serial_widget_t* serial_widget = SERIAL_WIDGET(widget);
return_value_if_fail(serial_widget != NULL, RET_BAD_PARAMS);
serial_widget->flowcontrol = flowcontrol;
serial_widget_apply_props(widget);
return RET_OK;
}
ret_t serial_widget_set_check_interval(widget_t* widget, uint32_t check_interval) {
serial_widget_t* serial_widget = SERIAL_WIDGET(widget);
return_value_if_fail(serial_widget != NULL, RET_BAD_PARAMS);
serial_widget->check_interval = check_interval;
serial_widget_apply_props(widget);
return RET_OK;
}
static ret_t serial_widget_get_prop(widget_t* widget, const char* name, value_t* v) {
serial_widget_t* serial_widget = SERIAL_WIDGET(widget);
return_value_if_fail(serial_widget != NULL && name != NULL && v != NULL, RET_BAD_PARAMS);
if (tk_str_eq(SERIAL_WIDGET_PROP_BAUDRATE, name)) {
value_set_uint32(v, serial_widget->baudrate);
return RET_OK;
} else if (tk_str_eq(SERIAL_WIDGET_PROP_DEVICE, name)) {
value_set_str(v, serial_widget->device);
return RET_OK;
} else if (tk_str_eq(SERIAL_WIDGET_PROP_BYTESIZE, name)) {
value_set_uint32(v, serial_widget->bytesize);
return RET_OK;
} else if (tk_str_eq(SERIAL_WIDGET_PROP_PARITY, name)) {
value_set_uint32(v, serial_widget->parity);
return RET_OK;
} else if (tk_str_eq(SERIAL_WIDGET_PROP_STOPBITS, name)) {
value_set_uint32(v, serial_widget->stopbits);
return RET_OK;
} else if (tk_str_eq(SERIAL_WIDGET_PROP_FLOWCONTROL, name)) {
value_set_uint32(v, serial_widget->flowcontrol);
return RET_OK;
} else if (tk_str_eq(SERIAL_WIDGET_PROP_ISTREAM, name)) {
value_set_object(v, TK_OBJECT(serial_widget->istream));
return RET_OK;
} else if (tk_str_eq(SERIAL_WIDGET_PROP_OSTREAM, name)) {
value_set_object(v, TK_OBJECT(serial_widget->ostream));
return RET_OK;
} else if (tk_str_eq(SERIAL_WIDGET_PROP_IOSTREAM, name)) {
value_set_object(v, TK_OBJECT(serial_widget->iostream));
return RET_OK;
} else if (tk_str_eq(SERIAL_WIDGET_PROP_CHECK_INTERVAL, name)) {
value_set_uint32(v, serial_widget->check_interval);
return RET_OK;
}
return RET_NOT_FOUND;
}
static ret_t serial_widget_on_data(widget_t* widget) {
serial_widget_t* serial_widget = SERIAL_WIDGET(widget);
ENSURE(serial_widget);
widget_dispatch_simple_event(widget, EVT_DATA);
if (!tk_object_get_prop_bool(TK_OBJECT(serial_widget->iostream), TK_STREAM_PROP_IS_OK, FALSE)) {
log_debug("stream broken\n");
return RET_FAIL;
}
return RET_OK;
}
static ret_t serial_widget_close_device(widget_t* widget) {
serial_widget_t* serial_widget = SERIAL_WIDGET(widget);
ENSURE(serial_widget);
TK_OBJECT_UNREF(serial_widget->iostream);
serial_widget->istream = NULL;
serial_widget->ostream = NULL;
if (serial_widget->idle_id != TK_INVALID_ID) {
idle_remove(serial_widget->idle_id);
serial_widget->idle_id = TK_INVALID_ID;
}
if (serial_widget->timer_id != TK_INVALID_ID) {
timer_remove(serial_widget->timer_id);
serial_widget->timer_id = TK_INVALID_ID;
}
if (serial_widget->event_source != NULL) {
main_loop_remove_event_source(main_loop(), serial_widget->event_source);
serial_widget->event_source = NULL;
}
return RET_OK;
}
static ret_t serial_widget_on_event_source_event(event_source_t* source) {
event_source_fd_t* fd = EVENT_SOURCE_FD(source);
serial_widget_t* serial_widget = SERIAL_WIDGET(fd->ctx);
widget_t* widget = WIDGET(serial_widget);
if (serial_widget_on_data(widget) == RET_OK) {
return RET_OK;
} else {
serial_widget_close_device(widget);
return RET_REMOVE;
}
}
static ret_t serial_widget_check_if_data_available(const timer_info_t* info) {
widget_t* widget = WIDGET(info->ctx);
serial_widget_t* serial_widget = SERIAL_WIDGET(info->ctx);
ENSURE(serial_widget);
if (serial_widget->iostream != NULL) {
ret_t ret = tk_iostream_serial_wait_for_data(serial_widget->iostream, 10);
if (ret == RET_OK) {
if (serial_widget_on_data(WIDGET(serial_widget)) == RET_OK) {
return RET_REPEAT;
}
} else if (ret == RET_TIMEOUT) {
return RET_REPEAT;
}
}
serial_widget_close_device(widget);
serial_widget->timer_id = TK_INVALID_ID;
return RET_REMOVE;
}
static ret_t serial_widget_apply_props_async(const idle_info_t* info) {
int fd = -1;
widget_t* widget = WIDGET(info->ctx);
serial_widget_t* serial_widget = SERIAL_WIDGET(info->ctx);
ENSURE(serial_widget);
serial_widget_close_device(widget);
return_value_if_fail(serial_widget->device != NULL, RET_REMOVE);
serial_widget->iostream = tk_iostream_serial_create(serial_widget->device);
return_value_if_fail(serial_widget->iostream != NULL, RET_REMOVE);
tk_iostream_serial_config(serial_widget->iostream, serial_widget->baudrate,
serial_widget->bytesize, serial_widget->parity, serial_widget->stopbits,
serial_widget->flowcontrol);
serial_widget->istream = tk_iostream_get_istream(serial_widget->iostream);
serial_widget->ostream = tk_iostream_get_ostream(serial_widget->iostream);
fd = tk_object_get_prop_int(TK_OBJECT(serial_widget->iostream), TK_STREAM_PROP_FD, -1);
if (fd >= 0) {
serial_widget->event_source =
event_source_fd_create(fd, serial_widget_on_event_source_event, serial_widget);
main_loop_add_event_source(main_loop(), serial_widget->event_source);
} else {
serial_widget->timer_id = timer_add(serial_widget_check_if_data_available, serial_widget,
serial_widget->check_interval);
}
log_debug("open serial %s ok\n", serial_widget->device);
return RET_REMOVE;
}
static ret_t serial_widget_apply_props(widget_t* widget) {
serial_widget_t* serial_widget = SERIAL_WIDGET(widget);
return_value_if_fail(serial_widget != NULL, RET_BAD_PARAMS);
if (serial_widget->idle_id == TK_INVALID_ID && serial_widget->device != NULL) {
serial_widget->idle_id = idle_add(serial_widget_apply_props_async, widget);
}
return RET_OK;
}
static ret_t serial_widget_set_prop(widget_t* widget, const char* name, const value_t* v) {
return_value_if_fail(widget != NULL && name != NULL && v != NULL, RET_BAD_PARAMS);
if (tk_str_eq(SERIAL_WIDGET_PROP_BAUDRATE, name)) {
serial_widget_set_baudrate(widget, value_uint32(v));
return RET_OK;
} else if (tk_str_eq(SERIAL_WIDGET_PROP_DEVICE, name)) {
serial_widget_set_device(widget, value_str(v));
return RET_OK;
} else if (tk_str_eq(SERIAL_WIDGET_PROP_BYTESIZE, name)) {
if (v->type == VALUE_TYPE_STRING) {
serial_widget_set_bytesize(widget, serial_bytesize_from_str(value_str(v)));
} else {
serial_widget_set_bytesize(widget, value_uint32(v));
}
return RET_OK;
} else if (tk_str_eq(SERIAL_WIDGET_PROP_PARITY, name)) {
if (v->type == VALUE_TYPE_STRING) {
serial_widget_set_parity(widget, serial_parity_from_str(value_str(v)));
} else {
serial_widget_set_parity(widget, value_uint32(v));
}
return RET_OK;
} else if (tk_str_eq(SERIAL_WIDGET_PROP_STOPBITS, name)) {
if (v->type == VALUE_TYPE_STRING) {
serial_widget_set_stopbits(widget, serial_stopbits_from_str(value_str(v)));
} else {
serial_widget_set_stopbits(widget, value_uint32(v));
}
return RET_OK;
} else if (tk_str_eq(SERIAL_WIDGET_PROP_FLOWCONTROL, name)) {
if (v->type == VALUE_TYPE_STRING) {
serial_widget_set_flowcontrol(widget, serial_flowcontrol_from_str(value_str(v)));
} else {
serial_widget_set_flowcontrol(widget, value_uint32(v));
}
return RET_OK;
} else if (tk_str_eq(SERIAL_WIDGET_PROP_CHECK_INTERVAL, name)) {
serial_widget_set_check_interval(widget, value_uint32(v));
return RET_OK;
}
return RET_NOT_FOUND;
}
static ret_t serial_widget_on_destroy(widget_t* widget) {
serial_widget_t* serial_widget = SERIAL_WIDGET(widget);
return_value_if_fail(widget != NULL && serial_widget != NULL, RET_BAD_PARAMS);
TKMEM_FREE(serial_widget->device);
serial_widget_close_device(widget);
return RET_OK;
}
static ret_t serial_widget_on_paint_self(widget_t* widget, canvas_t* c) {
return RET_OK;
}
static ret_t serial_widget_on_event(widget_t* widget, event_t* e) {
return RET_OK;
}
static ret_t serial_widget_init(widget_t* widget) {
serial_widget_t* serial_widget = SERIAL_WIDGET(widget);
return_value_if_fail(serial_widget != NULL, RET_BAD_PARAMS);
serial_widget->baudrate = 115200;
serial_widget->bytesize = eightbits;
serial_widget->stopbits = stopbits_one;
serial_widget->flowcontrol = flowcontrol_none;
serial_widget->check_interval = 100;
return RET_OK;
}
const char* s_serial_widget_properties[] = {SERIAL_WIDGET_PROP_BAUDRATE,
SERIAL_WIDGET_PROP_BYTESIZE,
SERIAL_WIDGET_PROP_PARITY,
SERIAL_WIDGET_PROP_STOPBITS,
SERIAL_WIDGET_PROP_FLOWCONTROL,
SERIAL_WIDGET_PROP_DEVICE,
NULL};
TK_DECL_VTABLE(serial_widget) = {.size = sizeof(serial_widget_t),
.type = WIDGET_TYPE_SERIAL_WIDGET,
.clone_properties = s_serial_widget_properties,
.persistent_properties = s_serial_widget_properties,
.get_parent_vt = TK_GET_PARENT_VTABLE(widget),
.create = serial_widget_create,
.on_paint_self = serial_widget_on_paint_self,
.set_prop = serial_widget_set_prop,
.get_prop = serial_widget_get_prop,
.on_event = serial_widget_on_event,
.init = serial_widget_init,
.on_destroy = serial_widget_on_destroy};
widget_t* serial_widget_create(widget_t* parent, xy_t x, xy_t y, wh_t w, wh_t h) {
widget_t* widget = widget_create(parent, TK_REF_VTABLE(serial_widget), x, y, w, h);
return_value_if_fail(serial_widget_init(widget) == RET_OK, NULL);
return widget;
}
widget_t* serial_widget_cast(widget_t* widget) {
return_value_if_fail(WIDGET_IS_INSTANCE_OF(widget, serial_widget), NULL);
return widget;
}
|
0 |
repos/awtk/src/ext_widgets
|
repos/awtk/src/ext_widgets/serial_widget/serial_widget.h
|
/**
* File: serial_widget.h
* Author: AWTK Develop Team
* Brief: 用于串口通信的控件
*
* Copyright (c) 2022 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2022-07-08 Li XianJing <[email protected]> created
*
*/
#ifndef TK_SERIAL_WIDGET_H
#define TK_SERIAL_WIDGET_H
#include "base/widget.h"
#include "tkc/iostream.h"
BEGIN_C_DECLS
/**
* @class serial_widget_t
* @parent widget_t
* @annotation ["scriptable","design","widget"]
* 用于串口通信的控件
* 在xml中使用"serial"标签创建控件。如：
*
* ```xml
* <!-- ui -->
* <serial device="COM1" baudrate="115200"/>
* ```
*
* 可用通过style来设置控件的显示风格，如字体的大小和颜色等等。如：
* > 本控件默认不可见，无需指定style。
*
* ```xml
* <!-- style -->
* <serial>
* <style name="default" font_size="32">
* <normal text_color="black" />
* </style>
* </serial>
* ```
*/
typedef struct _serial_widget_t {
widget_t widget;
/**
* @property {char*} device
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 设备(文件)名。
*/
char* device;
/**
* @property {uint32_t} baudrate
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 波特率。
*/
uint32_t baudrate;
/**
* @property {uint32_t} bytesize
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 字节位数。
*/
uint32_t bytesize;
/**
* @property {uint32_t} parity
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 奇偶校验。
*/
uint32_t parity;
/**
* @property {uint32_t} stopbits
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 停止位。
*/
uint32_t stopbits;
/**
* @property {uint32_t} flowcontrol
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 流控。
*/
uint32_t flowcontrol;
/**
* @property {tk_istream_t*} istream
* @annotation ["set_prop","get_prop","readable","persitent","design"]
* 输入流。
*/
tk_istream_t* istream;
/**
* @property {tk_ostream_t*} ostream
* @annotation ["set_prop","get_prop","readable","persitent","design"]
* 输出流。
*/
tk_ostream_t* ostream;
/**
* @property {tk_iostream_t*} iostream
* @annotation ["set_prop","get_prop","readable","persitent","design"]
* 输入/出流。
*/
tk_iostream_t* iostream;
/**
* @property {uint32_t} check_interval
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 轮询时间（单位：ms）。
* > 仅在不支持用select等待串口数据的嵌入式设备上有效。
*/
uint32_t check_interval;
/*private*/
uint32_t idle_id;
uint32_t timer_id;
event_source_t* event_source;
} serial_widget_t;
/**
* @event {event_t} EVT_DATA
* 数据到来事件。
*/
/**
* @method serial_widget_create
* @annotation ["constructor", "scriptable"]
* 创建serial_widget对象
* @param {widget_t*} parent 父控件
* @param {xy_t} x x坐标
* @param {xy_t} y y坐标
* @param {wh_t} w 宽度
* @param {wh_t} h 高度
*
* @return {widget_t*} serial_widget对象。
*/
widget_t* serial_widget_create(widget_t* parent, xy_t x, xy_t y, wh_t w, wh_t h);
/**
* @method serial_widget_cast
* 转换为serial_widget对象(供脚本语言使用)。
* @annotation ["cast", "scriptable"]
* @param {widget_t*} widget serial_widget对象。
*
* @return {widget_t*} serial_widget对象。
*/
widget_t* serial_widget_cast(widget_t* widget);
/**
* @method serial_widget_set_baudrate
* 设置 波特率。
* @annotation ["scriptable"]
* @param {widget_t*} widget widget对象。
* @param {uint32_t} baudrate 波特率。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t serial_widget_set_baudrate(widget_t* widget, uint32_t baudrate);
/**
* @method serial_widget_set_device
* 设置 设备。
* @annotation ["scriptable"]
* @param {widget_t*} widget widget对象。
* @param {const char*} device 设备。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t serial_widget_set_device(widget_t* widget, const char* device);
/**
* @method serial_widget_set_bytesize
* 设置 字节位数。
* @annotation ["scriptable"]
* @param {widget_t*} widget widget对象。
* @param {uint32_t} bytesize 字节位数。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t serial_widget_set_bytesize(widget_t* widget, uint32_t bytesize);
/**
* @method serial_widget_set_parity
* 设置 奇偶校验。
* @annotation ["scriptable"]
* @param {widget_t*} widget widget对象。
* @param {uint32_t} parity 奇偶校验。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t serial_widget_set_parity(widget_t* widget, uint32_t parity);
/**
* @method serial_widget_set_stopbits
* 设置 停止位。
* @annotation ["scriptable"]
* @param {widget_t*} widget widget对象。
* @param {uint32_t} stopbits 停止位。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t serial_widget_set_stopbits(widget_t* widget, uint32_t stopbits);
/**
* @method serial_widget_set_flowcontrol
* 设置 流控。
* @annotation ["scriptable"]
* @param {widget_t*} widget widget对象。
* @param {uint32_t} flowcontrol 流控。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t serial_widget_set_flowcontrol(widget_t* widget, uint32_t flowcontrol);
/**
* @method serial_widget_set_check_interval
* 设置 轮询时间(毫秒)。
* @annotation ["scriptable"]
* @param {widget_t*} widget widget对象。
* @param {uint32_t} check_interval 轮询时间（单位：ms）。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t serial_widget_set_check_interval(widget_t* widget, uint32_t check_interval);
#define SERIAL_WIDGET_PROP_BAUDRATE "baudrate"
#define SERIAL_WIDGET_PROP_DEVICE "device"
#define SERIAL_WIDGET_PROP_BYTESIZE "bytesize"
#define SERIAL_WIDGET_PROP_PARITY "parity"
#define SERIAL_WIDGET_PROP_STOPBITS "stopbits"
#define SERIAL_WIDGET_PROP_FLOWCONTROL "flowcontrol"
#define SERIAL_WIDGET_PROP_ISTREAM "istream"
#define SERIAL_WIDGET_PROP_OSTREAM "ostream"
#define SERIAL_WIDGET_PROP_IOSTREAM "iostream"
#define SERIAL_WIDGET_PROP_CHECK_INTERVAL "check_interval"
#define WIDGET_TYPE_SERIAL_WIDGET "serial"
#define SERIAL_WIDGET(widget) ((serial_widget_t*)(serial_widget_cast(WIDGET(widget))))
/*public for subclass and runtime type check*/
TK_EXTERN_VTABLE(serial_widget);
END_C_DECLS
#endif /*TK_SERIAL_WIDGET_H*/
|
0 |
repos/awtk/src/ext_widgets
|
repos/awtk/src/ext_widgets/file_browser/file_browser.h
|
/**
* File: file_browser.h
* Author: AWTK Develop Team
* Brief: file_browser
*
* Copyright (c) 2020 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2020-01-04 Li XianJing <[email protected]> created
*
*/
#ifndef TK_FILE_BROWSER_H
#define TK_FILE_BROWSER_H
#include "tkc/fs.h"
#include "tkc/str.h"
#include "tkc/buffer.h"
#include "tkc/darray.h"
#include "tkc/emitter.h"
BEGIN_C_DECLS
/**
* @class fb_item_t
* 文件或目录的信息。
*/
typedef struct _fb_item_t {
/**
* @property {char*} name
* @annotation ["readable"]
* 名称。
*/
char* name;
/**
* @property {bool_t} is_dir
* @annotation ["readable"]
* 是否是目录。
*/
bool_t is_dir;
/**
* @property {bool_t} is_reg_file
* @annotation ["readable"]
* 是否是常规文件。
*/
bool_t is_reg_file;
/**
* @property {uint64_t} size
* @annotation ["readable"]
* 文件大小。
*/
uint64_t size;
/**
* @property {uint64_t} atime
* @annotation ["readable"]
* 最后一次访问时间。
*/
uint64_t atime;
/**
* @property {uint64_t} mtime
* @annotation ["readable"]
* 最后修改时间。
*/
uint64_t mtime;
/**
* @property {uint64_t} ctime
* @annotation ["readable"]
* 创建时间。
*/
uint64_t ctime;
} fb_item_t;
/**
* @class file_browser_t
* 文件浏览器模型。
*/
typedef struct _file_browser_t {
/**
* @property {char*} cwd
* @annotation ["readable"]
* 当前路径。
*/
char cwd[MAX_PATH + 1];
/**
* @property {char*} top_dir
* @annotation ["readable"]
* 最顶层目录。到达本目录后，不允许往上。
*/
char* top_dir;
/*private*/
fs_t* fs;
fb_item_t* items;
uint32_t items_size;
uint32_t items_capacity;
void* filter_ctx;
tk_filter_t filter;
tk_compare_t compare;
bool_t ignore_hidden_files;
} file_browser_t;
/**
* @method file_browser_create
* 创建file_browser对象
* @annotation ["constructor"]
* @param {fs_t*} fs 文件系统对象。
*
* @return {file_browser_t*} 对象。
*/
file_browser_t* file_browser_create(fs_t* fs);
/**
* @method file_browser_set_cwd
* 设置当前目录。
* 目录支持变量：
* ```
* ${app_dir} -> app 文件目录。
* ${temp_dir} -> 临时文件目录。
* ${user_dir} -> 用户目录。
* ```
* @param {file_browser_t*} fb file browser对象。
* @param {const char*} cwd 当前目录。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t file_browser_set_cwd(file_browser_t* fb, const char* cwd);
/**
* @method file_browser_set_top_dir
* 设置顶层目录。
*
* 目录支持变量：
* ```
* ${app_dir} -> app 文件目录。
* ${temp_dir} -> 临时文件目录。
* ${user_dir} -> 用户目录。
* ```
* @param {file_browser_t*} fb file browser对象。
* @param {const char*} top_dir 顶层目录。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t file_browser_set_top_dir(file_browser_t* fb, const char* top_dir);
/**
* @method file_browser_create_dir
* 在当前目录下创建指定子目录。
*
* @param {file_browser_t*} fb file browser对象。
* @param {const char*} name 当前目录下的子目录名。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t file_browser_create_dir(file_browser_t* fb, const char* name);
/**
* @method file_browser_create_file
* 在当前目录下创建指定文件。
*
* @param {file_browser_t*} fb file browser对象。
* @param {const char*} name 当前目录下的文件名。
* @param {const void*} buff 文件内容。
* @param {uint32_t} size 文件内容的长度。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t file_browser_create_file(file_browser_t* fb, const char* name, const void* buff,
uint32_t size);
/**
* @method file_browser_remove
* 删除当前目录下的指定子目录或文件。
*
* @param {file_browser_t*} fb file browser对象。
* @param {const char*} name 当前目录下的子目录名/文件名。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t file_browser_remove(file_browser_t* fb, const char* name);
/**
* @method file_browser_enter
* 进入当前目录下的指定子目录。
*
* @param {file_browser_t*} fb file browser对象。
* @param {const char*} dir 当前目录下的子目录名。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t file_browser_enter(file_browser_t* fb, const char* dir);
/**
* @method file_browser_up
* 返回上一级目录。
*
* @param {file_browser_t*} fb file browser对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t file_browser_up(file_browser_t* fb);
/**
* @method file_browser_refresh
* 刷新。
*
* @param {file_browser_t*} fb file browser对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t file_browser_refresh(file_browser_t* fb);
/**
* @method file_browser_set_filter
* 设置过滤函数。
*
* @param {file_browser_t*} fb file browser对象。
* @param {tk_filter_t} filter 过滤函数。
* @param {void*} ctx 过滤函数的上下文。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t file_browser_set_filter(file_browser_t* fb, tk_filter_t filter, void* ctx);
/**
* @method file_browser_set_compare
* 设置排序用的比较函数。
*
* @param {file_browser_t*} fb file browser对象。
* @param {tk_compare_t} compare 排序用的比较函数。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t file_browser_set_compare(file_browser_t* fb, tk_compare_t compare);
/**
* @method file_browser_sort_by_name
* 按名称排序。
*
* @param {file_browser_t*} fb file browser对象。
* @param {bool_t} ascending 按升序排。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t file_browser_sort_by_name(file_browser_t* fb, bool_t ascending);
/**
* @method file_browser_sort_by_type
* 按类型排序。
*
* @param {file_browser_t*} fb file browser对象。
* @param {bool_t} ascending 按升序排。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t file_browser_sort_by_type(file_browser_t* fb, bool_t ascending);
/**
* @method file_browser_sort_by_size
* 按大小排序。
*
* @param {file_browser_t*} fb file browser对象。
* @param {bool_t} ascending 按升序排。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t file_browser_sort_by_size(file_browser_t* fb, bool_t ascending);
/**
* @method file_browser_sort_by_mtime
* 按修改时间排序。
*
* @param {file_browser_t*} fb file browser对象。
* @param {bool_t} ascending 按升序排。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t file_browser_sort_by_mtime(file_browser_t* fb, bool_t ascending);
/**
* @method file_browser_get_items_nr
* 获取当前目录下文件项个数。
*
* @param {file_browser_t*} fb file browser对象。
*
* @return {uint32_t} 返回当前目录下文件项个数。
*/
uint32_t file_browser_get_items_nr(file_browser_t* fb);
/**
* @method file_browser_get_item
* 获取指定项序数的项目。
*
* @param {file_browser_t*} fb file browser对象。
* @param {uint32_t} index 序数。
*
* @return {fb_item_t*} 返回指定项序数的项目。
*/
fb_item_t* file_browser_get_item(file_browser_t* fb, uint32_t index);
/**
* @method file_browser_set_ignore_hidden_files
* 设置是否忽略隐藏文件。
*
* @param {file_browser_t*} fb file browser对象。
* @param {bool_t} ignore_hidden_files 是否忽略隐藏文件。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t file_browser_set_ignore_hidden_files(file_browser_t* fb, bool_t ignore_hidden_files);
/**
* @method file_browser_destroy
* 销毁file_browser对象
*
* @param {file_browser_t*} fb file browser对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t file_browser_destroy(file_browser_t* fb);
/*public for test*/
bool_t fb_filter_files_only(void* ctx, const void* data);
bool_t fb_filter_by_ext_names(void* ctx, const void* data);
bool_t fb_filter_directories_only(void* ctx, const void* data);
int fb_compare_by_name(const void* a, const void* b);
int fb_compare_by_type(const void* a, const void* b);
int fb_compare_by_size(const void* a, const void* b);
int fb_compare_by_mtime(const void* a, const void* b);
int fb_compare_by_name_dec(const void* a, const void* b);
int fb_compare_by_type_dec(const void* a, const void* b);
int fb_compare_by_size_dec(const void* a, const void* b);
int fb_compare_by_mtime_dec(const void* a, const void* b);
END_C_DECLS
#endif /*TK_FILE_BROWSER_H*/
|
0 |
repos/awtk/src/ext_widgets
|
repos/awtk/src/ext_widgets/file_browser/file_browser_view.c
|
/**
* File: file_browser_view.c
* Author: AWTK Develop Team
* Brief: file manager/browser/choosor
*
* Copyright (c) 2020 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2020-01-08 Li XianJing <[email protected]> created
*
*/
#include "tkc/mem.h"
#include "tkc/utils.h"
#include "file_browser_view.h"
#include "base/date_time_format.h"
#define SORT_BY_NAME "name"
#define SORT_BY_TYPE "type"
#define SORT_BY_SIZE "size"
#define SORT_BY_MTIME "mtime"
#ifndef FB_DATE_TIME_FORMAT
#define FB_DATE_TIME_FORMAT "YY-MM-DD hh:mm:ss"
#endif /*FB_DATE_TIME_FORMAT*/
ret_t file_browser_view_reload(widget_t* widget);
ret_t file_browser_view_set_top_dir(widget_t* widget, const char* top_dir) {
file_browser_view_t* file_browser_view = FILE_BROWSER_VIEW(widget);
return_value_if_fail(file_browser_view != NULL, RET_BAD_PARAMS);
file_browser_view->top_dir = tk_str_copy(file_browser_view->top_dir, top_dir);
file_browser_set_top_dir(file_browser_view->fb, top_dir);
return RET_OK;
}
ret_t file_browser_view_set_init_dir(widget_t* widget, const char* init_dir) {
file_browser_view_t* file_browser_view = FILE_BROWSER_VIEW(widget);
return_value_if_fail(file_browser_view != NULL, RET_BAD_PARAMS);
file_browser_view->init_dir = tk_str_copy(file_browser_view->init_dir, init_dir);
file_browser_set_cwd(file_browser_view->fb, init_dir);
return RET_OK;
}
ret_t file_browser_view_set_filter(widget_t* widget, const char* filter) {
file_browser_view_t* file_browser_view = FILE_BROWSER_VIEW(widget);
return_value_if_fail(file_browser_view != NULL && filter != NULL, RET_BAD_PARAMS);
file_browser_view->filter = tk_str_copy(file_browser_view->filter, filter);
if (tk_str_eq(filter, STR_FILTER_FILES_ONLY)) {
file_browser_set_filter(file_browser_view->fb, fb_filter_files_only, NULL);
} else if (tk_str_eq(filter, STR_FILTER_DIR_ONLY)) {
file_browser_set_filter(file_browser_view->fb, fb_filter_directories_only, NULL);
} else if (filter != NULL) {
file_browser_set_filter(file_browser_view->fb, fb_filter_by_ext_names,
file_browser_view->filter);
} else {
file_browser_set_filter(file_browser_view->fb, NULL, NULL);
}
return RET_OK;
}
static ret_t file_browser_view_sync_sort(widget_t* widget) {
const char* sort_by = NULL;
bool_t sort_ascending = FALSE;
file_browser_view_t* file_browser_view = FILE_BROWSER_VIEW(widget);
return_value_if_fail(file_browser_view != NULL, RET_BAD_PARAMS);
sort_by = file_browser_view->sort_by;
sort_ascending = file_browser_view->sort_ascending;
if (sort_by != NULL) {
if (tk_str_eq(sort_by, SORT_BY_NAME)) {
file_browser_sort_by_name(file_browser_view->fb, sort_ascending);
} else if (tk_str_eq(sort_by, SORT_BY_SIZE)) {
file_browser_sort_by_name(file_browser_view->fb, sort_ascending);
} else if (tk_str_eq(sort_by, SORT_BY_MTIME)) {
file_browser_sort_by_mtime(file_browser_view->fb, sort_ascending);
} else if (tk_str_eq(sort_by, SORT_BY_TYPE)) {
file_browser_sort_by_type(file_browser_view->fb, sort_ascending);
}
}
return RET_OK;
}
ret_t file_browser_view_set_ignore_hidden_files(widget_t* widget, bool_t ignore_hidden_files) {
file_browser_view_t* file_browser_view = FILE_BROWSER_VIEW(widget);
return_value_if_fail(file_browser_view != NULL, RET_BAD_PARAMS);
file_browser_view->ignore_hidden_files = ignore_hidden_files;
file_browser_set_ignore_hidden_files(file_browser_view->fb, ignore_hidden_files);
return RET_OK;
}
ret_t file_browser_view_set_sort_ascending(widget_t* widget, bool_t sort_ascending) {
file_browser_view_t* file_browser_view = FILE_BROWSER_VIEW(widget);
return_value_if_fail(file_browser_view != NULL, RET_BAD_PARAMS);
file_browser_view->sort_ascending = sort_ascending;
file_browser_view_sync_sort(widget);
return RET_OK;
}
ret_t file_browser_view_set_show_check_button(widget_t* widget, bool_t show_check_button) {
file_browser_view_t* file_browser_view = FILE_BROWSER_VIEW(widget);
return_value_if_fail(file_browser_view != NULL, RET_BAD_PARAMS);
file_browser_view->show_check_button = show_check_button;
file_browser_view_reload(widget);
return RET_OK;
}
ret_t file_browser_view_set_sort_by(widget_t* widget, const char* sort_by) {
file_browser_view_t* file_browser_view = FILE_BROWSER_VIEW(widget);
return_value_if_fail(file_browser_view != NULL, RET_BAD_PARAMS);
file_browser_view->sort_by = tk_str_copy(file_browser_view->sort_by, sort_by);
file_browser_view_sync_sort(widget);
return RET_OK;
}
ret_t file_browser_view_set_odd_item_style(widget_t* widget, const char* odd_item_style) {
file_browser_view_t* file_browser_view = FILE_BROWSER_VIEW(widget);
return_value_if_fail(file_browser_view != NULL, RET_BAD_PARAMS);
file_browser_view->odd_item_style =
tk_str_copy(file_browser_view->odd_item_style, odd_item_style);
return RET_OK;
}
ret_t file_browser_view_set_even_item_style(widget_t* widget, const char* even_item_style) {
file_browser_view_t* file_browser_view = FILE_BROWSER_VIEW(widget);
return_value_if_fail(file_browser_view != NULL, RET_BAD_PARAMS);
file_browser_view->even_item_style =
tk_str_copy(file_browser_view->even_item_style, even_item_style);
return RET_OK;
}
static ret_t file_browser_view_get_prop(widget_t* widget, const char* name, value_t* v) {
file_browser_view_t* file_browser_view = FILE_BROWSER_VIEW(widget);
return_value_if_fail(file_browser_view != NULL && name != NULL && v != NULL, RET_BAD_PARAMS);
if (tk_str_eq(FILE_BROWSER_VIEW_PROP_INIT_DIR, name)) {
value_set_str(v, file_browser_view->init_dir);
return RET_OK;
} else if (tk_str_eq(FILE_BROWSER_VIEW_PROP_TOP_DIR, name)) {
value_set_str(v, file_browser_view->top_dir);
return RET_OK;
} else if (tk_str_eq(FILE_BROWSER_VIEW_PROP_IGNORE_HIDDEN_FILES, name)) {
value_set_bool(v, file_browser_view->ignore_hidden_files);
return RET_OK;
} else if (tk_str_eq(FILE_BROWSER_VIEW_PROP_SORT_ASCENDING, name)) {
value_set_bool(v, file_browser_view->sort_ascending);
return RET_OK;
} else if (tk_str_eq(FILE_BROWSER_VIEW_PROP_SHOW_CHECK_BUTTON, name)) {
value_set_bool(v, file_browser_view->show_check_button);
return RET_OK;
} else if (tk_str_eq(FILE_BROWSER_VIEW_PROP_SORT_BY, name)) {
value_set_str(v, file_browser_view->sort_by);
return RET_OK;
} else if (tk_str_eq(FILE_BROWSER_VIEW_PROP_ODD_ITEM_STYLE, name)) {
value_set_str(v, file_browser_view->odd_item_style);
return RET_OK;
} else if (tk_str_eq(FILE_BROWSER_VIEW_PROP_EVEN_ITEM_STYLE, name)) {
value_set_str(v, file_browser_view->even_item_style);
return RET_OK;
}
return RET_NOT_FOUND;
}
static ret_t file_browser_view_set_prop(widget_t* widget, const char* name, const value_t* v) {
return_value_if_fail(widget != NULL && name != NULL && v != NULL, RET_BAD_PARAMS);
if (tk_str_eq(FILE_BROWSER_VIEW_PROP_INIT_DIR, name)) {
file_browser_view_set_init_dir(widget, value_str(v));
return RET_OK;
} else if (tk_str_eq(FILE_BROWSER_VIEW_PROP_TOP_DIR, name)) {
file_browser_view_set_top_dir(widget, value_str(v));
return RET_OK;
} else if (tk_str_eq(FILE_BROWSER_VIEW_PROP_IGNORE_HIDDEN_FILES, name)) {
file_browser_view_set_ignore_hidden_files(widget, value_bool(v));
return RET_OK;
} else if (tk_str_eq(FILE_BROWSER_VIEW_PROP_SORT_ASCENDING, name)) {
file_browser_view_set_sort_ascending(widget, value_bool(v));
return RET_OK;
} else if (tk_str_eq(FILE_BROWSER_VIEW_PROP_SHOW_CHECK_BUTTON, name)) {
file_browser_view_set_show_check_button(widget, value_bool(v));
return RET_OK;
} else if (tk_str_eq(FILE_BROWSER_VIEW_PROP_SORT_BY, name)) {
file_browser_view_set_sort_by(widget, value_str(v));
return RET_OK;
} else if (tk_str_eq(FILE_BROWSER_VIEW_PROP_ODD_ITEM_STYLE, name)) {
file_browser_view_set_odd_item_style(widget, value_str(v));
return RET_OK;
} else if (tk_str_eq(FILE_BROWSER_VIEW_PROP_EVEN_ITEM_STYLE, name)) {
file_browser_view_set_even_item_style(widget, value_str(v));
return RET_OK;
}
return RET_NOT_FOUND;
}
static ret_t file_browser_view_on_destroy(widget_t* widget) {
file_browser_view_t* file_browser_view = FILE_BROWSER_VIEW(widget);
return_value_if_fail(widget != NULL && file_browser_view != NULL, RET_BAD_PARAMS);
TKMEM_FREE(file_browser_view->filter);
TKMEM_FREE(file_browser_view->sort_by);
TKMEM_FREE(file_browser_view->init_dir);
TKMEM_FREE(file_browser_view->top_dir);
TKMEM_FREE(file_browser_view->odd_item_style);
TKMEM_FREE(file_browser_view->even_item_style);
file_browser_destroy(file_browser_view->fb);
widget_destroy(file_browser_view->file_template);
widget_destroy(file_browser_view->folder_template);
darray_deinit(&(file_browser_view->selected_items));
darray_deinit(&(file_browser_view->file_items_cache));
darray_deinit(&(file_browser_view->folder_items_cache));
return RET_OK;
}
static ret_t file_browser_view_on_paint_self(widget_t* widget, canvas_t* c) {
file_browser_view_t* file_browser_view = FILE_BROWSER_VIEW(widget);
(void)file_browser_view;
return RET_OK;
}
static ret_t file_browser_view_reload_in_idle(const idle_info_t* info) {
widget_t* widget = WIDGET(info->ctx);
file_browser_view_reload(widget);
return RET_REMOVE;
}
static ret_t file_browser_view_on_item_clicked(void* ctx, event_t* e) {
value_change_event_t changed;
widget_t* target = WIDGET(e->target);
file_browser_view_t* file_browser_view = FILE_BROWSER_VIEW(ctx);
return_value_if_fail(target != NULL && file_browser_view != NULL, RET_BAD_PARAMS);
if (tk_str_eq(target->name, FILE_BROWSER_VIEW_RETURN_UP)) {
file_browser_up(file_browser_view->fb);
widget_add_idle(WIDGET(file_browser_view), file_browser_view_reload_in_idle);
} else if (tk_str_eq(target->name, FILE_BROWSER_VIEW_FOLDER)) {
uint32_t index = widget_index_of(target);
fb_item_t* info = file_browser_get_item(file_browser_view->fb, index - 1);
return_value_if_fail(info != NULL, RET_FAIL);
file_browser_enter(file_browser_view->fb, info->name);
widget_add_idle(WIDGET(file_browser_view), file_browser_view_reload_in_idle);
} else {
uint32_t index = widget_index_of(target);
fb_item_t* info = file_browser_get_item(file_browser_view->fb, index - 1);
return_value_if_fail(info != NULL, RET_FAIL);
if (file_browser_view->selected_file != NULL) {
widget_set_text_utf8(file_browser_view->selected_file, info->name);
}
}
value_change_event_init(&changed, EVT_VALUE_CHANGED, ctx);
value_set_str(&(changed.new_value), file_browser_view->fb->cwd);
widget_dispatch(WIDGET(ctx), (event_t*)&changed);
log_debug("cwd: %s\n", value_str(&(changed.new_value)));
return RET_OK;
}
static ret_t file_browser_view_recycle_items(widget_t* widget) {
widget_t* container = NULL;
darray_t* file_items_cache = NULL;
darray_t* folder_items_cache = NULL;
file_browser_view_t* file_browser_view = FILE_BROWSER_VIEW(widget);
return_value_if_fail(file_browser_view != NULL, RET_BAD_PARAMS);
container = file_browser_view->container;
file_items_cache = &(file_browser_view->file_items_cache);
folder_items_cache = &(file_browser_view->folder_items_cache);
if (container != NULL && container->children != NULL) {
WIDGET_FOR_EACH_CHILD_BEGIN(container, iter, i)
widget_remove_child_prepare(container, iter);
if (tk_str_eq(iter->name, FILE_BROWSER_VIEW_FILE)) {
darray_push(file_items_cache, iter);
} else if (tk_str_eq(iter->name, FILE_BROWSER_VIEW_FOLDER)) {
darray_push(folder_items_cache, iter);
}
container->children->elms[i] = NULL;
WIDGET_FOR_EACH_CHILD_END();
container->children->size = 0;
}
return RET_OK;
}
static widget_t* file_browser_view_create_file_item(widget_t* widget) {
widget_t* item = NULL;
darray_t* cache = NULL;
widget_t* container = NULL;
file_browser_view_t* file_browser_view = FILE_BROWSER_VIEW(widget);
return_value_if_fail(file_browser_view != NULL, NULL);
container = file_browser_view->container;
cache = &(file_browser_view->file_items_cache);
if (cache->size > 0) {
item = WIDGET(darray_pop(cache));
widget_add_child(container, item);
} else {
item = widget_clone(file_browser_view->file_template, container);
widget_on(item, EVT_CLICK, file_browser_view_on_item_clicked, widget);
}
return item;
}
static widget_t* file_browser_view_create_folder_item(widget_t* widget) {
widget_t* item = NULL;
darray_t* cache = NULL;
widget_t* container = NULL;
file_browser_view_t* file_browser_view = FILE_BROWSER_VIEW(widget);
return_value_if_fail(file_browser_view != NULL, NULL);
container = file_browser_view->container;
cache = &(file_browser_view->folder_items_cache);
if (cache->size > 0) {
item = WIDGET(darray_pop(cache));
widget_add_child(container, item);
} else {
item = widget_clone(file_browser_view->folder_template, container);
widget_on(item, EVT_CLICK, file_browser_view_on_item_clicked, widget);
}
return item;
}
static ret_t file_browser_view_item_set_style(file_browser_view_t* file_browser_view,
widget_t* item, bool_t odd) {
ret_t ret = RET_OK;
return_value_if_fail(file_browser_view != NULL && item != NULL, RET_BAD_PARAMS);
if (odd) {
if (file_browser_view->odd_item_style != NULL) {
ret = widget_use_style(item, file_browser_view->odd_item_style);
}
} else {
if (file_browser_view->even_item_style != NULL) {
ret = widget_use_style(item, file_browser_view->even_item_style);
}
}
return ret;
}
ret_t file_browser_view_reload(widget_t* widget) {
uint32_t i = 0;
uint32_t nr = 0;
widget_t* item = NULL;
widget_t* item_child = NULL;
file_browser_view_t* file_browser_view = FILE_BROWSER_VIEW(widget);
widget_t* container = file_browser_view != NULL ? file_browser_view->container : NULL;
return_value_if_fail(container != NULL && file_browser_view != NULL, RET_BAD_PARAMS);
file_browser_view_recycle_items(widget);
if (file_browser_view->cwd != NULL) {
widget_set_text_utf8(file_browser_view->cwd, file_browser_view->fb->cwd);
}
item = file_browser_view->return_up_template;
widget_add_child(container, item);
nr = file_browser_get_items_nr(file_browser_view->fb);
for (i = 0; i < nr; i++) {
fb_item_t* info = file_browser_get_item(file_browser_view->fb, i);
if (info->is_dir) {
item = file_browser_view_create_folder_item(widget);
} else {
value_t v;
char prop[TK_NAME_LEN + 1];
const char* ext = strrchr(info->name, '.');
item = file_browser_view_create_file_item(widget);
item_child = widget_lookup(item, FILE_BROWSER_VIEW_ICON, TRUE);
if (item_child != NULL && ext != NULL) {
ext++;
tk_snprintf(prop, sizeof(prop), "icon_%s", ext);
if (widget_get_prop(widget, prop, &v) == RET_OK && value_str(&v) != NULL) {
widget_set_prop_str(item_child, WIDGET_PROP_IMAGE, value_str(&v));
}
}
}
item_child = widget_lookup(item, FILE_BROWSER_VIEW_NAME, TRUE);
if (item_child != NULL) {
widget_set_text_utf8(item_child, info->name);
}
item_child = widget_lookup(item, FILE_BROWSER_VIEW_SIZE, TRUE);
if (item_child != NULL) {
wstr_t* str = &(item_child->text);
wstr_from_int(str, info->size);
}
item_child = widget_lookup(item, FILE_BROWSER_VIEW_MTIME, TRUE);
if (item_child != NULL) {
wstr_t* str = &(item_child->text);
wstr_format_time(str, FB_DATE_TIME_FORMAT, info->mtime);
}
item_child = widget_lookup(item, FILE_BROWSER_VIEW_CTIME, TRUE);
if (item_child != NULL) {
wstr_t* str = &(item_child->text);
wstr_format_time(str, FB_DATE_TIME_FORMAT, info->ctime);
}
item_child = widget_lookup_by_type(item, WIDGET_TYPE_CHECK_BUTTON, TRUE);
if (item_child != NULL) {
widget_set_visible(item_child, file_browser_view->show_check_button, FALSE);
}
}
WIDGET_FOR_EACH_CHILD_BEGIN(container, item, item_index)
file_browser_view_item_set_style(file_browser_view, item, item_index % 2);
WIDGET_FOR_EACH_CHILD_END()
widget_layout(widget);
return RET_OK;
}
static ret_t file_browser_view_init_ui(widget_t* widget) {
widget_t* template = NULL;
widget_t* container = NULL;
file_browser_view_t* file_browser_view = FILE_BROWSER_VIEW(widget);
return_value_if_fail(file_browser_view != NULL, RET_BAD_PARAMS);
container = widget_lookup(widget, FILE_BROWSER_VIEW_CONTAINER, TRUE);
return_value_if_fail(container != NULL, RET_BAD_PARAMS);
file_browser_view->container = container;
file_browser_view->cwd = widget_lookup(widget, FILE_BROWSER_VIEW_CWD, TRUE);
file_browser_view->selected_file = widget_lookup(widget, FILE_BROWSER_VIEW_SELECTED_FILE, TRUE);
template = widget_lookup(container, FILE_BROWSER_VIEW_FILE, TRUE);
return_value_if_fail(template != NULL, RET_BAD_PARAMS);
file_browser_view->file_template = template;
widget_remove_child(template->parent, template);
template = widget_lookup(container, FILE_BROWSER_VIEW_FOLDER, TRUE);
return_value_if_fail(template != NULL, RET_BAD_PARAMS);
file_browser_view->folder_template = template;
widget_remove_child(template->parent, template);
template = widget_lookup(container, FILE_BROWSER_VIEW_RETURN_UP, TRUE);
return_value_if_fail(template != NULL, RET_BAD_PARAMS);
file_browser_view->return_up_template = template;
widget_remove_child(template->parent, template);
widget_on(template, EVT_CLICK, file_browser_view_on_item_clicked, widget);
file_browser_view->inited = TRUE;
return RET_OK;
}
static ret_t file_browser_view_on_event(widget_t* widget, event_t* e) {
file_browser_view_t* file_browser_view = FILE_BROWSER_VIEW(widget);
return_value_if_fail(widget != NULL && file_browser_view != NULL, RET_BAD_PARAMS);
switch (e->type) {
case EVT_WIDGET_LOAD: {
file_browser_view_init_ui(widget);
break;
}
}
return RET_OK;
}
static ret_t file_browser_view_init(widget_t* widget) {
file_browser_view_t* file_browser_view = FILE_BROWSER_VIEW(widget);
return_value_if_fail(file_browser_view != NULL, RET_BAD_PARAMS);
file_browser_view->sort_ascending = TRUE;
file_browser_view->show_check_button = FALSE;
file_browser_view->ignore_hidden_files = TRUE;
file_browser_view->fb = file_browser_create(os_fs());
darray_init(&(file_browser_view->selected_items), 10, NULL, NULL);
darray_init(&(file_browser_view->file_items_cache), 10, (tk_destroy_t)widget_unref, NULL);
darray_init(&(file_browser_view->folder_items_cache), 10, (tk_destroy_t)widget_unref, NULL);
return RET_OK;
}
const char* s_file_browser_view_properties[] = {
FILE_BROWSER_VIEW_PROP_SORT_BY, FILE_BROWSER_VIEW_PROP_INIT_DIR,
FILE_BROWSER_VIEW_PROP_SORT_ASCENDING, FILE_BROWSER_VIEW_PROP_IGNORE_HIDDEN_FILES, NULL};
TK_DECL_VTABLE(file_browser_view) = {.size = sizeof(file_browser_view_t),
.type = WIDGET_TYPE_FILE_BROWSER_VIEW,
.clone_properties = s_file_browser_view_properties,
.persistent_properties = s_file_browser_view_properties,
.get_parent_vt = TK_GET_PARENT_VTABLE(widget),
.create = file_browser_view_create,
.init = file_browser_view_init,
.on_paint_self = file_browser_view_on_paint_self,
.set_prop = file_browser_view_set_prop,
.get_prop = file_browser_view_get_prop,
.on_event = file_browser_view_on_event,
.on_destroy = file_browser_view_on_destroy};
widget_t* file_browser_view_create(widget_t* parent, xy_t x, xy_t y, wh_t w, wh_t h) {
widget_t* widget = widget_create(parent, TK_REF_VTABLE(file_browser_view), x, y, w, h);
return_value_if_fail(file_browser_view_init(widget) == RET_OK, NULL);
return widget;
}
widget_t* file_browser_view_cast(widget_t* widget) {
return_value_if_fail(WIDGET_IS_INSTANCE_OF(widget, file_browser_view), NULL);
return widget;
}
#include "base/widget_factory.h"
ret_t file_browser_view_register(void) {
return widget_factory_register(widget_factory(), WIDGET_TYPE_FILE_BROWSER_VIEW,
file_browser_view_create);
}
darray_t* file_browser_view_get_selected_items(widget_t* widget) {
darray_t* arr = NULL;
widget_t* container = NULL;
file_browser_view_t* file_browser_view = FILE_BROWSER_VIEW(widget);
return_value_if_fail(file_browser_view != NULL, NULL);
container = file_browser_view->container;
arr = &(file_browser_view->selected_items);
darray_clear(arr);
if (container->children != NULL) {
WIDGET_FOR_EACH_CHILD_BEGIN(container, iter, i)
if (i > 0) {
widget_t* checkable = widget_lookup_by_type(iter, WIDGET_TYPE_CHECK_BUTTON, TRUE);
if (checkable != NULL && widget_get_value(checkable)) {
fb_item_t* info = file_browser_get_item(file_browser_view->fb, i - 1);
darray_push(arr, info);
}
}
WIDGET_FOR_EACH_CHILD_END();
}
return arr;
}
const char* file_browser_view_get_cwd(widget_t* widget) {
file_browser_view_t* file_browser_view = FILE_BROWSER_VIEW(widget);
return_value_if_fail(file_browser_view != NULL, NULL);
return file_browser_view->fb->cwd;
}
ret_t file_browser_view_create_dir(widget_t* widget, const char* name) {
file_browser_view_t* file_browser_view = FILE_BROWSER_VIEW(widget);
return_value_if_fail(file_browser_view != NULL, RET_BAD_PARAMS);
return file_browser_create_dir(file_browser_view->fb, name);
}
ret_t file_browser_view_create_file(widget_t* widget, const char* name, const char* data,
uint32_t size) {
file_browser_view_t* file_browser_view = FILE_BROWSER_VIEW(widget);
return_value_if_fail(file_browser_view != NULL, RET_BAD_PARAMS);
return file_browser_create_file(file_browser_view->fb, name, data, size);
}
|
0 |
repos/awtk/src/ext_widgets
|
repos/awtk/src/ext_widgets/file_browser/file_dialog.h
|
/**
* File: file_dialog.h
* Author: AWTK Develop Team
* Brief: 文件对话框。
*
* Copyright (c) Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2022-05-18 Li XianJing <[email protected]> created
*
*/
#ifndef TK_FILE_DIALOG_H
#define TK_FILE_DIALOG_H
#include "tkc.h"
BEGIN_C_DECLS
/**
* @class file_dialog_t
* @annotation ["fake"]
* 文件对话框。
*/
/**
* @method tk_choose_files
* 多选文件，用完后请调用darray_destroy销毁返回的数组。
* @param {const char*} filters 过滤规则(文件扩展名列表,如:".c.cpp.cxx")。
* @param {const char*} init_dir 初始目录。
*
* @return {darray_t*} 返回NULL表示失败，返回非NULL为文件名列表。
*/
darray_t* tk_choose_files(const char* filters, const char* init_dir);
/**
* @method tk_choose_file
* 选择单个文件，用完后请调用TKMEM_FREE销毁返回的字符串。
* @param {const char*} filters 过滤规则(文件扩展名列表,如:".c.cpp.cxx")。
* @param {const char*} init_dir 初始目录。
*
* @return {char*} 返回NULL表示失败，返回非NULL为文件名。
*/
char* tk_choose_file(const char* filters, const char* init_dir);
/**
* @method tk_choose_folder
* 选择单个目录，用完后请调用TKMEM_FREE销毁返回的字符串。
* @param {const char*} init_dir 初始目录。
*
* @return {char*} 返回NULL表示失败，返回非NULL为文件名。
*/
char* tk_choose_folder(const char* init_dir);
/**
* @method tk_choose_file_for_save
* 选择单个文件用于保存，用完后请调用TKMEM_FREE销毁返回的字符串。
* @param {const char*} filters 过滤规则(文件扩展名列表,如:".c.cpp.cxx")。
* @param {const char*} init_dir 初始目录。
*
* @return {char*} 返回NULL表示失败，返回非NULL为文件名。
*/
char* tk_choose_file_for_save(const char* filters, const char* init_dir);
END_C_DECLS
#endif /*TK_FILE_DIALOG_H*/
|
0 |
repos/awtk/src/ext_widgets
|
repos/awtk/src/ext_widgets/file_browser/file_chooser.c
|
/**
* File: file_chooser.c
* Author: AWTK Develop Team
* Brief: file/folder choosers
*
* Copyright (c) 2020 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2020-01-12 Li XianJing <[email protected]> created
*
*/
#include "tkc/mem.h"
#include "tkc/utils.h"
#include "base/widget.h"
#include "base/dialog.h"
#include "base/window.h"
#include "file_browser/file_chooser.h"
#include "file_browser/file_browser_view.h"
file_chooser_t* file_chooser_create(void) {
file_chooser_t* chooser = TKMEM_ZALLOC(file_chooser_t);
return_value_if_fail(chooser != NULL, NULL);
emitter_init(EMITTER(chooser));
str_init(&(chooser->cwd), 0);
str_init(&(chooser->filename), 0);
return chooser;
}
ret_t file_chooser_set_init_dir(file_chooser_t* chooser, const char* init_dir) {
return_value_if_fail(chooser != NULL, RET_BAD_PARAMS);
chooser->init_dir = tk_str_copy(chooser->init_dir, init_dir);
return RET_OK;
}
ret_t file_chooser_set_top_dir(file_chooser_t* chooser, const char* top_dir) {
return_value_if_fail(chooser != NULL, RET_BAD_PARAMS);
chooser->top_dir = tk_str_copy(chooser->top_dir, top_dir);
return RET_OK;
}
ret_t file_chooser_set_filter(file_chooser_t* chooser, const char* filter) {
return_value_if_fail(chooser != NULL, RET_BAD_PARAMS);
chooser->filter = tk_str_copy(chooser->filter, filter);
return RET_OK;
}
file_chooser_t* file_chooser_cast(file_chooser_t* chooser) {
return (file_chooser_t*)chooser;
}
static ret_t file_choose_on_click_to_close(void* ctx, event_t* e) {
done_event_t done;
widget_t* win = widget_get_window(WIDGET(e->target));
file_chooser_t* chooser = (file_chooser_t*)ctx;
chooser->aborted = TRUE;
emitter_dispatch(EMITTER(chooser), done_event_init(&done, RET_OK));
if (widget_is_dialog(win)) {
dialog_quit(win, DIALOG_QUIT_CANCEL);
} else {
widget_close_window(win);
}
file_chooser_destroy(chooser);
return RET_OK;
}
static ret_t file_choose_on_ok(void* ctx, event_t* e) {
done_event_t done;
widget_t* win = widget_get_window(WIDGET(e->target));
file_chooser_t* chooser = (file_chooser_t*)ctx;
widget_t* widget = widget_lookup_by_type(win, WIDGET_TYPE_FILE_BROWSER_VIEW, TRUE);
widget_t* selected_file = widget_lookup(widget, FILE_BROWSER_VIEW_SELECTED_FILE, TRUE);
str_set(&(chooser->cwd), file_browser_view_get_cwd(widget));
if (selected_file != NULL) {
str_from_wstr(&(chooser->filename), selected_file->text.str);
}
chooser->aborted = FALSE;
if (emitter_dispatch(EMITTER(chooser), done_event_init(&done, RET_OK)) == RET_OK) {
if (widget_is_dialog(win)) {
dialog_quit(win, DIALOG_QUIT_OK);
} else {
widget_close_window(win);
}
file_chooser_destroy(chooser);
}
return RET_OK;
}
static ret_t file_choose_on_selected_file_changed(void* ctx, event_t* e) {
widget_t* win = WIDGET(ctx);
widget_t* selected_file = WIDGET(e->target);
widget_t* ok = widget_lookup(win, FILE_CHOOSER_OK, TRUE);
if (ok != NULL) {
const wchar_t* text = widget_get_text(selected_file);
widget_set_enable(ok, TK_STR_IS_NOT_EMPTY(text));
}
return RET_OK;
}
ret_t file_chooser_choose(file_chooser_t* chooser) {
widget_t* win = window_open(chooser->ui);
widget_t* file_browser_view = widget_lookup_by_type(win, WIDGET_TYPE_FILE_BROWSER_VIEW, TRUE);
widget_t* selected_file = widget_lookup(win, FILE_BROWSER_VIEW_SELECTED_FILE, TRUE);
widget_child_on(win, FILE_CHOOSER_OK, EVT_CLICK, file_choose_on_ok, chooser);
widget_child_on(win, FILE_CHOOSER_CANCEL, EVT_CLICK, file_choose_on_click_to_close, chooser);
widget_child_on(win, FILE_CHOOSER_CLOSE, EVT_CLICK, file_choose_on_click_to_close, chooser);
widget_on(selected_file, EVT_VALUE_CHANGED, file_choose_on_selected_file_changed, win);
widget_dispatch_simple_event(selected_file, EVT_VALUE_CHANGED);
if (chooser->init_dir != NULL || chooser->filter != NULL) {
if (chooser->filter != NULL) {
file_browser_view_set_filter(file_browser_view, chooser->filter);
}
if (chooser->init_dir != NULL) {
file_browser_view_set_init_dir(file_browser_view, chooser->init_dir);
}
}
if (chooser->top_dir != NULL) {
file_browser_view_set_top_dir(file_browser_view, chooser->top_dir);
}
file_browser_view_reload(file_browser_view);
if (widget_is_dialog(win)) {
dialog_modal(win);
}
return RET_OK;
}
ret_t file_chooser_choose_file_for_save(file_chooser_t* chooser) {
return_value_if_fail(chooser != NULL, RET_BAD_PARAMS);
chooser->ui = FILE_CHOOSER_UI_CHOOSE_FILE_FOR_SAVE;
return file_chooser_choose(chooser);
}
ret_t file_chooser_choose_file_for_open(file_chooser_t* chooser) {
return_value_if_fail(chooser != NULL, RET_BAD_PARAMS);
chooser->ui = FILE_CHOOSER_UI_CHOOSE_FILE_FOR_OPEN;
return file_chooser_choose(chooser);
}
ret_t file_chooser_choose_folder(file_chooser_t* chooser) {
return_value_if_fail(chooser != NULL, RET_BAD_PARAMS);
chooser->ui = FILE_CHOOSER_UI_CHOOSE_FOLDER;
file_chooser_set_filter(chooser, STR_FILTER_DIR_ONLY);
return file_chooser_choose(chooser);
}
const char* file_chooser_get_dir(file_chooser_t* chooser) {
return_value_if_fail(chooser != NULL, NULL);
return chooser->cwd.str;
}
const char* file_chooser_get_filename(file_chooser_t* chooser) {
return_value_if_fail(chooser != NULL, NULL);
return chooser->filename.str;
}
bool_t file_chooser_is_aborted(file_chooser_t* chooser) {
return_value_if_fail(chooser != NULL, FALSE);
return chooser->aborted;
}
ret_t file_chooser_destroy(file_chooser_t* chooser) {
return_value_if_fail(chooser != NULL, RET_BAD_PARAMS);
str_reset(&(chooser->cwd));
str_reset(&(chooser->filename));
TKMEM_FREE(chooser->filter);
TKMEM_FREE(chooser->init_dir);
TKMEM_FREE(chooser->top_dir);
emitter_deinit(EMITTER(chooser));
TKMEM_FREE(chooser);
return RET_OK;
}
|
0 |
repos/awtk/src/ext_widgets
|
repos/awtk/src/ext_widgets/file_browser/file_dialog.c
|
/**
* File: file_dialog.c
* Author: AWTK Develop Team
* Brief: 文件对话框。
*
* Copyright (c) Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2022-05-18 Li XianJing <[email protected]> created
*
*/
#include "awtk.h"
#include "ext_widgets/file_browser/file_chooser.h"
#if defined(WITH_SDL) && (!defined(LINUX_FB) && !defined(ANDROID) && !defined(IOS))
#define WITH_NATIVE_FILE_DIALOG 1
#endif /*WITH_SDL*/
#ifdef WITH_NATIVE_FILE_DIALOG
#include "../3rd/nativefiledialog/src/include/nfd.h"
static ret_t tk_choose_restore_window_manager_ignore_input_events(const idle_info_t* idle) {
window_manager_set_ignore_input_events(window_manager(), FALSE);
return RET_REMOVE;
}
/* 忽略本帧内的输入事件，避免出现关闭nfd后误触发awtk窗口内的其他事件（如在nfd里双击选择文件） */
static ret_t tk_choose_window_manager_ignore_input_events(void) {
ret_t ret = RET_OK;
window_manager_t* wm = WINDOW_MANAGER(window_manager());
return_value_if_fail(wm != NULL, RET_FAIL);
if (!wm->ignore_input_events) {
ret = window_manager_set_ignore_input_events(WIDGET(wm), TRUE);
if (RET_OK == ret) {
uint32_t id = idle_add(tk_choose_restore_window_manager_ignore_input_events, wm);
ret = (id != TK_INVALID_ID) ? RET_OK : RET_FAIL;
if (RET_OK != ret) {
window_manager_set_ignore_input_events(WIDGET(wm), FALSE);
}
}
}
return ret;
}
static const char* filters_to_nfd(const char* filters, str_t* str) {
str_set(str, filters);
str_replace(str, ".", ",");
str_trim(str, ",");
return str->str;
}
static darray_t* tk_choose_files_native(const char* filters, const char* init_dir) {
str_t str;
nfdpathset_t pathSet;
nfdresult_t result = NFD_OKAY;
str_init(&str, 64);
memset(&pathSet, 0x00, sizeof(pathSet));
result = NFD_OpenDialogMultiple(filters_to_nfd(filters, &str), init_dir, &pathSet);
str_reset(&str);
tk_choose_window_manager_ignore_input_events();
if (result == NFD_OKAY) {
size_t i = 0;
size_t n = NFD_PathSet_GetCount(&pathSet);
darray_t* ret = darray_create(n, default_destroy, NULL);
for (i = 0; i < n; ++i) {
nfdchar_t* path = NFD_PathSet_GetPath(&pathSet, i);
char* iter = tk_strdup(path);
if (iter != NULL) {
darray_push(ret, iter);
}
log_debug("Path %i: %s\n", (int)i, path);
}
NFD_PathSet_Free(&pathSet);
return ret;
}
return NULL;
}
static char* tk_choose_file_native(const char* filters, const char* init_dir) {
str_t str;
nfdchar_t* outPath = NULL;
str_init(&str, 64);
nfdresult_t result = NFD_OpenDialog(filters_to_nfd(filters, &str), init_dir, &outPath);
str_reset(&str);
tk_choose_window_manager_ignore_input_events();
if (result == NFD_OKAY) {
char* ret = tk_strdup(outPath);
log_debug("%s\n", outPath);
free(outPath);
return ret;
} else if (result == NFD_CANCEL) {
log_debug("%s\n", "User pressed cancel.");
} else {
log_warn("Error: %s\n", NFD_GetError());
}
return NULL;
}
static char* tk_choose_folder_native(const char* init_dir) {
nfdchar_t* outPath = NULL;
nfdresult_t result = NFD_PickFolder(init_dir, &outPath);
tk_choose_window_manager_ignore_input_events();
if (result == NFD_OKAY) {
char* ret = tk_strdup(outPath);
log_debug("%s\n", outPath);
free(outPath);
return ret;
} else if (result == NFD_CANCEL) {
log_debug("%s\n", "User pressed cancel.");
} else {
log_warn("Error: %s\n", NFD_GetError());
}
return NULL;
}
static char* tk_choose_file_for_save_native(const char* filters, const char* init_dir) {
str_t str;
nfdchar_t* outPath = NULL;
nfdresult_t result = NFD_OKAY;
str_init(&str, 64);
result = NFD_SaveDialog(filters_to_nfd(filters, &str), init_dir, &outPath);
str_reset(&str);
tk_choose_window_manager_ignore_input_events();
if (result == NFD_OKAY) {
char* ret = tk_strdup(outPath);
log_debug("%s\n", outPath);
free(outPath);
return ret;
} else if (result == NFD_CANCEL) {
log_debug("%s\n", "User pressed cancel.");
} else {
log_warn("Error: %s\n", NFD_GetError());
}
return NULL;
}
#endif /*WITH_NATIVE_FILE_DIALOG*/
static ret_t on_choose_file_result(void* ctx, event_t* e) {
str_t* str = (str_t*)ctx;
file_chooser_t* chooser = (file_chooser_t*)(e->target);
if (!file_chooser_is_aborted(chooser)) {
char full_path[MAX_PATH + 1];
const char* dir = file_chooser_get_dir(chooser);
const char* name = file_chooser_get_filename(chooser);
path_build(full_path, sizeof(full_path) - 1, dir, name, NULL);
str_set(str, full_path);
}
return RET_OK;
}
static char* tk_choose_file_awtk(const char* filters, const char* init_dir) {
str_t str;
file_chooser_t* chooser = file_chooser_create();
str_init(&str, MAX_PATH + 1);
emitter_on(EMITTER(chooser), EVT_DONE, on_choose_file_result, &str);
file_chooser_set_init_dir(chooser, init_dir);
file_chooser_set_filter(chooser, filters);
if (file_chooser_choose_file_for_open(chooser) == RET_OK) {
return str.str;
} else {
str_reset(&str);
return NULL;
}
}
static darray_t* tk_choose_files_awtk(const char* filters, const char* init_dir) {
char* filename = tk_choose_file_awtk(filters, init_dir);
if (filename != NULL) {
darray_t* ret = darray_create(1, default_destroy, NULL);
if (ret != NULL) {
darray_push(ret, filename);
} else {
TKMEM_FREE(filename);
}
return ret;
}
return NULL;
}
static char* tk_choose_folder_awtk(const char* init_dir) {
str_t str;
file_chooser_t* chooser = file_chooser_create();
str_init(&str, MAX_PATH + 1);
emitter_on(EMITTER(chooser), EVT_DONE, on_choose_file_result, &str);
file_chooser_set_init_dir(chooser, init_dir);
if (file_chooser_choose_folder(chooser) == RET_OK) {
return str.str;
} else {
str_reset(&str);
return NULL;
}
}
static char* tk_choose_file_for_save_awtk(const char* filters, const char* init_dir) {
str_t str;
file_chooser_t* chooser = file_chooser_create();
str_init(&str, MAX_PATH + 1);
emitter_on(EMITTER(chooser), EVT_DONE, on_choose_file_result, &str);
file_chooser_set_init_dir(chooser, init_dir);
file_chooser_set_filter(chooser, filters);
if (file_chooser_choose_file_for_save(chooser) == RET_OK) {
return str.str;
} else {
str_reset(&str);
return NULL;
}
}
static const char* fix_init_dir(char path[MAX_PATH + 1], const char* init_dir) {
if (init_dir == NULL) {
path_cwd(path);
} else {
path_normalize(init_dir, path, MAX_PATH);
}
return path;
}
darray_t* tk_choose_files(const char* filters, const char* init_dir) {
char path[MAX_PATH + 1] = {0};
init_dir = fix_init_dir(path, init_dir);
#ifdef WITH_NATIVE_FILE_DIALOG
if (system_info()->app_type == APP_DESKTOP) {
return tk_choose_files_native(filters, init_dir);
}
#endif /*WITH_NATIVE_FILE_DIALOG*/
return tk_choose_files_awtk(filters, init_dir);
}
char* tk_choose_file(const char* filters, const char* init_dir) {
char path[MAX_PATH + 1] = {0};
init_dir = fix_init_dir(path, init_dir);
#ifdef WITH_NATIVE_FILE_DIALOG
if (system_info()->app_type == APP_DESKTOP) {
return tk_choose_file_native(filters, init_dir);
}
#endif /*WITH_NATIVE_FILE_DIALOG*/
return tk_choose_file_awtk(filters, init_dir);
}
char* tk_choose_folder(const char* init_dir) {
char path[MAX_PATH + 1] = {0};
init_dir = fix_init_dir(path, init_dir);
#ifdef WITH_NATIVE_FILE_DIALOG
if (system_info()->app_type == APP_DESKTOP) {
return tk_choose_folder_native(init_dir);
}
#endif /*WITH_NATIVE_FILE_DIALOG*/
return tk_choose_folder_awtk(init_dir);
}
char* tk_choose_file_for_save(const char* filters, const char* init_dir) {
char path[MAX_PATH + 1] = {0};
init_dir = fix_init_dir(path, init_dir);
#ifdef WITH_NATIVE_FILE_DIALOG
if (system_info()->app_type == APP_DESKTOP) {
return tk_choose_file_for_save_native(filters, init_dir);
}
#endif /*WITH_NATIVE_FILE_DIALOG*/
return tk_choose_file_for_save_awtk(filters, init_dir);
}
|
0 |
repos/awtk/src/ext_widgets
|
repos/awtk/src/ext_widgets/file_browser/file_browser.c
|
/**
* File: file_browser.c
* Author: AWTK Develop Team
* Brief: file_browser
*
* Copyright (c) 2020 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2020-01-04 Li XianJing <[email protected]> created
*
*/
#include "tkc/mem.h"
#include "tkc/path.h"
#include "tkc/utils.h"
#include "ext_widgets/file_browser/file_chooser.h"
#include "ext_widgets/file_browser/file_browser.h"
static ret_t file_browser_sort(file_browser_t* fb);
static ret_t file_browser_extend_items(file_browser_t* fb, uint32_t capacity) {
fb_item_t* items = NULL;
return_value_if_fail(fb != NULL, RET_BAD_PARAMS);
if (fb->items_capacity >= capacity) {
return RET_OK;
}
items = TKMEM_REALLOC(fb->items, capacity * sizeof(fb_item_t));
if (items != NULL) {
uint32_t delta = capacity - fb->items_capacity;
fb->items = items;
fb->items_capacity = capacity;
memset(items + fb->items_size, 0x00, delta * sizeof(fb_item_t));
return RET_OK;
} else {
return RET_OOM;
}
}
static fb_item_t* file_browser_add_item(file_browser_t* fb) {
return_value_if_fail(fb != NULL, NULL);
if (fb->items_size >= fb->items_capacity) {
uint32_t capacity = fb->items_capacity + fb->items_capacity / 2 + 10;
if (file_browser_extend_items(fb, capacity) != RET_OK) {
return NULL;
}
}
if (fb->items_size < fb->items_capacity) {
fb_item_t* item = fb->items + fb->items_size;
fb->items_size++;
return item;
}
return NULL;
}
static fb_item_t* file_browser_find_item(file_browser_t* fb, const char* name) {
uint32_t i = 0;
for (i = 0; i < fb->items_size; i++) {
fb_item_t* iter = fb->items + i;
if (tk_str_eq(iter->name, name)) {
return iter;
}
}
return NULL;
}
file_browser_t* file_browser_create(fs_t* fs) {
file_browser_t* fb = NULL;
return_value_if_fail(fs != NULL, NULL);
fb = TKMEM_ZALLOC(file_browser_t);
return_value_if_fail(fb != NULL, NULL);
fb->fs = fs;
tk_strcpy(fb->cwd, "/");
fb->ignore_hidden_files = TRUE;
fb->compare = fb_compare_by_name;
return fb;
}
static ret_t file_browser_normlize_path(const char* in, char* out, uint32_t out_size) {
char path[MAX_PATH + 1] = {0};
return_value_if_fail(in != NULL && out != NULL, RET_BAD_PARAMS);
memset(path, 0x00, sizeof(path));
path_expand_vars(in, path, sizeof(path) - 1);
if (file_exist(path)) {
char* p = path + strlen(path);
while (p > path && *p != '/' && *p != '\\') {
p--;
}
*p = '\0';
}
in = path;
if (path_is_abs(in)) {
path_normalize(in, out, out_size);
} else {
char abs_path[MAX_PATH + 1];
memset(abs_path, 0x00, sizeof(path));
return_value_if_fail(path_abs(in, abs_path, MAX_PATH) == RET_OK, RET_BAD_PARAMS);
path_normalize(abs_path, out, out_size);
}
path_remove_last_slash(out);
return RET_OK;
}
ret_t file_browser_set_cwd(file_browser_t* fb, const char* cwd) {
return_value_if_fail(fb != NULL && cwd != NULL, RET_BAD_PARAMS);
file_browser_normlize_path(cwd, fb->cwd, MAX_PATH);
file_browser_refresh(fb);
return RET_OK;
}
ret_t file_browser_set_top_dir(file_browser_t* fb, const char* top_dir) {
char path[MAX_PATH + 1] = {0};
return_value_if_fail(fb != NULL && top_dir != NULL, RET_BAD_PARAMS);
file_browser_normlize_path(top_dir, path, MAX_PATH);
fb->top_dir = tk_str_copy(fb->top_dir, path);
return RET_OK;
}
ret_t file_browser_create_dir(file_browser_t* fb, const char* name) {
char fullpath[MAX_PATH + 1];
fb_item_t* item = file_browser_find_item(fb, name);
return_value_if_fail(item == NULL, RET_FOUND);
memset(fullpath, 0x00, sizeof(fullpath));
return_value_if_fail(fb != NULL && name != NULL, RET_BAD_PARAMS);
return_value_if_fail(path_build(fullpath, MAX_PATH, fb->cwd, name, NULL) == RET_OK, RET_FAIL);
return fs_create_dir(fb->fs, fullpath);
}
ret_t file_browser_create_file(file_browser_t* fb, const char* name, const void* buff,
uint32_t size) {
ret_t ret = RET_OK;
fs_file_t* fp = NULL;
char fullpath[MAX_PATH + 1];
fb_item_t* item = file_browser_find_item(fb, name);
return_value_if_fail(item == NULL || item->is_reg_file, RET_FOUND);
memset(fullpath, 0x00, sizeof(fullpath));
return_value_if_fail(fb != NULL && name != NULL && buff != NULL, RET_BAD_PARAMS);
return_value_if_fail(path_build(fullpath, MAX_PATH, fb->cwd, name, NULL) == RET_OK, RET_FAIL);
fp = fs_open_file(fb->fs, fullpath, "wb+");
return_value_if_fail(fp != NULL, RET_FAIL);
if (fs_file_write(fp, buff, size) != size) {
ret = RET_FAIL;
}
fs_file_close(fp);
return ret;
}
static ret_t file_browser_remove_item_recursive(file_browser_t* fb, const char* fullpath) {
fs_stat_info_t st;
return_value_if_fail(fs_stat(fb->fs, fullpath, &st) == RET_OK, RET_BAD_PARAMS);
if (st.is_reg_file) {
return fs_remove_file(fb->fs, fullpath);
} else if (st.is_dir) {
fs_dir_t* dir = fs_open_dir(fb->fs, fullpath);
if (dir != NULL) {
fs_item_t info;
char sub_path[MAX_PATH + 1];
while (fs_dir_read(dir, &info) == RET_OK) {
if (tk_str_eq(info.name, ".") || tk_str_eq(info.name, "..")) {
continue;
}
ENSURE(path_build(sub_path, MAX_PATH, fullpath, info.name, NULL) == RET_OK);
if (file_browser_remove_item_recursive(fb, sub_path) != RET_OK) {
log_warn("file_browser_remove_item_recursive failed\n");
}
}
fs_dir_close(dir);
}
return fs_remove_dir(fb->fs, fullpath);
} else {
assert(!"not supported");
return fs_remove_file(fb->fs, fullpath);
}
}
ret_t file_browser_remove(file_browser_t* fb, const char* name) {
char fullpath[MAX_PATH + 1];
memset(fullpath, 0x00, sizeof(fullpath));
return_value_if_fail(fb != NULL && name != NULL, RET_BAD_PARAMS);
return_value_if_fail(path_build(fullpath, MAX_PATH, fb->cwd, name, NULL) == RET_OK, RET_FAIL);
return file_browser_remove_item_recursive(fb, fullpath);
}
ret_t file_browser_refresh(file_browser_t* fb) {
fs_item_t info;
fs_stat_info_t st;
fs_dir_t* dir = NULL;
char fullpath[MAX_PATH + 1];
return_value_if_fail(fb != NULL && fb->cwd[0] != '\0', RET_BAD_PARAMS);
fb->items_size = 0;
dir = fs_open_dir(fb->fs, fb->cwd);
return_value_if_fail(dir != NULL, RET_BAD_PARAMS);
memset(fullpath, 0x00, sizeof(fullpath));
while (fs_dir_read(dir, &info) == RET_OK) {
fb_item_t* iter = NULL;
if (tk_str_eq(info.name, ".") || tk_str_eq(info.name, "..")) {
continue;
}
if (fb->ignore_hidden_files && info.name[0] == '.') {
continue;
}
if (fb->filter != NULL && fb->filter(fb->filter_ctx, &info) == FALSE) {
continue;
}
path_build(fullpath, MAX_PATH, fb->cwd, info.name, NULL);
if (fs_stat(os_fs(), fullpath, &st) != RET_OK) {
log_debug("stat file failed:%s\n", fullpath);
continue;
}
iter = file_browser_add_item(fb);
return_value_if_fail(iter != NULL, RET_OOM);
iter->size = st.size;
iter->mtime = st.mtime;
iter->ctime = st.ctime;
iter->mtime = st.mtime;
iter->is_dir = st.is_dir;
iter->is_reg_file = st.is_reg_file;
iter->name = tk_str_copy(iter->name, info.name);
}
fs_dir_close(dir);
file_browser_sort(fb);
return RET_OK;
}
ret_t file_browser_enter(file_browser_t* fb, const char* dir) {
char path[MAX_PATH + 1];
return_value_if_fail(fb != NULL && dir != NULL, RET_BAD_PARAMS);
memset(path, 0x00, sizeof(path));
return_value_if_fail(path_build(path, MAX_PATH, fb->cwd, dir, NULL) == RET_OK, RET_FAIL);
return file_browser_set_cwd(fb, path);
}
ret_t file_browser_up(file_browser_t* fb) {
char* p = NULL;
return_value_if_fail(fb != NULL, RET_BAD_PARAMS);
if (fb->top_dir != NULL) {
if (strstr(fb->top_dir, fb->cwd) != NULL) {
return RET_FAIL;
}
}
p = strrchr(fb->cwd, TK_PATH_SEP);
while (p != NULL && (p[1] == '\0' || (p[1] == '.' && p[2] == '\0'))) {
*p = '\0';
p = strrchr(fb->cwd, TK_PATH_SEP);
}
if (p != NULL) {
*p = '\0';
}
if (fb->cwd[0] == '\0') {
fb->cwd[0] = '/';
fb->cwd[1] = '\0';
}
return file_browser_refresh(fb);
}
ret_t file_browser_set_filter(file_browser_t* fb, tk_filter_t filter, void* ctx) {
return_value_if_fail(fb != NULL, RET_BAD_PARAMS);
fb->filter = filter;
fb->filter_ctx = ctx;
return RET_OK;
}
ret_t file_browser_set_compare(file_browser_t* fb, tk_compare_t compare) {
return_value_if_fail(fb != NULL, RET_BAD_PARAMS);
fb->compare = compare;
return RET_OK;
}
static int fb_dir_first(fb_item_t* aa, fb_item_t* bb) {
if (aa->is_dir) {
return -1;
} else if (bb->is_dir) {
return 1;
} else {
return 0;
}
}
int fb_compare_by_name(const void* a, const void* b) {
fb_item_t* aa = (fb_item_t*)a;
fb_item_t* bb = (fb_item_t*)b;
if ((aa->is_reg_file && bb->is_reg_file) || (aa->is_dir && bb->is_dir)) {
return strcmp(aa->name, bb->name);
}
return fb_dir_first(aa, bb);
}
int fb_compare_by_type(const void* a, const void* b) {
fb_item_t* aa = (fb_item_t*)a;
fb_item_t* bb = (fb_item_t*)b;
if (aa->is_reg_file && bb->is_reg_file) {
const char* atype = strrchr(aa->name, '.');
const char* btype = strrchr(bb->name, '.');
if (atype == NULL) {
return -1;
}
if (btype == NULL) {
return 1;
}
return strcasecmp(atype + 1, btype + 1);
}
if (aa->is_dir && bb->is_dir) {
return strcmp(aa->name, bb->name);
}
return fb_dir_first(aa, bb);
}
int fb_compare_by_size(const void* a, const void* b) {
fb_item_t* aa = (fb_item_t*)a;
fb_item_t* bb = (fb_item_t*)b;
if ((aa->is_reg_file && bb->is_reg_file) || (aa->is_dir && bb->is_dir)) {
return aa->size - bb->size;
}
return fb_dir_first(aa, bb);
}
int fb_compare_by_mtime(const void* a, const void* b) {
fb_item_t* aa = (fb_item_t*)a;
fb_item_t* bb = (fb_item_t*)b;
if ((aa->is_reg_file && bb->is_reg_file) || (aa->is_dir && bb->is_dir)) {
return aa->mtime - bb->mtime;
}
return fb_dir_first(aa, bb);
}
int fb_compare_by_name_dec(const void* a, const void* b) {
fb_item_t* aa = (fb_item_t*)a;
fb_item_t* bb = (fb_item_t*)b;
if ((aa->is_reg_file && bb->is_reg_file) || (aa->is_dir && bb->is_dir)) {
return -strcmp(aa->name, bb->name);
}
return fb_dir_first(aa, bb);
}
int fb_compare_by_type_dec(const void* a, const void* b) {
fb_item_t* aa = (fb_item_t*)a;
fb_item_t* bb = (fb_item_t*)b;
if (aa->is_reg_file && bb->is_reg_file) {
const char* atype = strrchr(aa->name, '.');
const char* btype = strrchr(bb->name, '.');
if (atype == NULL) {
return 1;
}
if (btype == NULL) {
return -1;
}
return -strcasecmp(atype + 1, btype + 1);
}
if (aa->is_dir && bb->is_dir) {
return -strcmp(aa->name, bb->name);
}
return fb_dir_first(aa, bb);
}
int fb_compare_by_size_dec(const void* a, const void* b) {
fb_item_t* aa = (fb_item_t*)a;
fb_item_t* bb = (fb_item_t*)b;
if ((aa->is_reg_file && bb->is_reg_file) || (aa->is_dir && bb->is_dir)) {
return bb->size - aa->size;
}
return fb_dir_first(aa, bb);
}
int fb_compare_by_mtime_dec(const void* a, const void* b) {
fb_item_t* aa = (fb_item_t*)a;
fb_item_t* bb = (fb_item_t*)b;
if ((aa->is_reg_file && bb->is_reg_file) || (aa->is_dir && bb->is_dir)) {
return bb->mtime - aa->mtime;
}
return fb_dir_first(aa, bb);
}
static ret_t file_browser_sort(file_browser_t* fb) {
return_value_if_fail(fb != NULL, RET_BAD_PARAMS);
if (fb->compare != NULL && fb->items_size > 1) {
qsort(fb->items, fb->items_size, sizeof(fb_item_t), fb->compare);
}
return RET_OK;
}
ret_t file_browser_sort_by_name(file_browser_t* fb, bool_t ascending) {
return_value_if_fail(fb != NULL, RET_BAD_PARAMS);
fb->compare = ascending ? fb_compare_by_name : fb_compare_by_name_dec;
return file_browser_sort(fb);
}
ret_t file_browser_sort_by_type(file_browser_t* fb, bool_t ascending) {
return_value_if_fail(fb != NULL, RET_BAD_PARAMS);
fb->compare = ascending ? fb_compare_by_type : fb_compare_by_type_dec;
return file_browser_sort(fb);
}
ret_t file_browser_sort_by_size(file_browser_t* fb, bool_t ascending) {
return_value_if_fail(fb != NULL, RET_BAD_PARAMS);
fb->compare = ascending ? fb_compare_by_size : fb_compare_by_size_dec;
return file_browser_sort(fb);
}
ret_t file_browser_sort_by_mtime(file_browser_t* fb, bool_t ascending) {
return_value_if_fail(fb != NULL, RET_BAD_PARAMS);
fb->compare = ascending ? fb_compare_by_mtime : fb_compare_by_mtime_dec;
return file_browser_sort(fb);
}
uint32_t file_browser_get_items_nr(file_browser_t* fb) {
return_value_if_fail(fb != NULL, 0);
return fb->items_size;
}
fb_item_t* file_browser_get_item(file_browser_t* fb, uint32_t index) {
return_value_if_fail(fb != NULL && index < fb->items_size, NULL);
return fb->items + index;
}
ret_t file_browser_set_ignore_hidden_files(file_browser_t* fb, bool_t ignore_hidden_files) {
return_value_if_fail(fb != NULL, RET_BAD_PARAMS);
fb->ignore_hidden_files = ignore_hidden_files;
return RET_OK;
}
ret_t file_browser_destroy(file_browser_t* fb) {
return_value_if_fail(fb != NULL, RET_BAD_PARAMS);
if (fb->items != NULL) {
uint32_t i = 0;
log_debug("items_capacity=%u\n", fb->items_capacity);
for (i = 0; i < fb->items_capacity; i++) {
fb_item_t* iter = fb->items + i;
TKMEM_FREE(iter->name);
}
TKMEM_FREE(fb->items);
}
TKMEM_FREE(fb->top_dir);
TKMEM_FREE(fb);
return RET_OK;
}
bool_t fb_filter_files_only(void* ctx, const void* data) {
fs_item_t* item = (fs_item_t*)data;
return item->is_reg_file;
}
bool_t fb_filter_directories_only(void* ctx, const void* data) {
fs_item_t* item = (fs_item_t*)data;
return item->is_dir;
}
bool_t fb_filter_by_ext_names(void* ctx, const void* data) {
fs_item_t* item = (fs_item_t*)data;
const char* ext_names = (const char*)ctx;
const char* p = strrchr(item->name, '.');
if (item->is_dir) {
return TRUE;
}
if (ext_names == NULL) {
return TRUE;
}
if (p == NULL) {
return FALSE;
}
return strstr(ext_names, p) != NULL;
}
|
0 |
repos/awtk/src/ext_widgets
|
repos/awtk/src/ext_widgets/file_browser/file_browser_view.h
|
/**
* File: file_browser_view.h
* Author: AWTK Develop Team
* Brief: file manager/browser/choosor
*
* Copyright (c) 2020 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2020-01-08 Li XianJing <[email protected]> created
*
*/
#ifndef TK_FILE_BROWSER_VIEW_H
#define TK_FILE_BROWSER_VIEW_H
#include "base/widget.h"
#include "file_browser/file_browser.h"
BEGIN_C_DECLS
/**
* @class file_browser_view_t
* @parent widget_t
* @annotation ["scriptable","design","widget"]
* 文件管理/浏览/选择控件。
*
* file\_browser\_view\_t是[widget\_t](widget_t.md)的子类控件，widget\_t的函数均适用于file\_browser\_view\_t控件。
*
* 考虑到文件浏览器界面呈现的多样性，界面呈现工作完全有子控件来完成。
*
* file\_browser\_view\_t负责关联文件/文件夹数据到子控件上，子控件需要特定的规范命名。
*
* * 名为 "cwd" 的子控件用于显示当前路径。
*
* * 名为 "selected_file" 的子控件用于显示当前选择的文件。
*
* * 名为 "file" 的子控件用于显示文件项的模板控件。
*
* * 名为 "folder" 的子控件用于显示文件夹项的模板控件。
*
* * 名为 "return_up" 的子控件用于返回上一级文件夹的模板控件。
*
* * 名为 "container" 的子控件为容器控件，通常是scrollview。
*
* * 名为 "name" 的子控件用于显示文件和文件夹的名称(放在列表项目内)。
* * 名为 "size" 的子控件用于显示文件和文件夹的大小(放在列表项目内)。
*
* * 名为 "mtime" 的子控件用于显示文件和文件夹的修改时间(放在列表项目内)。
*
* * 名为 "ctime" 的子控件用于显示文件和文件夹的创建时间(放在列表项目内)。
*
* * 名为 "icon" 的子控件用于显示文件和文件夹的图标(放在列表项目内)。
*
* * 类型为 "check_button" 的子控件用于选择(放在列表项目内)。
*
* 完整示例请参考：
*
* https://github.com/zlgopen/awtk/blob/master/design/default/ui/file_chooser_for_open.xml
*
*/
typedef struct _file_browser_view_t {
widget_t widget;
/**
* @property {char*} init_dir
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 初始文件夹。
*/
char* init_dir;
/**
* @property {char*} top_dir
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 最顶层目录。到达本目录后，不允许往上。
*/
char* top_dir;
/**
* @property {char*} filter
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 过滤规则。
*/
char* filter;
/**
* @property {bool_t} ignore_hidden_files
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 是否忽略隐藏文件。
*/
bool_t ignore_hidden_files;
/**
* @property {bool_t} sort_ascending
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 是否为升序排序。
*/
bool_t sort_ascending;
/**
* @property {bool_t} show_check_button
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 是否显示checkbutton。
*/
bool_t show_check_button;
/**
* @property {char*} sort_by
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 排序方式。可选值(name, size, mtime, type)。
*/
char* sort_by;
/**
* @property {char*} odd_item_style
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 奇数项样式。
*/
char* odd_item_style;
/**
* @property {char*} even_item_style
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 偶数项样式。
*/
char* even_item_style;
/*private*/
bool_t inited;
file_browser_t* fb;
widget_t* cwd;
widget_t* selected_file;
widget_t* container;
widget_t* file_template;
widget_t* folder_template;
widget_t* return_up_template;
darray_t selected_items;
darray_t file_items_cache;
darray_t folder_items_cache;
} file_browser_view_t;
/**
* @event {value_change_event_t} EVT_VALUE_CHANGED
* 值(当前显示目录)改变事件。
*/
/**
* @method file_browser_view_create
* @annotation ["constructor", "scriptable"]
* 创建file_browser_view对象
* @param {widget_t*} parent 父控件
* @param {xy_t} x x坐标
* @param {xy_t} y y坐标
* @param {wh_t} w 宽度
* @param {wh_t} h 高度
*
* @return {widget_t*} 对象。
*/
widget_t* file_browser_view_create(widget_t* parent, xy_t x, xy_t y, wh_t w, wh_t h);
/**
* @method file_browser_view_cast
* 转换为file_browser_view对象(供脚本语言使用)。
* @annotation ["cast", "scriptable"]
* @param {widget_t*} widget file_browser_view对象。
*
* @return {widget_t*} file_browser_view对象。
*/
widget_t* file_browser_view_cast(widget_t* widget);
/**
* @method file_browser_view_set_init_dir
* 设置 初始文件夹。
* @annotation ["scriptable"]
* @param {widget_t*} widget widget对象。
* @param {const char*} init_dir 初始文件夹。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t file_browser_view_set_init_dir(widget_t* widget, const char* init_dir);
/**
* @method file_browser_view_set_top_dir
* 设置 顶层文件夹。
* @annotation ["scriptable"]
* @param {widget_t*} widget widget对象。
* @param {const char*} top_dir 初始文件夹。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t file_browser_view_set_top_dir(widget_t* widget, const char* top_dir);
/**
* @method file_browser_view_set_filter
* 设置 过滤规则。
* @annotation ["scriptable"]
* @param {widget_t*} widget widget对象。
* @param {const char*} filter 过滤规则。
*> files_only 表示只列出文件，dir_only 表示只列出目录，其它表示只列出满足扩展名文件集合(如：.jpg.png.gif)。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t file_browser_view_set_filter(widget_t* widget, const char* filter);
/**
* @method file_browser_view_reload
* 重新加载。
* @annotation ["scriptable"]
* @param {widget_t*} widget widget对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t file_browser_view_reload(widget_t* widget);
/**
* @method file_browser_view_set_ignore_hidden_files
* 设置 忽略隐藏文件。
* @annotation ["scriptable"]
* @param {widget_t*} widget widget对象。
* @param {bool_t} ignore_hidden_files 忽略隐藏文件。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t file_browser_view_set_ignore_hidden_files(widget_t* widget, bool_t ignore_hidden_files);
/**
* @method file_browser_view_set_sort_ascending
* 设置 是否为升序排序。
* @annotation ["scriptable"]
* @param {widget_t*} widget widget对象。
* @param {bool_t} sort_ascending 是否为升序排序。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t file_browser_view_set_sort_ascending(widget_t* widget, bool_t sort_ascending);
/**
* @method file_browser_view_set_show_check_button
* 设置 是否显示checkbutton。
* @annotation ["scriptable"]
* @param {widget_t*} widget widget对象。
* @param {bool_t} show_check_button 是否显示checkbutton。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t file_browser_view_set_show_check_button(widget_t* widget, bool_t show_check_button);
/**
* @method file_browser_view_set_sort_by
* 设置 排序方式。可选值(name, size, mtime, type)。
* @annotation ["scriptable"]
* @param {widget_t*} widget widget对象。
* @param {const char*} sort_by 排序方式。可选值(name, size, mtime, type)。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t file_browser_view_set_sort_by(widget_t* widget, const char* sort_by);
/**
* @method file_browser_view_set_odd_item_style
* 设置 奇数项样式。
* @annotation ["scriptable"]
* @param {widget_t*} widget widget对象。
* @param {const char*} odd_item_style 奇数项样式。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t file_browser_view_set_odd_item_style(widget_t* widget, const char* odd_item_style);
/**
* @method file_browser_view_set_even_item_style
* 设置 偶数项样式。
* @annotation ["scriptable"]
* @param {widget_t*} widget widget对象。
* @param {const char*} even_item_style 奇数项样式。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t file_browser_view_set_even_item_style(widget_t* widget, const char* even_item_style);
/**
* @method file_browser_view_get_selected_items
* 返回当前选中的项目。
*
* > 在返回数组中，每个元素是一个fb\_item\_t对象。
* > 调用者无需释放返回值，返回值只在当次调用有效。
*
* @param {widget_t*} widget widget对象。
*
* @return {darray_t*} 返回当前选中的项目。
*/
darray_t* file_browser_view_get_selected_items(widget_t* widget);
/**
* @method file_browser_view_get_cwd
* 获取当前路径。
* @annotation ["scriptable"]
* @param {widget_t*} widget widget对象。
*
* @return {const char*} 返回当前路径。
*/
const char* file_browser_view_get_cwd(widget_t* widget);
/**
* @method file_browser_view_create_dir
* 在当前文件夹创建子文件夹。
*
* @annotation ["scriptable"]
* @param {widget_t*} widget widget对象。
* @param {const char*} name 子文件夹名。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t file_browser_view_create_dir(widget_t* widget, const char* name);
/**
* @method file_browser_view_create_file
* 在当前文件夹创建文件。
*
* @annotation ["scriptable"]
* @param {widget_t*} widget widget对象。
* @param {const char*} name 文件名。
* @param {const char*} data 数据。
* @param {uint32_t} size 数据长度。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t file_browser_view_create_file(widget_t* widget, const char* name, const char* data,
uint32_t size);
#define FILE_BROWSER_VIEW_PROP_SORT_BY "sort_by"
#define FILE_BROWSER_VIEW_PROP_INIT_DIR "init_dir"
#define FILE_BROWSER_VIEW_PROP_TOP_DIR "top_dir"
#define FILE_BROWSER_VIEW_PROP_SORT_ASCENDING "sort_ascending"
#define FILE_BROWSER_VIEW_PROP_SHOW_CHECK_BUTTON "show_check_button"
#define FILE_BROWSER_VIEW_PROP_IGNORE_HIDDEN_FILES "ignore_hidden_files"
#define FILE_BROWSER_VIEW_PROP_ODD_ITEM_STYLE "odd_item_style"
#define FILE_BROWSER_VIEW_PROP_EVEN_ITEM_STYLE "even_item_style"
#define WIDGET_TYPE_FILE_BROWSER_VIEW "file_browser_view"
#define FILE_BROWSER_VIEW(widget) ((file_browser_view_t*)(file_browser_view_cast(WIDGET(widget))))
ret_t file_browser_view_register(void);
/*特殊子控件的名字*/
/*用于显示当前路径的控件*/
#define FILE_BROWSER_VIEW_CWD "cwd"
#define FILE_BROWSER_VIEW_SELECTED_FILE "selected_file"
/*用于显示名称的控件*/
#define FILE_BROWSER_VIEW_NAME "name"
/*用于显示文件大小的控件*/
#define FILE_BROWSER_VIEW_SIZE "size"
/*用于显示文件修改时间的控件*/
#define FILE_BROWSER_VIEW_MTIME "mtime"
/*用于显示文件创建时间的控件*/
#define FILE_BROWSER_VIEW_CTIME "ctime"
/*用于显示文件图标的控件*/
#define FILE_BROWSER_VIEW_ICON "icon"
/*用于显示文件项的模板控件*/
#define FILE_BROWSER_VIEW_FILE "file"
/*用于显示文件夹项的模板控件*/
#define FILE_BROWSER_VIEW_FOLDER "folder"
/*用于显示返回上一级文件夹的模板控件*/
#define FILE_BROWSER_VIEW_RETURN_UP "return_up"
/*容器控件，通常是scrollview*/
#define FILE_BROWSER_VIEW_CONTAINER "container"
#define STR_FILTER_FILES_ONLY "files_only"
#define STR_FILTER_DIR_ONLY "dir_only"
/*public for subclass and runtime type check*/
TK_EXTERN_VTABLE(file_browser_view);
END_C_DECLS
#endif /*TK_FILE_BROWSER_VIEW_H*/
|
0 |
repos/awtk/src/ext_widgets
|
repos/awtk/src/ext_widgets/file_browser/file_chooser.h
|
/**
* File: file_chooser.h
* Author: AWTK Develop Team
* Brief: file/folder choosers
*
* Copyright (c) 2020 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2020-01-12 Li XianJing <[email protected]> created
*
*/
#ifndef TK_FILE_CHOOSER_H
#define TK_FILE_CHOOSER_H
#include "tkc/emitter.h"
BEGIN_C_DECLS
/**
* @class file_chooser_t
* @annotation ["scriptable"]
* @parent emitter_t
* 文件/目录选择器
*/
typedef struct _file_chooser_t {
emitter_t emitter;
/**
* @property {char*} init_dir
* 初始目录。
*/
char* init_dir;
/**
* @property {char*} top_dir
* 最顶层目录。到达本目录后，不允许往上。
*/
char* top_dir;
/**
* @property {char*} filter
* 过滤规则。
*/
char* filter;
/**
* @property {tk_on_done_t} on_done
* 接受结果的回调函数。
*/
tk_on_done_t on_done;
/**
* @property {void*} on_done_ctx
* 用户数据。
*/
void* on_done_ctx;
/*result*/
/**
* @property {str_t} cwd
* 当前路径。
*/
str_t cwd;
/**
* @property {str_t} filename
* 当前选择的文件。
*/
str_t filename;
/**
* @property {bool_t} aborted
* 是否取消了选择。
*/
bool_t aborted;
/*private*/
const char* ui;
} file_chooser_t;
/**
* @method file_chooser_create
* 创建file_chooser对象
* @annotation ["constructor", "scriptable"]
*
* @return {file_chooser_t*} 对象。
*/
file_chooser_t* file_chooser_create(void);
/**
* @method file_chooser_set_init_dir
* 设置初始目录。
* @annotation ["scriptable"]
* @param {file_chooser_t*} chooser file_chooser对象。
* @param {const char*} init_dir 初始目录
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t file_chooser_set_init_dir(file_chooser_t* chooser, const char* init_dir);
/**
* @method file_chooser_set_top_dir
* 设置初始目录。
* @annotation ["scriptable"]
* @param {file_chooser_t*} chooser file_chooser对象。
* @param {const char*} top_dir 初始目录
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t file_chooser_set_top_dir(file_chooser_t* chooser, const char* top_dir);
/**
* @method file_chooser_set_filter
* 设置过滤规则。
* @annotation ["scriptable"]
* @param {file_chooser_t*} chooser file_chooser对象。
* @param {const char*} filter 过滤规则。
*> files_only 表示只列出文件，dir_only 表示只列出目录，其它表示只列出满足扩展名文件集合(如：.jpg.png.gif)。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t file_chooser_set_filter(file_chooser_t* chooser, const char* filter);
/**
* @method file_chooser_cast
* 转换为file_chooser对象(供脚本语言使用)。
*
* @annotation ["cast", "scriptable"]
* @param {file_chooser_t*} chooser file_chooser对象。
*
* @return {file_chooser_t*} 对象。
*/
file_chooser_t* file_chooser_cast(file_chooser_t* chooser);
/**
* @method file_chooser_choose_file_for_save
* 为了保存而选择文件。
*
* @annotation ["scriptable"]
* @param {file_chooser_t*} chooser file_chooser对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t file_chooser_choose_file_for_save(file_chooser_t* chooser);
/**
* @method file_chooser_choose_file_for_open
* 为了打开而选择文件。
*
* @annotation ["scriptable"]
* @param {file_chooser_t*} chooser file_chooser对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t file_chooser_choose_file_for_open(file_chooser_t* chooser);
/**
* @method file_chooser_choose_folder
* 选择目录。
*
* @annotation ["scriptable"]
* @param {file_chooser_t*} chooser file_chooser对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t file_chooser_choose_folder(file_chooser_t* chooser);
/**
* @method file_chooser_get_dir
* 获取目录。
*
* @annotation ["scriptable"]
* @param {file_chooser_t*} chooser file_chooser对象。
*
* @return {const char*} 返回选择的目录。
*/
const char* file_chooser_get_dir(file_chooser_t* chooser);
/**
* @method file_chooser_get_filename
* 获取文件名。
*
* @annotation ["scriptable"]
* @param {file_chooser_t*} chooser file_chooser对象。
*
* @return {const char*} 返回选择的文件名。
*/
const char* file_chooser_get_filename(file_chooser_t* chooser);
/**
* @method file_chooser_is_aborted
* 用户是否取消了选择。
*
* @annotation ["scriptable"]
* @param {file_chooser_t*} chooser file_chooser对象。
*
* @return {bool_t} 返回用户是否取消了选择。
*/
bool_t file_chooser_is_aborted(file_chooser_t* chooser);
/**
* @method file_chooser_destroy
* 销毁file_chooser对象(选择完成后自动调用)。
*
* @param {file_chooser_t*} chooser file_chooser对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t file_chooser_destroy(file_chooser_t* chooser);
/*UI 资源文件名*/
#define FILE_CHOOSER_UI_CHOOSE_FOLDER "folder_chooser"
#define FILE_CHOOSER_UI_CHOOSE_FILE_FOR_OPEN "file_chooser_for_open"
#define FILE_CHOOSER_UI_CHOOSE_FILE_FOR_SAVE "file_chooser_for_save"
/*控件名*/
#define FILE_CHOOSER_OK "ok"
#define FILE_CHOOSER_CANCEL "cancel"
#define FILE_CHOOSER_CLOSE "close"
END_C_DECLS
#endif /*TK_FILE_CHOOSER_H*/
|
0 |
repos/awtk/src/ext_widgets
|
repos/awtk/src/ext_widgets/gauge/gauge.h
|
/**
* File: gauge.h
* Author: AWTK Develop Team
* Brief: gauge
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-09-05 Li XianJing <[email protected]> created
*
*/
#ifndef TK_GAUGE_H
#define TK_GAUGE_H
#include "base/widget.h"
BEGIN_C_DECLS
/**
* @class gauge_t
* @parent widget_t
* @annotation ["scriptable","design","widget"]
* 表盘控件。
*
* 表盘控件就是一张图片。
*
* gauge\_t是[widget\_t](widget_t.md)的子类控件，widget\_t的函数均适用于gauge\_t控件。
*
* 在xml中使用"gauge"标签创建表盘控件。如：
*
* ```xml
* <gauge x="c" y="10" w="240" h="240" image="gauge_bg" >
* ```
*
* > 更多用法请参考：
* [gauge.xml](https://github.com/zlgopen/awtk/blob/master/design/default/ui/gauge.xml)
*
* 在c代码中使用函数gauge\_create创建表盘控件。如：
*
* ```c
* widget_t* gauge = gauge_create(win, 10, 10, 200, 200);
* gauge_set_image(gauge, "gauge_bg");
* ```
*
* 可用通过style来设置控件的显示风格，如背景和边框等。如：
*
* ```xml
* <gauge>
* <style name="border">
* <normal border_color="#000000" bg_color="#e0e0e0" text_color="black"/>
* </style>
* </gauge>
* ```
*
* > 更多用法请参考：
* [theme
* default](https://github.com/zlgopen/awtk/blob/master/design/default/styles/default.xml)
*
*/
typedef struct _gauge_t {
widget_t widget;
/**
* @property {char*} image
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 背景图片。
*/
char* image;
/**
* @property {image_draw_type_t} draw_type
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 图片的绘制方式。
*/
image_draw_type_t draw_type;
} gauge_t;
/**
* @method gauge_create
* 创建gauge对象
* @annotation ["constructor", "scriptable"]
* @param {widget_t*} parent 父控件
* @param {xy_t} x x坐标
* @param {xy_t} y y坐标
* @param {wh_t} w 宽度
* @param {wh_t} h 高度
*
* @return {widget_t*} 对象。
*/
widget_t* gauge_create(widget_t* parent, xy_t x, xy_t y, wh_t w, wh_t h);
/**
* @method gauge_cast
* 转换为gauge对象(供脚本语言使用)。
* @annotation ["cast", "scriptable"]
* @param {widget_t*} widget gauge对象。
*
* @return {widget_t*} gauge对象。
*/
widget_t* gauge_cast(widget_t* widget);
/**
* @method gauge_set_image
* 设置背景图片的名称。
* @annotation ["scriptable"]
* @param {widget_t*} widget image对象。
* @param {const char*} name 图片名称，该图片必须存在于资源管理器。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t gauge_set_image(widget_t* widget, const char* name);
/**
* @method gauge_set_draw_type
* 设置图片的显示方式。
*
* > 绘制方式的属性值和枚举值:
* [image\_draw\_type\_name\_value](https://github.com/zlgopen/awtk/blob/master/src/base/enums.c#L98)
*
* @annotation ["scriptable"]
* @param {widget_t*} widget image对象。
* @param {image_draw_type_t} draw_type 显示方式。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t gauge_set_draw_type(widget_t* widget, image_draw_type_t draw_type);
#define WIDGET_TYPE_GAUGE "gauge"
#define GAUGE(widget) ((gauge_t*)(gauge_cast(WIDGET(widget))))
/*public for subclass and runtime type check*/
TK_EXTERN_VTABLE(gauge);
#define GUAGE GAUGE
#define guage_set_image gauge_set_image
#define guage_set_draw_type gauge_set_draw_type
END_C_DECLS
#endif /*TK_GAUGE_H*/
|
0 |
repos/awtk/src/ext_widgets
|
repos/awtk/src/ext_widgets/gauge/gauge_pointer.h
|
/**
* File: gauge_pointer.h
* Author: AWTK Develop Team
* Brief: gauge_pointer
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-09-05 Li XianJing <[email protected]> created
*
*/
#ifndef TK_GAUGE_POINTER_H
#define TK_GAUGE_POINTER_H
#include "base/widget.h"
BEGIN_C_DECLS
/**
* @class gauge_pointer_t
* @parent widget_t
* @annotation ["scriptable","design","widget"]
* 仪表指针控件。
*
* 仪表指针就是一张旋转的图片，图片可以是普通图片也可以是SVG图片。
*
* 在嵌入式平台上，对于旋转的图片，SVG图片的效率比位图高数倍，所以推荐使用SVG图片。
*
* gauge\_pointer\_t是[widget\_t](widget_t.md)的子类控件，widget\_t的函数均适用于gauge\_pointer\_t控件。
*
* 在xml中使用"gauge\_pointer"标签创建仪表指针控件。如：
*
* ```xml
* <gauge_pointer x="c" y="50" w="24" h="140" value="-128" image="gauge_pointer" />
* ```
*
* > 更多用法请参考：
* [gauge.xml](https://github.com/zlgopen/awtk/blob/master/design/default/ui/gauge.xml)
*
* 在c代码中使用函数gauge\_pointer\_create创建仪表指针控件。如：
*
* ```c
* widget_t* gauge_pointer = gauge_pointer_create(gauge, 10, 10, 100, 30);
* gauge_pointer_set_image(gauge_pointer, "gauge_pointer");
* ```
*
* > 创建之后，需要用gauge\_pointer\_set\_image设置仪表指针图片。
*
*
*/
typedef struct _gauge_pointer_t {
widget_t widget;
/**
* @property {float_t} angle
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 指针角度。12点钟方向为0度，顺时钟方向为正，单位为度。
*/
float_t angle;
/**
* @property {char*} image
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 指针图片。
*
* 图片须垂直向上，图片的中心点为旋转方向。
*
*/
char* image;
/**
* @property {char*} anchor_x
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 图片旋转锚点x坐标。(后面加上px为像素点，不加px为相对百分比坐标0.0f到1.0f)
*/
char* anchor_x;
/**
* @property {char*} anchor_y
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 图片旋转锚点x坐标。(后面加上px为像素点，不加px为相对百分比坐标0.0f到1.0f)
*/
char* anchor_y;
/*private*/
const asset_info_t* bsvg_asset;
} gauge_pointer_t;
/**
* @event {value_change_event_t} EVT_VALUE_WILL_CHANGE
* 值(角度)即将改变事件。
*/
/**
* @event {value_change_event_t} EVT_VALUE_CHANGED
* 值(角度)改变事件。
*/
/**
* @method gauge_pointer_create
* 创建gauge_pointer对象
* @annotation ["constructor", "scriptable"]
* @param {widget_t*} parent 父控件
* @param {xy_t} x x坐标
* @param {xy_t} y y坐标
* @param {wh_t} w 宽度
* @param {wh_t} h 高度
*
* @return {widget_t*} 对象。
*/
widget_t* gauge_pointer_create(widget_t* parent, xy_t x, xy_t y, wh_t w, wh_t h);
/**
* @method gauge_pointer_cast
* 转换为gauge_pointer对象(供脚本语言使用)。
* @annotation ["cast", "scriptable"]
* @param {widget_t*} widget gauge_pointer对象。
*
* @return {widget_t*} gauge_pointer对象。
*/
widget_t* gauge_pointer_cast(widget_t* widget);
/**
* @method gauge_pointer_set_angle
* 设置指针角度。12点钟方向为0度，顺时钟方向为正，单位为度。
* @annotation ["scriptable"]
* @param {widget_t*} widget 控件对象。
* @param {float_t} angle 指针角度。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t gauge_pointer_set_angle(widget_t* widget, float_t angle);
/**
* @method gauge_pointer_set_image
* 设置指针的图片。
* @annotation ["scriptable"]
* @param {widget_t*} widget 控件对象。
* @param {const char*} image 指针的图片。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t gauge_pointer_set_image(widget_t* widget, const char* image);
/**
* @method gauge_pointer_set_anchor
* 设置指针的旋转锚点。
* @annotation ["scriptable"]
* @param {widget_t*} widget 控件对象。
* @param {const char*} anchor_x 指针的锚点坐标x。(后面加上px为像素点，不加px为相对百分比坐标)
* @param {const char*} anchor_y 指针的锚点坐标y。(后面加上px为像素点，不加px为相对百分比坐标)
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t gauge_pointer_set_anchor(widget_t* widget, const char* anchor_x, const char* anchor_y);
#define GAUGE_POINTER_PROP_ANGLE "angle"
#define WIDGET_TYPE_GAUGE_POINTER "gauge_pointer"
#define GAUGE_POINTER(widget) ((gauge_pointer_t*)(gauge_pointer_cast(WIDGET(widget))))
/*public for subclass and runtime type check*/
TK_EXTERN_VTABLE(gauge_pointer);
/*public for test*/
ret_t gauge_pointer_set_anchor_for_str(widget_t* widget, const char* anchor, bool_t is_x);
rect_t gauge_pointer_get_dirty_rect(widget_t* widget);
#define GUAGE_POINTER GAUGE_POINTER
#define guage_pointer_set_angle gauge_pointer_set_angle
#define guage_pointer_set_image gauge_pointer_set_image
#define guage_pointer_set_anchor gauge_pointer_set_anchor
END_C_DECLS
#endif /*TK_GAUGE_POINTER_H*/
|
0 |
repos/awtk/src/ext_widgets
|
repos/awtk/src/ext_widgets/gauge/gauge.c
|
/**
* File: gauge.h
* Author: AWTK Develop Team
* Brief: gauge
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-09-05 Li XianJing <[email protected]> created
*
*/
#include "tkc/mem.h"
#include "base/enums.h"
#include "tkc/utils.h"
#include "gauge/gauge.h"
#include "base/image_manager.h"
static ret_t gauge_get_prop(widget_t* widget, const char* name, value_t* v) {
gauge_t* gauge = GAUGE(widget);
return_value_if_fail(gauge != NULL && name != NULL && v != NULL, RET_BAD_PARAMS);
if (tk_str_eq(name, WIDGET_PROP_IMAGE)) {
value_set_str(v, gauge->image);
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_DRAW_TYPE)) {
value_set_int(v, gauge->draw_type);
return RET_OK;
}
return RET_NOT_FOUND;
}
static ret_t gauge_set_prop(widget_t* widget, const char* name, const value_t* v) {
return_value_if_fail(widget != NULL && name != NULL && v != NULL, RET_BAD_PARAMS);
if (tk_str_eq(name, WIDGET_PROP_IMAGE)) {
return gauge_set_image(widget, value_str(v));
} else if (tk_str_eq(name, WIDGET_PROP_DRAW_TYPE)) {
if (v->type == VALUE_TYPE_STRING) {
const key_type_value_t* kv = image_draw_type_find(value_str(v));
if (kv != NULL) {
return gauge_set_draw_type(widget, (image_draw_type_t)(kv->value));
}
} else {
return gauge_set_draw_type(widget, (image_draw_type_t)value_int(v));
}
return RET_OK;
}
return RET_NOT_FOUND;
}
static ret_t gauge_on_destroy(widget_t* widget) {
gauge_t* gauge = GAUGE(widget);
return_value_if_fail(gauge != NULL, RET_BAD_PARAMS);
TKMEM_FREE(gauge->image);
return RET_OK;
}
ret_t gauge_set_image(widget_t* widget, const char* name) {
gauge_t* gauge = GAUGE(widget);
return_value_if_fail(gauge != NULL && name != NULL, RET_BAD_PARAMS);
gauge->image = tk_str_copy(gauge->image, name);
return RET_OK;
}
ret_t gauge_set_draw_type(widget_t* widget, image_draw_type_t draw_type) {
gauge_t* gauge = GAUGE(widget);
return_value_if_fail(gauge != NULL, RET_BAD_PARAMS);
gauge->draw_type = draw_type;
return RET_OK;
}
static const char* s_gauge_properties[] = {WIDGET_PROP_DRAW_TYPE, WIDGET_PROP_IMAGE, NULL};
static ret_t gauge_on_paint_self(widget_t* widget, canvas_t* c) {
bitmap_t bitmap;
gauge_t* gauge = GAUGE(widget);
return_value_if_fail(widget != NULL && gauge != NULL && gauge->image != NULL, RET_BAD_PARAMS);
if (widget_load_image(widget, gauge->image, &bitmap) == RET_OK) {
rect_t dst = rect_init(0, 0, widget->w, widget->h);
canvas_draw_image_ex(c, &bitmap, gauge->draw_type, &dst);
}
return RET_OK;
}
static ret_t gauge_init(widget_t* widget) {
gauge_t* gauge = GAUGE(widget);
return_value_if_fail(gauge != NULL, RET_BAD_PARAMS);
gauge->draw_type = IMAGE_DRAW_CENTER;
return RET_OK;
}
TK_DECL_VTABLE(gauge) = {.size = sizeof(gauge_t),
.type = WIDGET_TYPE_GAUGE,
.clone_properties = s_gauge_properties,
.persistent_properties = s_gauge_properties,
.get_parent_vt = TK_GET_PARENT_VTABLE(widget),
.create = gauge_create,
.init = gauge_init,
.on_paint_self = gauge_on_paint_self,
.set_prop = gauge_set_prop,
.get_prop = gauge_get_prop,
.on_destroy = gauge_on_destroy};
widget_t* gauge_create(widget_t* parent, xy_t x, xy_t y, wh_t w, wh_t h) {
widget_t* widget = widget_create(parent, TK_REF_VTABLE(gauge), x, y, w, h);
return_value_if_fail(gauge_init(widget) == RET_OK, NULL);
return widget;
}
widget_t* gauge_cast(widget_t* widget) {
return_value_if_fail(WIDGET_IS_INSTANCE_OF(widget, gauge), NULL);
return widget;
}
|
0 |
repos/awtk/src/ext_widgets
|
repos/awtk/src/ext_widgets/gauge/gauge_pointer.c
|
/**
* File: gauge_pointer.h
* Author: AWTK Develop Team
* Brief: gauge_pointer
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-09-05 Li XianJing <[email protected]> created
*
*/
#include "tkc/mem.h"
#include "tkc/utils.h"
#include "tkc/matrix.h"
#include "svg/bsvg_draw.h"
#include "base/widget_vtable.h"
#include "gauge/gauge_pointer.h"
#include "base/image_manager.h"
#include "base/assets_manager.h"
#define ANCHOR_PX_STR_LEN 2
#define DEFAULT_POINTER_SIZE 0.6f
static rect_t gauge_pointer_calc_dirty_rect(widget_t* widget, int32_t img_w, int32_t img_h) {
xy_t x = 0;
xy_t y = 0;
matrix_t m;
xy_t min_x = 0;
xy_t min_y = 0;
xy_t max_x = 0;
xy_t max_y = 0;
int32_t w = img_w;
int32_t h = img_h;
int32_t ox = widget->x;
int32_t oy = widget->y;
gauge_pointer_t* gauge_pointer = GAUGE_POINTER(widget);
ENSURE(gauge_pointer);
float_t rotation = TK_D2R(gauge_pointer->angle);
float_t anchor_x = tk_eval_ratio_or_px(gauge_pointer->anchor_x, widget->w);
float_t anchor_y = tk_eval_ratio_or_px(gauge_pointer->anchor_y, widget->h);
matrix_init(&m);
matrix_translate(&m, ox, oy);
matrix_translate(&m, anchor_x, anchor_y);
matrix_rotate(&m, rotation);
matrix_translate(&m, -anchor_x, -anchor_y);
matrix_transform_point(&m, 0, 0, &(x), &(y));
min_x = x;
max_x = x;
min_y = y;
max_y = y;
matrix_transform_point(&m, w, 0, &(x), &(y));
min_x = tk_min(min_x, x);
max_x = tk_max(max_x, x);
min_y = tk_min(min_y, y);
max_y = tk_max(max_y, y);
matrix_transform_point(&m, 0, h, &(x), &(y));
min_x = tk_min(min_x, x);
max_x = tk_max(max_x, x);
min_y = tk_min(min_y, y);
max_y = tk_max(max_y, y);
matrix_transform_point(&m, w, h, &(x), &(y));
min_x = tk_min(min_x, x);
max_x = tk_max(max_x, x);
min_y = tk_min(min_y, y);
max_y = tk_max(max_y, y);
return rect_init(min_x, min_y, max_x - min_x, max_y - min_y);
}
rect_t gauge_pointer_get_dirty_rect(widget_t* widget) {
int32_t w = 0;
int32_t h = 0;
rect_t r = rect_init(0, 0, widget->w, widget->h);
gauge_pointer_t* gauge_pointer = GAUGE_POINTER(widget);
return_value_if_fail(gauge_pointer != NULL, r);
if (widget->initializing) {
return r;
}
if (gauge_pointer->bsvg_asset != NULL || gauge_pointer->image == NULL) {
if (gauge_pointer->bsvg_asset != NULL) {
bsvg_t bsvg;
const asset_info_t* asset = gauge_pointer->bsvg_asset;
if (bsvg_init(&bsvg, (const uint32_t*)asset->data, asset->size) != NULL) {
w = bsvg.header->w;
h = bsvg.header->h;
} else {
w = widget->w;
h = widget->h * DEFAULT_POINTER_SIZE * 1.2f;
}
} else {
w = widget->w;
h = widget->h * DEFAULT_POINTER_SIZE * 1.2f;
}
} else {
bitmap_t bitmap;
if (widget_load_image(widget, gauge_pointer->image, &bitmap) == RET_OK) {
w = bitmap.w;
h = bitmap.h;
} else {
return r;
}
}
return gauge_pointer_calc_dirty_rect(widget, w, h);
}
static ret_t gauge_pointer_invalidate(widget_t* widget, const rect_t* rect) {
rect_t r;
widget_t* parent = NULL;
return_value_if_fail(widget != NULL, RET_BAD_PARAMS);
parent = widget->parent;
r = gauge_pointer_get_dirty_rect(widget);
if (parent != NULL && !parent->destroying) {
return widget_invalidate_force(parent, &r);
} else {
return RET_OK;
}
}
ret_t gauge_pointer_set_angle(widget_t* widget, float_t angle) {
gauge_pointer_t* gauge_pointer = GAUGE_POINTER(widget);
return_value_if_fail(gauge_pointer != NULL, RET_BAD_PARAMS);
if (gauge_pointer->angle != angle) {
value_change_event_t evt;
value_change_event_init(&evt, EVT_VALUE_WILL_CHANGE, widget);
value_set_float(&(evt.old_value), gauge_pointer->angle);
value_set_float(&(evt.new_value), angle);
widget_invalidate_force(widget, NULL);
if (widget_dispatch(widget, (event_t*)&evt) != RET_STOP) {
gauge_pointer->angle = angle;
evt.e.type = EVT_VALUE_CHANGED;
widget_dispatch(widget, (event_t*)&evt);
widget_invalidate_force(widget, NULL);
}
}
return RET_OK;
}
ret_t gauge_pointer_set_anchor_for_str(widget_t* widget, const char* anchor, bool_t is_x) {
gauge_pointer_t* gauge_pointer = GAUGE_POINTER(widget);
return_value_if_fail(widget != NULL, RET_BAD_PARAMS);
return_value_if_fail(anchor != NULL, RET_BAD_PARAMS);
return_value_if_fail(gauge_pointer != NULL, RET_BAD_PARAMS);
if (is_x) {
gauge_pointer->anchor_x = tk_str_copy(gauge_pointer->anchor_x, anchor);
} else {
gauge_pointer->anchor_y = tk_str_copy(gauge_pointer->anchor_y, anchor);
}
return RET_OK;
}
ret_t gauge_pointer_set_anchor(widget_t* widget, const char* anchor_x, const char* anchor_y) {
gauge_pointer_t* gauge_pointer = GAUGE_POINTER(widget);
return_value_if_fail(gauge_pointer != NULL, RET_BAD_PARAMS);
gauge_pointer_set_anchor_for_str(widget, anchor_x, TRUE);
gauge_pointer_set_anchor_for_str(widget, anchor_y, FALSE);
return RET_OK;
}
static ret_t gauge_pointer_load_svg_asset(void* ctx, event_t* e) {
widget_t* widget = WIDGET(ctx);
gauge_pointer_t* gauge_pointer = GAUGE_POINTER(widget);
return_value_if_fail(gauge_pointer != NULL, RET_BAD_PARAMS);
if (gauge_pointer->image != NULL) {
const asset_info_t* asset = widget_load_asset(widget, ASSET_TYPE_IMAGE, gauge_pointer->image);
if (gauge_pointer->bsvg_asset != NULL) {
widget_unload_asset(widget, gauge_pointer->bsvg_asset);
gauge_pointer->bsvg_asset = NULL;
}
if (asset != NULL) {
if (asset->subtype == ASSET_TYPE_IMAGE_BSVG) {
gauge_pointer->bsvg_asset = asset;
} else {
widget_unload_asset(widget, asset);
}
}
}
return RET_REMOVE;
}
ret_t gauge_pointer_set_image(widget_t* widget, const char* image) {
widget_t* win = widget_get_window(widget);
gauge_pointer_t* gauge_pointer = GAUGE_POINTER(widget);
return_value_if_fail(widget != NULL, RET_BAD_PARAMS);
return_value_if_fail(image != NULL && gauge_pointer != NULL, RET_BAD_PARAMS);
gauge_pointer->image = tk_str_copy(gauge_pointer->image, image);
if (gauge_pointer->image != NULL) {
if (win != NULL) {
gauge_pointer_load_svg_asset(widget, NULL);
} else {
widget_on(widget, EVT_BEFORE_PAINT, gauge_pointer_load_svg_asset, widget);
}
}
return RET_OK;
}
static ret_t gauge_pointer_get_prop(widget_t* widget, const char* name, value_t* v) {
gauge_pointer_t* gauge_pointer = GAUGE_POINTER(widget);
ENSURE(gauge_pointer);
return_value_if_fail(widget != NULL && name != NULL && v != NULL, RET_BAD_PARAMS);
if (tk_str_eq(name, GAUGE_POINTER_PROP_ANGLE) || tk_str_eq(name, WIDGET_PROP_VALUE)) {
value_set_float(v, gauge_pointer->angle);
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_IMAGE)) {
value_set_str(v, gauge_pointer->image);
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_ANCHOR_X)) {
value_set_str(v, gauge_pointer->anchor_x);
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_ANCHOR_Y)) {
value_set_str(v, gauge_pointer->anchor_y);
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_DIRTY_RECT)) {
value_set_rect(v, gauge_pointer_get_dirty_rect(widget));
return RET_OK;
}
return RET_NOT_FOUND;
}
static ret_t gauge_pointer_set_prop(widget_t* widget, const char* name, const value_t* v) {
return_value_if_fail(widget != NULL && name != NULL && v != NULL, RET_BAD_PARAMS);
if (tk_str_eq(name, GAUGE_POINTER_PROP_ANGLE) || tk_str_eq(name, WIDGET_PROP_VALUE)) {
return gauge_pointer_set_angle(widget, value_float(v));
} else if (tk_str_eq(name, WIDGET_PROP_IMAGE)) {
return gauge_pointer_set_image(widget, value_str(v));
} else if (tk_str_eq(name, WIDGET_PROP_ANCHOR_X)) {
return gauge_pointer_set_anchor_for_str(widget, value_str(v), TRUE);
} else if (tk_str_eq(name, WIDGET_PROP_ANCHOR_Y)) {
return gauge_pointer_set_anchor_for_str(widget, value_str(v), FALSE);
}
return RET_NOT_FOUND;
}
static ret_t gauge_pointer_on_destroy(widget_t* widget) {
gauge_pointer_t* gauge_pointer = GAUGE_POINTER(widget);
return_value_if_fail(widget != NULL && gauge_pointer != NULL, RET_BAD_PARAMS);
TKMEM_FREE(gauge_pointer->image);
if (gauge_pointer->bsvg_asset != NULL) {
widget_unload_asset(widget, gauge_pointer->bsvg_asset);
}
TKMEM_FREE(gauge_pointer->anchor_x);
TKMEM_FREE(gauge_pointer->anchor_y);
return RET_OK;
}
static ret_t gauge_pointer_paint_default(widget_t* widget, vgcanvas_t* vg) {
float_t w, h;
float_t cx, cy;
color_t bg, fg;
color_t black = color_init(0, 0, 0, 0xff);
return_value_if_fail(widget != NULL, RET_BAD_PARAMS);
w = widget->w;
h = widget->h;
cx = w * 0.5f;
cy = h * 0.5f;
bg = style_get_color(widget->astyle, STYLE_ID_BG_COLOR, black);
fg = style_get_color(widget->astyle, STYLE_ID_FG_COLOR, black);
vgcanvas_begin_path(vg);
vgcanvas_move_to(vg, cx, 0);
vgcanvas_line_to(vg, cx, cx + h * DEFAULT_POINTER_SIZE);
vgcanvas_set_line_width(vg, tk_max_int(1, tk_roundi(cx / 3.0f)));
vgcanvas_set_stroke_color(vg, bg);
vgcanvas_stroke(vg);
vgcanvas_begin_path(vg);
vgcanvas_set_fill_color(vg, fg);
vgcanvas_arc(vg, cx, cy, cx, 0, M_PI * 2, FALSE);
vgcanvas_fill(vg);
return RET_OK;
}
static ret_t gauge_pointer_on_paint_self(widget_t* widget, canvas_t* c) {
bitmap_t bitmap;
float_t rotation = 0;
float_t anchor_x = 0;
float_t anchor_y = 0;
vgcanvas_t* vg = canvas_get_vgcanvas(c);
gauge_pointer_t* gauge_pointer = GAUGE_POINTER(widget);
return_value_if_fail(gauge_pointer != NULL && widget != NULL, RET_BAD_PARAMS);
anchor_x = tk_eval_ratio_or_px(gauge_pointer->anchor_x, widget->w);
anchor_y = tk_eval_ratio_or_px(gauge_pointer->anchor_y, widget->h);
rotation = TK_D2R(gauge_pointer->angle);
vgcanvas_save(vg);
vgcanvas_translate(vg, c->ox, c->oy);
vgcanvas_translate(vg, anchor_x, anchor_y);
vgcanvas_rotate(vg, rotation);
vgcanvas_translate(vg, -anchor_x, -anchor_y);
if (gauge_pointer->bsvg_asset != NULL) {
bsvg_t bsvg;
style_t* style = widget->astyle;
color_t black = color_init(0, 0, 0, 0xff);
color_t bg = style_get_color(style, STYLE_ID_BG_COLOR, black);
color_t fg = style_get_color(style, STYLE_ID_FG_COLOR, black);
const asset_info_t* asset = gauge_pointer->bsvg_asset;
vgcanvas_set_fill_color(vg, bg);
vgcanvas_set_stroke_color(vg, fg);
bsvg_draw(bsvg_init(&bsvg, (const uint32_t*)asset->data, asset->size), vg);
} else if (gauge_pointer->image != NULL &&
widget_load_image(widget, gauge_pointer->image, &bitmap) == RET_OK) {
float_t w = bitmap.w;
float_t h = bitmap.h;
vgcanvas_draw_image(vg, &bitmap, 0, 0, w, h, 0, 0, w, h);
} else {
gauge_pointer_paint_default(widget, vg);
}
vgcanvas_restore(vg);
return RET_OK;
}
static ret_t gauge_pointer_init(widget_t* widget) {
gauge_pointer_t* gauge_pointer = GAUGE_POINTER(widget);
return_value_if_fail(gauge_pointer != NULL, RET_BAD_PARAMS);
gauge_pointer->anchor_x = tk_strdup("0.5");
gauge_pointer->anchor_y = tk_strdup("0.5");
return RET_OK;
}
static const char* s_gauge_pointer_properties[] = {
GAUGE_POINTER_PROP_ANGLE, WIDGET_PROP_IMAGE, WIDGET_PROP_ANCHOR_X, WIDGET_PROP_ANCHOR_Y, NULL};
TK_DECL_VTABLE(gauge_pointer) = {.size = sizeof(gauge_pointer_t),
.type = WIDGET_TYPE_GAUGE_POINTER,
.clone_properties = s_gauge_pointer_properties,
.persistent_properties = s_gauge_pointer_properties,
.allow_draw_outside = TRUE,
.get_parent_vt = TK_GET_PARENT_VTABLE(widget),
.create = gauge_pointer_create,
.init = gauge_pointer_init,
.on_paint_self = gauge_pointer_on_paint_self,
.on_paint_background = widget_on_paint_null,
.set_prop = gauge_pointer_set_prop,
.get_prop = gauge_pointer_get_prop,
.invalidate = gauge_pointer_invalidate,
.on_destroy = gauge_pointer_on_destroy};
widget_t* gauge_pointer_create(widget_t* parent, xy_t x, xy_t y, wh_t w, wh_t h) {
widget_t* widget = widget_create(parent, TK_REF_VTABLE(gauge_pointer), x, y, w, h);
return_value_if_fail(gauge_pointer_init(widget) == RET_OK, NULL);
return widget;
}
widget_t* gauge_pointer_cast(widget_t* widget) {
return_value_if_fail(WIDGET_IS_INSTANCE_OF(widget, gauge_pointer), NULL);
return widget;
}
|
0 |
repos/awtk/src/ext_widgets
|
repos/awtk/src/ext_widgets/features/draggable.c
|
/**
* File: draggable.c
* Author: AWTK Develop Team
* Brief: make parent widget or window draggable
*
* Copyright (c) 2019 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2019-10-25 Li XianJing <[email protected]> created
*
*/
#include "tkc/mem.h"
#include "tkc/utils.h"
#include "draggable.h"
ret_t draggable_set_top(widget_t* widget, int32_t top) {
draggable_t* draggable = DRAGGABLE(widget);
return_value_if_fail(draggable != NULL, RET_BAD_PARAMS);
draggable->top = top;
return RET_OK;
}
ret_t draggable_set_bottom(widget_t* widget, int32_t bottom) {
draggable_t* draggable = DRAGGABLE(widget);
return_value_if_fail(draggable != NULL, RET_BAD_PARAMS);
draggable->bottom = bottom;
return RET_OK;
}
ret_t draggable_set_left(widget_t* widget, int32_t left) {
draggable_t* draggable = DRAGGABLE(widget);
return_value_if_fail(draggable != NULL, RET_BAD_PARAMS);
draggable->left = left;
return RET_OK;
}
ret_t draggable_set_right(widget_t* widget, int32_t right) {
draggable_t* draggable = DRAGGABLE(widget);
return_value_if_fail(draggable != NULL, RET_BAD_PARAMS);
draggable->right = right;
return RET_OK;
}
ret_t draggable_set_vertical_only(widget_t* widget, bool_t vertical_only) {
draggable_t* draggable = DRAGGABLE(widget);
return_value_if_fail(draggable != NULL, RET_BAD_PARAMS);
draggable->vertical_only = vertical_only;
return RET_OK;
}
ret_t draggable_set_horizontal_only(widget_t* widget, bool_t horizontal_only) {
draggable_t* draggable = DRAGGABLE(widget);
return_value_if_fail(draggable != NULL, RET_BAD_PARAMS);
draggable->horizontal_only = horizontal_only;
return RET_OK;
}
ret_t draggable_set_allow_out_of_screen(widget_t* widget, bool_t allow_out_of_screen) {
draggable_t* draggable = DRAGGABLE(widget);
return_value_if_fail(draggable != NULL, RET_BAD_PARAMS);
draggable->allow_out_of_screen = allow_out_of_screen;
return RET_OK;
}
ret_t draggable_set_drag_window(widget_t* widget, bool_t drag_window) {
draggable_t* draggable = DRAGGABLE(widget);
return_value_if_fail(draggable != NULL, RET_BAD_PARAMS);
draggable->drag_window = drag_window;
return RET_OK;
}
ret_t draggable_set_drag_native_window(widget_t* widget, bool_t drag_native_window) {
draggable_t* draggable = DRAGGABLE(widget);
return_value_if_fail(draggable != NULL, RET_BAD_PARAMS);
draggable->drag_native_window = drag_native_window;
return RET_OK;
}
ret_t draggable_set_drag_parent(widget_t* widget, uint32_t drag_parent) {
draggable_t* draggable = DRAGGABLE(widget);
return_value_if_fail(draggable != NULL, RET_BAD_PARAMS);
draggable->drag_parent = drag_parent;
return RET_OK;
}
static ret_t draggable_get_prop(widget_t* widget, const char* name, value_t* v) {
draggable_t* draggable = DRAGGABLE(widget);
return_value_if_fail(draggable != NULL && name != NULL && v != NULL, RET_BAD_PARAMS);
if (tk_str_eq(DRAGGABLE_PROP_TOP, name)) {
value_set_int32(v, draggable->top);
return RET_OK;
} else if (tk_str_eq(DRAGGABLE_PROP_BOTTOM, name)) {
value_set_int32(v, draggable->bottom);
return RET_OK;
} else if (tk_str_eq(DRAGGABLE_PROP_LEFT, name)) {
value_set_int32(v, draggable->left);
return RET_OK;
} else if (tk_str_eq(DRAGGABLE_PROP_RIGHT, name)) {
value_set_int32(v, draggable->right);
return RET_OK;
} else if (tk_str_eq(DRAGGABLE_PROP_VERTICAL_ONLY, name)) {
value_set_bool(v, draggable->vertical_only);
return RET_OK;
} else if (tk_str_eq(DRAGGABLE_PROP_HORIZONTAL_ONLY, name)) {
value_set_bool(v, draggable->horizontal_only);
return RET_OK;
} else if (tk_str_eq(DRAGGABLE_PROP_DRAG_WINDOW, name)) {
value_set_bool(v, draggable->drag_window);
return RET_OK;
} else if (tk_str_eq(DRAGGABLE_PROP_DRAG_NATIVE_WINDOW, name)) {
value_set_bool(v, draggable->drag_native_window);
return RET_OK;
} else if (tk_str_eq(DRAGGABLE_PROP_DRAG_PARENT, name)) {
value_set_uint32(v, draggable->drag_parent);
return RET_OK;
} else if (tk_str_eq(DRAGGABLE_PROP_ALLOW_OUT_OF_SCREEN, name)) {
value_set_bool(v, draggable->allow_out_of_screen);
return RET_OK;
}
return RET_NOT_FOUND;
}
static ret_t draggable_set_prop(widget_t* widget, const char* name, const value_t* v) {
return_value_if_fail(widget != NULL && name != NULL && v != NULL, RET_BAD_PARAMS);
if (tk_str_eq(DRAGGABLE_PROP_TOP, name)) {
draggable_set_top(widget, value_int32(v));
return RET_OK;
} else if (tk_str_eq(DRAGGABLE_PROP_BOTTOM, name)) {
draggable_set_bottom(widget, value_int32(v));
return RET_OK;
} else if (tk_str_eq(DRAGGABLE_PROP_LEFT, name)) {
draggable_set_left(widget, value_int32(v));
return RET_OK;
} else if (tk_str_eq(DRAGGABLE_PROP_RIGHT, name)) {
draggable_set_right(widget, value_int32(v));
return RET_OK;
} else if (tk_str_eq(DRAGGABLE_PROP_VERTICAL_ONLY, name)) {
draggable_set_vertical_only(widget, value_bool(v));
return RET_OK;
} else if (tk_str_eq(DRAGGABLE_PROP_HORIZONTAL_ONLY, name)) {
draggable_set_horizontal_only(widget, value_bool(v));
return RET_OK;
} else if (tk_str_eq(DRAGGABLE_PROP_DRAG_WINDOW, name)) {
draggable_set_drag_window(widget, value_bool(v));
return RET_OK;
} else if (tk_str_eq(DRAGGABLE_PROP_DRAG_NATIVE_WINDOW, name)) {
draggable_set_drag_native_window(widget, value_bool(v));
return RET_OK;
} else if (tk_str_eq(DRAGGABLE_PROP_DRAG_PARENT, name)) {
draggable_set_drag_parent(widget, value_uint32(v));
return RET_OK;
} else if (tk_str_eq(DRAGGABLE_PROP_ALLOW_OUT_OF_SCREEN, name)) {
draggable_set_allow_out_of_screen(widget, value_bool(v));
return RET_OK;
}
return RET_NOT_FOUND;
}
static ret_t draggable_on_destroy(widget_t* widget) {
draggable_t* draggable = DRAGGABLE(widget);
return_value_if_fail(widget != NULL && draggable != NULL, RET_BAD_PARAMS);
(void)draggable;
return RET_OK;
}
static ret_t draggable_on_paint_self(widget_t* widget, canvas_t* c) {
return RET_OK;
}
static widget_t* draggable_get_target(widget_t* widget) {
widget_t* target = NULL;
draggable_t* draggable = DRAGGABLE(widget);
return_value_if_fail(draggable != NULL, NULL);
if (draggable->drag_window) {
target = widget_get_window(widget);
} else {
uint32_t i = draggable->drag_parent;
target = widget->parent;
while (i > 0 && target != NULL && target->parent != NULL) {
target = target->parent;
if (widget_is_window(target)) {
break;
}
i--;
}
}
return target;
}
static ret_t draggable_on_parent_pointer_down(void* ctx, event_t* e) {
widget_t* widget = WIDGET(ctx);
return_value_if_fail(widget != NULL, RET_BAD_PARAMS);
if (widget->enable) {
pointer_event_t* evt = (pointer_event_t*)e;
draggable_t* draggable = DRAGGABLE(widget);
return_value_if_fail(draggable != NULL, RET_BAD_PARAMS);
widget_t* target = draggable_get_target(widget);
draggable->pressed = TRUE;
draggable->down.x = evt->x;
draggable->down.y = evt->y;
if (draggable->drag_native_window) {
native_window_info_t info;
native_window_t* nw = widget_get_native_window(widget);
native_window_get_info(nw, &info);
draggable->saved_position.x = info.x;
draggable->saved_position.y = info.y;
} else {
draggable->saved_position.x = target->x;
draggable->saved_position.y = target->y;
}
widget_grab(widget->parent->parent, widget->parent);
widget_dispatch_simple_event(widget, EVT_DRAG_START);
}
return RET_OK;
}
static ret_t draggable_move_target(widget_t* widget, xy_t x, xy_t y) {
widget_t* target = NULL;
draggable_t* draggable = DRAGGABLE(widget);
native_window_t* nw = widget_get_native_window(widget);
return_value_if_fail(draggable != NULL, RET_BAD_PARAMS);
target = draggable_get_target(widget);
return_value_if_fail(target != NULL, RET_BAD_PARAMS);
xy_t min_x = draggable->left != DRAGGABLE_UNSPECIFIED_NUM
? draggable->left
: (draggable->allow_out_of_screen ? 1 - target->w : 0);
xy_t min_y = draggable->top != DRAGGABLE_UNSPECIFIED_NUM
? draggable->top
: (draggable->allow_out_of_screen ? 1 - target->h : 0);
xy_t max_x =
draggable->right != DRAGGABLE_UNSPECIFIED_NUM
? draggable->right - target->w
: (draggable->allow_out_of_screen ? nw->rect.w - 1 : target->parent->w - target->w);
xy_t max_y =
draggable->bottom != DRAGGABLE_UNSPECIFIED_NUM
? draggable->bottom - target->h
: (draggable->allow_out_of_screen ? nw->rect.h - 1 : target->parent->h - target->h);
if (min_x < max_x) {
x = tk_clampi(x, min_x, max_x);
}
if (min_y < max_y) {
y = tk_clampi(y, min_y, max_y);
}
widget_move(target, x, y);
return RET_OK;
}
static ret_t draggable_on_parent_pointer_move(void* ctx, event_t* e) {
widget_t* widget = WIDGET(ctx);
draggable_t* draggable = DRAGGABLE(widget);
return_value_if_fail(widget != NULL && draggable != NULL, RET_BAD_PARAMS);
if (widget->enable && draggable->pressed) {
xy_t x = 0;
xy_t y = 0;
pointer_event_t* evt = (pointer_event_t*)e;
xy_t dx = evt->x - draggable->down.x;
xy_t dy = evt->y - draggable->down.y;
x = draggable->saved_position.x + (draggable->vertical_only ? 0 : dx);
y = draggable->saved_position.y + (draggable->horizontal_only ? 0 : dy);
if (draggable->drag_native_window) {
native_window_t* nw = widget_get_native_window(widget);
native_window_move(nw, x, y, TRUE);
} else {
draggable_move_target(widget, x, y);
}
widget_dispatch_simple_event(widget, EVT_DRAG);
}
return RET_OK;
}
static ret_t draggable_on_parent_pointer_up(void* ctx, event_t* e) {
widget_t* widget = WIDGET(ctx);
return_value_if_fail(widget != NULL, RET_BAD_PARAMS);
if (widget->enable) {
int32_t dx, dy;
widget_t* target = NULL;
draggable_t* draggable = DRAGGABLE(widget);
return_value_if_fail(draggable != NULL, RET_BAD_PARAMS);
draggable->pressed = FALSE;
target = draggable_get_target(widget);
dx = target->x - draggable->saved_position.x;
dy = target->y - draggable->saved_position.y;
if (tk_abs(dx) > 5 || tk_abs(dy) > 5) {
pointer_event_t abort;
pointer_event_init(&abort, EVT_POINTER_DOWN_ABORT, NULL, 0, 0);
widget_dispatch(widget->parent, (event_t*)&abort);
}
widget_ungrab(widget->parent->parent, widget->parent);
widget_dispatch_simple_event(widget, EVT_DRAG_END);
}
return RET_OK;
}
static ret_t draggable_on_attach_parent(widget_t* widget, widget_t* parent) {
draggable_t* draggable = DRAGGABLE(widget);
widget_on(parent, EVT_POINTER_DOWN_BEFORE_CHILDREN, draggable_on_parent_pointer_down, draggable);
widget_on(parent, EVT_POINTER_MOVE_BEFORE_CHILDREN, draggable_on_parent_pointer_move, draggable);
widget_on(parent, EVT_POINTER_UP_BEFORE_CHILDREN, draggable_on_parent_pointer_up, draggable);
return RET_OK;
}
static ret_t draggable_on_detach_parent(widget_t* widget, widget_t* parent) {
widget_off_by_ctx(parent, widget);
return RET_OK;
}
static ret_t draggable_on_event(widget_t* widget, event_t* e) {
draggable_t* draggable = DRAGGABLE(widget);
return_value_if_fail(widget != NULL && draggable != NULL, RET_BAD_PARAMS);
(void)draggable;
return RET_OK;
}
static ret_t draggable_init(widget_t* widget) {
draggable_t* draggable = DRAGGABLE(widget);
return_value_if_fail(draggable != NULL, RET_BAD_PARAMS);
draggable->top = DRAGGABLE_UNSPECIFIED_NUM;
draggable->bottom = DRAGGABLE_UNSPECIFIED_NUM;
draggable->left = DRAGGABLE_UNSPECIFIED_NUM;
draggable->right = DRAGGABLE_UNSPECIFIED_NUM;
draggable->vertical_only = FALSE;
draggable->horizontal_only = FALSE;
draggable->drag_window = FALSE;
draggable->pressed = FALSE;
draggable->allow_out_of_screen = FALSE;
widget_set_sensitive(widget, FALSE);
return RET_OK;
}
const char* s_draggable_properties[] = {
DRAGGABLE_PROP_TOP, DRAGGABLE_PROP_BOTTOM,
DRAGGABLE_PROP_LEFT, DRAGGABLE_PROP_RIGHT,
DRAGGABLE_PROP_VERTICAL_ONLY, DRAGGABLE_PROP_HORIZONTAL_ONLY,
DRAGGABLE_PROP_DRAG_WINDOW, NULL};
TK_DECL_VTABLE(draggable) = {.size = sizeof(draggable_t),
.type = WIDGET_TYPE_DRAGGABLE,
.clone_properties = s_draggable_properties,
.persistent_properties = s_draggable_properties,
.get_parent_vt = TK_GET_PARENT_VTABLE(widget),
.create = draggable_create,
.init = draggable_init,
.on_paint_self = draggable_on_paint_self,
.set_prop = draggable_set_prop,
.get_prop = draggable_get_prop,
.on_event = draggable_on_event,
.on_attach_parent = draggable_on_attach_parent,
.on_detach_parent = draggable_on_detach_parent,
.on_destroy = draggable_on_destroy};
widget_t* draggable_create(widget_t* parent, xy_t x, xy_t y, wh_t w, wh_t h) {
widget_t* widget = widget_create(parent, TK_REF_VTABLE(draggable), x, y, w, h);
return_value_if_fail(draggable_init(widget) == RET_OK, NULL)
return widget;
}
widget_t* draggable_cast(widget_t* widget) {
return_value_if_fail(WIDGET_IS_INSTANCE_OF(widget, draggable), NULL);
return widget;
}
#include "base/widget_factory.h"
ret_t draggable_register(void) {
return widget_factory_register(widget_factory(), WIDGET_TYPE_DRAGGABLE, draggable_create);
}
|
0 |
repos/awtk/src/ext_widgets
|
repos/awtk/src/ext_widgets/features/draggable.h
|
/**
* File: draggable.h
* Author: AWTK Develop Team
* Brief: make parent widget or window draggable
*
* Copyright (c) 2019 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2019-10-25 Li XianJing <[email protected]> created
*
*/
#ifndef TK_DRAGGABLE_H
#define TK_DRAGGABLE_H
#include "base/widget.h"
BEGIN_C_DECLS
/**
* @class draggable_t
* @parent widget_t
* @annotation ["scriptable","design","widget"]
*
* 将draggable放入目标控件，即可让目标控件或当前窗口可以被拖动。
*
* draggable\_t是[widget\_t](widget_t.md)的子类控件，widget\_t的函数均适用于draggable\_t控件。
*
* 在xml中使用"draggable"标签创建draggable控件。如：
*
* ```xml
* <button text="Drag Me" w="80" h="40" x="10" y="10">
* <draggable />
* </button>
* ```
*
* 拖动对话框标题时移动对话框：
*
* ```xml
* <dialog_title x="0" y="0" w="100%" h="30" text="Hello AWTK" >
* <draggable drag_window="true"/>
* </dialog_title>
* ```
*
* > 更多用法请参考：
* [draggable.xml](https://github.com/zlgopen/awtk/blob/master/design/default/ui/draggable.xml)
*
* 在c代码中使用函数draggable\_create创建按钮控件。如：
*
* ```c
* widget_t* draggable = draggable_create(target, 0, 0, 0, 0);
* ```
*
* > draggable本身不可见，故无需style。
*
*/
typedef struct _draggable_t {
widget_t widget;
/**
* @property {int32_t} top
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 拖动范围的顶部限制。缺省为父控件的顶部。
*/
int32_t top;
/**
* @property {int32_t} bottom
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 拖动范围的底部限制。缺省为父控件的底部。
*/
int32_t bottom;
/**
* @property {int32_t} left
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 拖动范围的左边限制。缺省为父控件的左边。
*/
int32_t left;
/**
* @property {int32_t} right
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 拖动范围的右边限制。缺省为父控件的右边边。
*/
int32_t right;
/**
* @property {bool_t} allow_out_of_screen
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 支持超出原生窗口边界拖动。（无法完全移出原生窗口，同时优先受到拖动范围限制的影响）
*/
bool_t allow_out_of_screen;
/**
* @property {bool_t} vertical_only
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 只允许垂直拖动。
*/
bool_t vertical_only;
/**
* @property {bool_t} horizontal_only
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 只允许水平拖动。
*/
bool_t horizontal_only;
/**
* @property {bool_t} drag_window
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 拖动窗口而不是父控件。比如放在对话框的titlebar上，拖动titlebar其实是希望拖动对话框。
*/
bool_t drag_window;
/**
* @property {bool_t} drag_native_window
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 拖动原生窗口。
*/
bool_t drag_native_window;
/**
* @property {uint32_t} drag_parent
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 拖动父控件。0表示直系父控件，1表示父控件的父控件，依次类推。
*/
uint32_t drag_parent;
/*private*/
bool_t pressed;
point_t down;
point_t saved_position;
} draggable_t;
/**
* @method draggable_create
* @annotation ["constructor", "scriptable"]
* 创建draggable对象
* @param {widget_t*} parent 父控件
* @param {xy_t} x x坐标
* @param {xy_t} y y坐标
* @param {wh_t} w 宽度
* @param {wh_t} h 高度
*
* @return {widget_t*} 对象。
*/
widget_t* draggable_create(widget_t* parent, xy_t x, xy_t y, wh_t w, wh_t h);
/**
* @method draggable_cast
* 转换为draggable对象(供脚本语言使用)。
* @annotation ["cast", "scriptable"]
* @param {widget_t*} widget draggable对象。
*
* @return {widget_t*} draggable对象。
*/
widget_t* draggable_cast(widget_t* widget);
/**
* @method draggable_set_top
* 设置top。
* @annotation ["scriptable"]
* @param {widget_t*} widget widget对象。
* @param {int32_t} top 拖动范围的顶部限制。缺省为父控件的顶部。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t draggable_set_top(widget_t* widget, int32_t top);
/**
* @method draggable_set_bottom
* 设置bottom。
* @annotation ["scriptable"]
* @param {widget_t*} widget widget对象。
* @param {int32_t} bottom 拖动范围的底部限制。缺省为父控件的底部。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t draggable_set_bottom(widget_t* widget, int32_t bottom);
/**
* @method draggable_set_left
* 设置left。
* @annotation ["scriptable"]
* @param {widget_t*} widget widget对象。
* @param {int32_t} left 拖动范围的左边限制。缺省为父控件的左边。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t draggable_set_left(widget_t* widget, int32_t left);
/**
* @method draggable_set_right
* 设置right。
* @annotation ["scriptable"]
* @param {widget_t*} widget widget对象。
* @param {int32_t} right 拖动范围的右边限制。缺省为父控件的右边边。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t draggable_set_right(widget_t* widget, int32_t right);
/**
* @method draggable_set_vertical_only
* 设置vertical_only。
* @annotation ["scriptable"]
* @param {widget_t*} widget widget对象。
* @param {bool_t} vertical_only 只允许垂直拖动。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t draggable_set_vertical_only(widget_t* widget, bool_t vertical_only);
/**
* @method draggable_set_horizontal_only
* 设置horizontal_only。
* @annotation ["scriptable"]
* @param {widget_t*} widget widget对象。
* @param {bool_t} horizontal_only 只允许水平拖动。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t draggable_set_horizontal_only(widget_t* widget, bool_t horizontal_only);
/**
* @method draggable_set_allow_out_of_screen
* 设置是否无范围限制拖动。
* 备注：可以让窗口拖动到外面去。
* @annotation ["scriptable"]
* @param {widget_t*} widget widget对象。
* @param {bool_t} allow_out_of_screen 是否无范围限制拖动。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t draggable_set_allow_out_of_screen(widget_t* widget, bool_t allow_out_of_screen);
/**
* @method draggable_set_drag_window
* 设置drag_window。
* @annotation ["scriptable"]
* @param {widget_t*} widget widget对象。
* @param {bool_t} drag_window 是否拖动窗口。
* 拖动窗口而不是父控件。比如放在对话框的titlebar上，拖动titlebar其实是希望拖动对话框。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t draggable_set_drag_window(widget_t* widget, bool_t drag_window);
/**
* @method draggable_set_drag_native_window
* 设置drag_native_window。
* @annotation ["scriptable"]
* @param {widget_t*} widget widget对象。
* @param {bool_t} drag_native_window 是否拖动原生窗口。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t draggable_set_drag_native_window(widget_t* widget, bool_t drag_native_window);
/**
* @method draggable_set_drag_parent
* 设置drag_parent。
* @annotation ["scriptable"]
* @param {widget_t*} widget widget对象。
* @param {uint32_t} drag_parent 0表示直系父控件，1表示父控件的父控件，依次类推。
* 拖动窗口而不是父控件。比如放在对话框的titlebar上，拖动titlebar其实是希望拖动对话框。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t draggable_set_drag_parent(widget_t* widget, uint32_t drag_parent);
#define DRAGGABLE_PROP_TOP "top"
#define DRAGGABLE_PROP_BOTTOM "bottom"
#define DRAGGABLE_PROP_LEFT "left"
#define DRAGGABLE_PROP_RIGHT "right"
#define DRAGGABLE_PROP_DRAG_WINDOW "drag_window"
#define DRAGGABLE_PROP_DRAG_PARENT "drag_parent"
#define DRAGGABLE_PROP_ALLOW_OUT_OF_SCREEN "allow_out_of_screen"
#define DRAGGABLE_PROP_VERTICAL_ONLY "vertical_only"
#define DRAGGABLE_PROP_HORIZONTAL_ONLY "horizontal_only"
#define DRAGGABLE_PROP_DRAG_NATIVE_WINDOW "drag_native_window"
#define WIDGET_TYPE_DRAGGABLE "draggable"
#define DRAGGABLE_UNSPECIFIED_NUM 0x1fffffff
#define DRAGGABLE(widget) ((draggable_t*)(draggable_cast(WIDGET(widget))))
ret_t draggable_register(void);
/*public for subclass and runtime type check*/
TK_EXTERN_VTABLE(draggable);
END_C_DECLS
#endif /*TK_DRAGGABLE_H*/
|
0 |
repos/awtk/src/ext_widgets
|
repos/awtk/src/ext_widgets/features/README.md
|
# 特性类控件
特性类控件一般是给所在的容器控件加上指定的特性。比如可拖动、可点击、可选择、可调整大小和上下文帮助等。
|
0 |
repos/awtk/src/ext_widgets
|
repos/awtk/src/ext_widgets/text_selector/text_selector.h
|
/**
* File: text_selector.h
* Author: AWTK Develop Team
* Brief: text_selector
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-09-25 Li XianJing <[email protected]> created
*
*/
#ifndef TK_TEXT_SELECTOR_H
#define TK_TEXT_SELECTOR_H
#include "base/widget.h"
#include "base/velocity.h"
#include "base/widget_animator.h"
BEGIN_C_DECLS
typedef struct _text_selector_option_t {
int32_t value;
struct _text_selector_option_t* next;
char* tr_text;
wstr_t text;
} text_selector_option_t;
/**
* @class text_selector_t
* @parent widget_t
* @annotation ["scriptable","design","widget"]
* 文本选择器控件，通常用于选择日期和时间等。
*
* > XXX: 目前需要先设置options和visible_nr，再设置其它参数(在XML中也需要按此顺序)。
*
* text\_selector\_t是[widget\_t](widget_t.md)的子类控件，widget\_t的函数均适用于text\_selector\_t控件。
*
* 在xml中使用"text\_selector"标签创建文本选择器控件。如：
*
* ```xml
* <text_selector options="red;green;blue;gold;orange" visible_nr="3" text="red"/>
* ```
*
* > 更多用法请参考：[text\_selector.xml](
* https://github.com/zlgopen/awtk/blob/master/design/default/ui/text_selector.xml)
*
* 在c代码中使用函数text\_selector\_create创建文本选择器控件。如：
*
* ```c
* widget_t* ts = text_selector_create(win, 10, 10, 80, 150);
* text_selector_set_options(ts, "1:red;2:green;3:blue;4:orange;5:gold");
* text_selector_set_value(ts, 1);
* widget_use_style(ts, "dark");
* ```
*
* > 完整示例请参考：[text\_selector demo](
* https://github.com/zlgopen/awtk-c-demos/blob/master/demos/text_selector.c)
*
* 可用通过style来设置控件的显示风格，如字体和背景颜色等。如：
*
* ```xml
* <style name="dark" fg_color="#a0a0a0" text_color="black" text_align_h="center">
* <normal bg_color="#ffffff" mask_color="#404040" border_color="#404040"/>
* </style>
* ```
*
* > 更多用法请参考：[theme default](
* https://github.com/zlgopen/awtk/blob/master/design/default/styles/default.xml#L443)
*
*/
typedef struct _text_selector_t {
widget_t widget;
/**
* @property {uint32_t} visible_nr
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 可见的选项数量(只能是1或者3或者5，缺省为5)。
*/
uint32_t visible_nr;
/**
* @property {int32_t} selected_index
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 当前选中的选项。
*/
int32_t selected_index;
/**
* @property {char*} options
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 设置可选项(英文冒号(:)分隔值和文本，英文分号(;)分隔选项，如:1:red;2:green;3:blue)。
* 对于数值选项，也可以指定一个范围，用英文负号(-)分隔起始值、结束值和格式。
* 如："1-7-%02d"表示1到7，格式为『02d』，格式为可选，缺省为『%d』。
* > 如果数据本身中有英文冒号(:)、英文分号(;)和英文负号(-)。请用16进制转义。
* > * 英文冒号(:)写为\\x3a
* > * 英文冒号(;)写为\\x3b
* > * 英文冒号(-)写为\\x2d
*/
char* options;
/**
* @property {float_t} yspeed_scale
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* y偏移速度比例。
*/
float_t yspeed_scale;
/**
* @property {uint32_t} animating_time
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 滚动动画播放时间。(单位毫秒)
*/
uint32_t animating_time;
/**
* @property {bool_t} localize_options
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 是否本地化(翻译)选项(缺省为FALSE)。
*/
bool_t localize_options;
/**
* @property {bool_t} loop_options
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 是否循环选项(缺省为FALSE)。
*/
bool_t loop_options;
/**
* @property {bool_t} enable_value_animator
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 是否修改值时启用动画。
*/
bool_t enable_value_animator;
/**
* @property {bool_t} ellipses
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 是否开启缩写，开启后，当文字长度操作控件长度后，自动变为...
*/
bool_t ellipses;
/**
* @property {easing_type_t} mask_easing
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 绘制蒙版的变化趋势。
*/
easing_type_t mask_easing;
/**
* @property {float_t} mask_area_scale
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 绘制蒙版的区域占比（范围0~1）。
*/
float_t mask_area_scale;
/*private*/
bool_t pressed;
bool_t is_init;
str_t text;
int32_t ydown;
int32_t yoffset;
int32_t yoffset_save;
velocity_t velocity;
widget_animator_t* wa;
int32_t draw_widget_y;
int32_t draw_widget_h;
uint32_t locale_info_id;
int32_t last_selected_index;
text_selector_option_t* option_items;
} text_selector_t;
/**
* @event {value_change_event_t} EVT_VALUE_WILL_CHANGE
* 值(当前项)即将改变事件。
*/
/**
* @event {value_change_event_t} EVT_VALUE_CHANGED
* 值(当前项)改变事件。
*/
/**
* @method text_selector_create
* 创建text_selector对象
* @annotation ["constructor", "scriptable"]
* @param {widget_t*} parent 父控件
* @param {xy_t} x x坐标
* @param {xy_t} y y坐标
* @param {wh_t} w 宽度
* @param {wh_t} h 高度
*
* @return {widget_t*} 对象。
*/
widget_t* text_selector_create(widget_t* parent, xy_t x, xy_t y, wh_t w, wh_t h);
/**
* @method text_selector_cast
* 转换text_selector对象(供脚本语言使用)。
* @annotation ["cast", "scriptable"]
* @param {widget_t*} widget text_selector对象。
*
* @return {widget_t*} text_selector对象。
*/
widget_t* text_selector_cast(widget_t* widget);
/**
* @method text_selector_reset_options
* 重置所有选项。
* @annotation ["scriptable"]
* @param {widget_t*} widget text_selector对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t text_selector_reset_options(widget_t* widget);
/**
* @method text_selector_count_options
* 获取选项个数。
* @annotation ["scriptable"]
* @param {widget_t*} widget text_selector对象。
*
* @return {int32_t} 返回选项个数。
*/
int32_t text_selector_count_options(widget_t* widget);
/**
* @method text_selector_append_option
* 追加一个选项。
* @annotation ["scriptable"]
* @param {widget_t*} widget text_selector对象。
* @param {int32_t} value 值。
* @param {const char*} text 文本。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t text_selector_append_option(widget_t* widget, int32_t value, const char* text);
/**
* @method text_selector_set_options
* 设置选项。
* @annotation ["scriptable"]
* @param {widget_t*} widget text_selector对象。
* @param {const char*} options 选项。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t text_selector_set_options(widget_t* widget, const char* options);
/**
* @method text_selector_set_range_options_ex
* 设置一系列的整数选项。
* @annotation ["scriptable"]
* @param {widget_t*} widget text_selector对象。
* @param {int32_t} start 起始值。
* @param {uint32_t} nr 个数。
* @param {int32_t} step 步长。
* @param {const char*} format 选项的格式化。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t text_selector_set_range_options_ex(widget_t* widget, int32_t start, uint32_t nr, int32_t step,
const char* format);
/**
* @method text_selector_set_range_options
* 设置一系列的整数选项。
* @annotation ["scriptable"]
* @param {widget_t*} widget text_selector对象。
* @param {int32_t} start 起始值。
* @param {uint32_t} nr 个数。
* @param {int32_t} step 步长。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t text_selector_set_range_options(widget_t* widget, int32_t start, uint32_t nr, int32_t step);
/**
* @method text_selector_get_option
* 获取第index个选项。
* @param {widget_t*} widget text_selector对象。
* @param {uint32_t} index 选项的索引。
*
* @return {text_selector_option_t*} 成功返回选项，失败返回NULL。
*/
text_selector_option_t* text_selector_get_option(widget_t* widget, uint32_t index);
/**
* @method text_selector_get_value
* 获取text_selector的值。
* @alias text_selector_get_value_int
* @annotation ["scriptable"]
* @param {widget_t*} widget text_selector对象。
*
* @return {int32_t} 返回值。
*/
int32_t text_selector_get_value(widget_t* widget);
/**
* @method text_selector_set_value
* 设置text_selector的值。
* @annotation ["scriptable"]
* @param {widget_t*} widget text_selector对象。
* @param {int32_t} value 值。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t text_selector_set_value(widget_t* widget, int32_t value);
/**
* @method text_selector_get_text
* 获取text_selector的文本。
* @annotation ["scriptable"]
* @alias text_selector_get_text_value
* @param {widget_t*} widget text_selector对象。
*
* @return {const char*} 返回文本。
*/
const char* text_selector_get_text(widget_t* widget);
/**
* @method text_selector_set_text
* 设置text_selector的文本。
* @annotation ["scriptable"]
* @param {widget_t*} widget text_selector对象。
* @param {const char*} text 文本。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t text_selector_set_text(widget_t* widget, const char* text);
/**
* @method text_selector_set_selected_index
* 设置第index个选项为当前选中的选项。
* @annotation ["scriptable"]
* @param {widget_t*} widget text_selector对象。
* @param {uint32_t} index 选项的索引。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t text_selector_set_selected_index(widget_t* widget, uint32_t index);
/**
* @method text_selector_set_visible_nr
* 设置可见的选项数。
* @annotation ["scriptable"]
* @param {widget_t*} widget text_selector对象。
* @param {uint32_t} visible_nr 选项数。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t text_selector_set_visible_nr(widget_t* widget, uint32_t visible_nr);
/**
* @method text_selector_set_localize_options
* 设置是否本地化(翻译)选项。
* @annotation ["scriptable"]
* @param {widget_t*} widget text_selector对象。
* @param {bool_t} localize_options 是否本地化(翻译)选项。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t text_selector_set_localize_options(widget_t* widget, bool_t localize_options);
/**
* @method text_selector_set_loop_options
* 设置是否循环选项。
* @annotation ["scriptable"]
* @param {widget_t*} widget text_selector对象。
* @param {bool_t} loop_options 是否循环选项。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t text_selector_set_loop_options(widget_t* widget, bool_t loop_options);
/**
* @method text_selector_set_yspeed_scale
* 设置Y轴偏移速度比例。
* @annotation ["scriptable"]
* @param {widget_t*} widget 控件对象。
* @param {float_t} yspeed_scale y偏移速度比例。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t text_selector_set_yspeed_scale(widget_t* widget, float_t yspeed_scale);
/**
* @method text_selector_set_animating_time
* 设置滚动动画播放时间。
* @annotation ["scriptable"]
* @param {widget_t*} widget 控件对象。
* @param {uint32_t} animating_time 滚动动画播放时间。(单位毫秒)
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t text_selector_set_animating_time(widget_t* widget, uint32_t animating_time);
/**
* @method text_selector_set_enable_value_animator
* 设置是否修改值时启用动画。
* @annotation ["scriptable"]
* @param {widget_t*} widget 控件对象。
* @param {bool_t} enable_value_animator 是否修改值时启用动画
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t text_selector_set_enable_value_animator(widget_t* widget, bool_t enable_value_animator);
/**
* @method text_selector_set_mask_easing
* 设置绘制蒙版的变化趋势。
* @annotation ["scriptable"]
* @param {widget_t*} widget 控件对象。
* @param {easing_type_t} mask_easing 绘制蒙版的变化趋势。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t text_selector_set_mask_easing(widget_t* widget, easing_type_t mask_easing);
/**
* @method text_selector_set_mask_area_scale
* 设置绘制蒙版的区域占比（范围0~1）。
* @annotation ["scriptable"]
* @param {widget_t*} widget 控件对象。
* @param {float_t} mask_area_scale 绘制蒙版的区域占比（范围0~1）。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t text_selector_set_mask_area_scale(widget_t* widget, float_t mask_area_scale);
/**
* @method text_selector_set_ellipses
* 是否开启缩写，开启后，当文字长度操作控件长度后，自动变为...
* @annotation ["scriptable"]
* @param {widget_t*} widget 控件对象。
* @param {bool_t} ellipses 是否开启缩写。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t text_selector_set_ellipses(widget_t* widget, bool_t ellipses);
#define TEXT_SELECTOR_PROP_VISIBLE_NR "visible_nr"
#define WIDGET_TYPE_TEXT_SELECTOR "text_selector"
#define TEXT_SELECTOR_PROP_LOOP_OPTIONS "loop_options"
#define TEXT_SELECTOR_PROP_Y_SPEED_SCALE "yspeed_scale"
#define TEXT_SELECTOR_PROP_ANIMATION_TIME "animating_time"
#define TEXT_SELECTOR_PROP_ENABLE_VALUE_ANIMATOR "enable_value_animator"
#define TEXT_SELECTOR_PROP_MASH_EASING "mask_easing"
#define TEXT_SELECTOR_PROP_MASH_AREA_SCALE "mask_area_scale"
#define TEXT_SELECTOR(widget) ((text_selector_t*)(text_selector_cast(WIDGET(widget))))
/*public for subclass and runtime type check*/
TK_EXTERN_VTABLE(text_selector);
/*public for test*/
ret_t text_selector_parse_options(widget_t* widget, const char* str);
END_C_DECLS
#endif /*TK_TEXT_SELECTOR_H*/
|
0 |
repos/awtk/src/ext_widgets
|
repos/awtk/src/ext_widgets/text_selector/text_selector.c
|
/**
* File: text_selector.h
* Author: AWTK Develop Team
* Brief: text_selector
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-09-25 Li XianJing <[email protected]> created
*
*/
#include "tkc/mem.h"
#include "tkc/utf8.h"
#include "tkc/utils.h"
#include "tkc/easing.h"
#include "widgets/button.h"
#include "base/layout.h"
#include "widgets/popup.h"
#include "base/window.h"
#include "tkc/tokenizer.h"
#include "text_selector/text_selector.h"
#include "base/widget_animator_manager.h"
#include "widget_animators/widget_animator_scroll.h"
#define TEXT_SELECTOR_WA_NAME "text_selector@wa"
static const wchar_t* text_selector_get_wtext(widget_t* widget);
static ret_t text_selector_set_all_options_localize_text(widget_t* widget);
static ret_t text_selector_scroll_to(widget_t* widget, int32_t yoffset_end);
static ret_t text_selector_sync_yoffset_with_selected_index(text_selector_t* text_selector,
bool_t is_anim);
const char* s_text_selector_properties[] = {WIDGET_PROP_TEXT,
WIDGET_PROP_VALUE,
WIDGET_PROP_OPTIONS,
WIDGET_PROP_ELLIPSES,
TEXT_SELECTOR_PROP_VISIBLE_NR,
WIDGET_PROP_SELECTED_INDEX,
WIDGET_PROP_LOCALIZE_OPTIONS,
TEXT_SELECTOR_PROP_Y_SPEED_SCALE,
TEXT_SELECTOR_PROP_LOOP_OPTIONS,
TEXT_SELECTOR_PROP_ANIMATION_TIME,
NULL};
static ret_t text_selector_paint_mask(widget_t* widget, canvas_t* c) {
int32_t i = 0;
int32_t y = 0;
int32_t n = 0;
style_t* style = widget->astyle;
color_t trans = color_init(0, 0, 0, 0);
color_t fc = style_get_color(style, STYLE_ID_FG_COLOR, trans);
const char* fg_image = style_get_str(style, STYLE_ID_FG_IMAGE, NULL);
color_t mask_color = style_get_color(style, STYLE_ID_MASK_COLOR, trans);
text_selector_t* text_selector = TEXT_SELECTOR(widget);
ENSURE(text_selector);
int32_t visible_nr = text_selector->visible_nr;
int32_t item_height = text_selector->draw_widget_h / visible_nr;
easing_func_t easing = easing_get(text_selector->mask_easing);
n = widget->h / 2 * text_selector->mask_area_scale;
if (fc.rgba.a) {
canvas_set_stroke_color(c, fc);
for (i = 1; i < visible_nr; i++) {
y = i * item_height;
canvas_draw_hline(c, 0, y, widget->w);
}
}
if (mask_color.rgba.a) {
for (i = 0; i <= n; i++) {
y = n - i - 1;
mask_color.rgba.a = 0xff * easing((float_t)i / (float_t)n);
canvas_set_stroke_color(c, mask_color);
canvas_draw_hline(c, 0, y, widget->w);
}
for (i = 0; i < n; i++) {
y = widget->h - n + i;
mask_color.rgba.a = 0xff * easing((float_t)i / (float_t)n);
canvas_set_stroke_color(c, mask_color);
canvas_draw_hline(c, 0, y, widget->w);
}
}
if (fg_image != NULL && *fg_image) {
bitmap_t img;
rect_t r = rect_init(0, 0, widget->w, widget->h);
if (widget_load_image(widget, fg_image, &img) == RET_OK) {
image_draw_type_t draw_type =
(image_draw_type_t)style_get_int(style, STYLE_ID_FG_IMAGE_DRAW_TYPE, IMAGE_DRAW_CENTER);
canvas_draw_image_ex(c, &img, draw_type, (const rect_t*)&r);
}
}
return RET_OK;
}
static int32_t text_selector_range_yoffset(int32_t value, int32_t min_yoffset, int32_t max_yoffset,
int32_t item_height, int32_t empty_item_height,
bool_t loop_options) {
if (value < min_yoffset) {
int32_t tmp = max_yoffset + empty_item_height + item_height;
if (loop_options && tmp != 0) {
int32_t n = tk_abs(value / tmp) + 1;
value = value + tmp * n;
} else {
value = min_yoffset;
}
} else if (value > max_yoffset) {
int32_t tmp = max_yoffset + empty_item_height + item_height;
if (loop_options && tmp != 0) {
value = value % tmp;
} else {
value = max_yoffset;
}
}
return value;
}
static ret_t text_selector_prepare_highlight_style(widget_t* widget, canvas_t* c, float_t d,
bool_t set_color) {
style_t* style = widget->astyle;
color_t trans = color_init(0, 0, 0, 0);
color_t tc = style_get_color(style, STYLE_ID_TEXT_COLOR, trans);
color_t hg_tc = style_get_color(style, STYLE_ID_HIGHLIGHT_TEXT_COLOR, trans);
const char* font_name = style_get_str(style, STYLE_ID_FONT_NAME, NULL);
uint16_t font_size = style_get_int(style, STYLE_ID_FONT_SIZE, TK_DEFAULT_FONT_SIZE);
uint16_t hg_font_size = style_get_int(style, STYLE_ID_HIGHLIGHT_FONT_SIZE, font_size);
const char* hg_font_name = style_get_str(style, STYLE_ID_HIGHLIGHT_FONT_NAME, font_name);
uint16_t tmp_font_size = hg_font_size;
if (hg_tc.rgba.a > 0 && set_color) {
canvas_set_text_color(c, hg_tc);
} else {
canvas_set_text_color(c, tc);
}
if (hg_font_size != font_size) {
if (d >= 1.0f) {
tmp_font_size = hg_font_size;
} else {
tmp_font_size = font_size + tk_roundi((hg_font_size - font_size) * d);
}
}
canvas_set_font(c, hg_font_name, tmp_font_size);
return RET_OK;
}
static ret_t text_selector_paint_text(widget_t* widget, canvas_t* c, rect_t* r,
text_selector_option_t* iter, int32_t empty_item_height,
int32_t item_height) {
text_selector_t* text_selector = NULL;
uint32_t d = tk_abs(r->y - empty_item_height);
text_selector = TEXT_SELECTOR(widget);
ENSURE(text_selector);
if (d < item_height) {
text_selector_prepare_highlight_style(widget, c, (item_height - d) / (float_t)item_height,
d < item_height / 2);
} else {
widget_prepare_text_style(widget, c);
}
return widget_draw_text_in_rect(widget, c, iter->text.str, iter->text.size, r,
text_selector->ellipses);
}
static ret_t text_selector_paint_self(widget_t* widget, canvas_t* c) {
rect_t r;
uint32_t y = 0;
text_selector_option_t* iter = NULL;
int32_t max_yoffset, tolal_height;
int32_t yoffset, visible_nr, item_height;
int32_t options_nr, empty_item_height, min_yoffset;
text_selector_t* text_selector = TEXT_SELECTOR(widget);
return_value_if_fail(text_selector != NULL, RET_BAD_PARAMS);
options_nr = text_selector_count_options(widget);
if (options_nr == 0) {
return RET_OK;
}
yoffset = text_selector->yoffset;
visible_nr = text_selector->visible_nr;
item_height = text_selector->draw_widget_h / visible_nr;
r = rect_init(0, 0, widget->w, item_height);
empty_item_height = (text_selector->visible_nr / 2) * item_height;
min_yoffset = -empty_item_height;
max_yoffset = (options_nr * item_height + empty_item_height) - text_selector->draw_widget_h;
tolal_height = max_yoffset + empty_item_height;
widget_prepare_text_style(widget, c);
iter = text_selector->option_items;
yoffset = text_selector_range_yoffset(yoffset, min_yoffset, max_yoffset, item_height,
empty_item_height, text_selector->loop_options);
while (iter != NULL) {
r.y = y - yoffset;
if (text_selector->loop_options) {
if (yoffset <= 0 && r.y > tolal_height) {
/* 当 yoffset <= 0 说明顶部有空位，需要显示，
* r.y 是选项加上 yoffset ，如果 r.y 大于 tolal_height 说明这个选项是加上 yoffset 后偏移出来的尾部。
* 然后把该选项设置到顶部的空位上面。
*/
r.y = r.y - tolal_height - item_height;
} else if (r.y + max_yoffset < empty_item_height) {
/* max_yoffset 为总队列长度，而 r.y 一定为负数，empty_item_height 是做多的剩余空位高度
* 符合该条件的选项，等于是选项加上 yoffset 后大于总队列长度，意味着选项为偏移出来的头部。
* 然后把该选项设置到尾部的空位上面。
*/
r.y = empty_item_height + item_height + r.y + max_yoffset;
}
}
if ((r.y + item_height) >= 0 && r.y < widget->h) {
text_selector_paint_text(widget, c, &r, iter, empty_item_height, item_height);
}
iter = iter->next;
y += item_height;
}
return RET_OK;
}
static ret_t text_selector_on_paint_self(widget_t* widget, canvas_t* c) {
rect_t r_save;
text_selector_t* text_selector = TEXT_SELECTOR(widget);
rect_t r = rect_init(c->ox, c->oy, widget->w, widget->h);
return_value_if_fail(widget != NULL && text_selector != NULL, RET_BAD_PARAMS);
canvas_get_clip_rect(c, &r_save);
r = rect_intersect(&r_save, &r);
if (r.w > 0 && r.h > 0) {
canvas_translate(c, 0, text_selector->draw_widget_y);
canvas_set_clip_rect(c, &r);
text_selector_paint_self(widget, c);
text_selector_paint_mask(widget, c);
canvas_set_clip_rect(c, &r_save);
canvas_untranslate(c, 0, text_selector->draw_widget_y);
}
return RET_OK;
}
static ret_t text_selector_set_real_draw_info(widget_t* widget) {
int32_t tmp_h = 0;
text_selector_t* text_selector = TEXT_SELECTOR(widget);
return_value_if_fail(text_selector != NULL, RET_BAD_PARAMS);
tmp_h = widget->h % text_selector->visible_nr;
if (tmp_h == 0) {
text_selector->draw_widget_y = 0;
text_selector->draw_widget_h = widget->h;
} else {
text_selector->draw_widget_y = tmp_h / 2;
text_selector->draw_widget_h = widget->h - tmp_h;
}
return RET_OK;
}
static ret_t text_selector_on_layout_children(widget_t* widget) {
text_selector_t* text_selector = TEXT_SELECTOR(widget);
return_value_if_fail(text_selector != NULL, RET_BAD_PARAMS);
text_selector_set_real_draw_info(widget);
if (!text_selector->is_init) {
text_selector_sync_yoffset_with_selected_index(text_selector, FALSE);
text_selector->is_init = TRUE;
}
return RET_OK;
}
static ret_t text_selector_on_destroy(widget_t* widget) {
text_selector_t* text_selector = TEXT_SELECTOR(widget);
return_value_if_fail(widget != NULL && text_selector != NULL, RET_BAD_PARAMS);
str_reset(&(text_selector->text));
text_selector_reset_options(widget);
if (text_selector->locale_info_id != TK_INVALID_ID) {
locale_info_off(locale_info(), text_selector->locale_info_id);
}
return RET_OK;
}
ret_t text_selector_parse_options(widget_t* widget, const char* str) {
str_t s;
int32_t i = 0;
tokenizer_t tokenizer;
tokenizer_t* t = &tokenizer;
text_selector_t* text_selector = TEXT_SELECTOR(widget);
return_value_if_fail(widget != NULL && text_selector != NULL, RET_BAD_PARAMS);
return_value_if_fail(str_init(&s, 100) != NULL, RET_OOM);
text_selector->options = tk_strdup(str);
tokenizer_init(t, str, strlen(str), ";");
while (tokenizer_has_more(t)) {
int32_t value = 0;
const char* token = tokenizer_next(t);
if (*token) {
const char* text = strchr(token, ':');
if (text != NULL) {
text++;
value = tk_atoi(token);
} else {
text = token;
value = i;
}
str_set(&s, text);
str_unescape(&s);
text_selector_append_option(widget, value, s.str);
i++;
}
}
str_reset(&s);
tokenizer_deinit(t);
return RET_OK;
}
ret_t text_selector_set_range_options_ex(widget_t* widget, int32_t start, uint32_t nr, int32_t step,
const char* format) {
char text[64];
uint32_t i = 0;
return_value_if_fail(widget != NULL && format != NULL, RET_BAD_PARAMS);
for (i = 0; i < nr; i++) {
int32_t value = start + i * step;
tk_snprintf(text, sizeof(text) - 1, format, value);
text_selector_append_option(widget, value, text);
}
return RET_OK;
}
ret_t text_selector_set_range_options(widget_t* widget, int32_t start, uint32_t nr, int32_t step) {
return text_selector_set_range_options_ex(widget, start, nr, step, "%d");
}
ret_t text_selector_set_options(widget_t* widget, const char* options) {
return_value_if_fail(widget != NULL && options != NULL, RET_BAD_PARAMS);
text_selector_reset_options(widget);
if (strchr(options, ':') == NULL && strchr(options, '-') != NULL) {
str_t s;
int nr = 0;
int end = 0;
int step = 1;
int start = 0;
char format[41];
ret_t ret = RET_FAIL;
memset(format, 0x00, sizeof(format));
nr = tk_sscanf(options, "%d-%d-%40s", &start, &end, format);
if (nr < 3) {
tk_strncpy(format, "%d", sizeof(format) - 1);
} else {
char* f = strchr(format, '-');
if (f != NULL) {
int p = f - format;
step = tk_atoi(f + 1);
memset((void*)f, 0x0, sizeof(format) - p);
}
}
if (str_init(&s, sizeof(format)) != NULL) {
str_set(&s, format);
str_unescape(&s);
ret = text_selector_set_range_options_ex(widget, start, end - start + 1, step, s.str);
str_reset(&s);
}
return ret;
} else {
return text_selector_parse_options(widget, options);
}
}
static ret_t text_selector_get_prop(widget_t* widget, const char* name, value_t* v) {
text_selector_t* text_selector = TEXT_SELECTOR(widget);
return_value_if_fail(widget != NULL && text_selector != NULL, RET_BAD_PARAMS);
if (tk_str_eq(name, WIDGET_PROP_TEXT)) {
value_set_wstr(v, text_selector_get_wtext(widget));
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_VALUE)) {
value_set_int(v, text_selector_get_value(widget));
return RET_OK;
} else if (tk_str_eq(name, TEXT_SELECTOR_PROP_VISIBLE_NR)) {
value_set_int(v, text_selector->visible_nr);
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_SELECTED_INDEX)) {
value_set_int(v, text_selector->selected_index);
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_XOFFSET)) {
value_set_int(v, 0);
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_YOFFSET)) {
value_set_int(v, text_selector->yoffset);
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_OPTIONS)) {
value_set_str(v, text_selector->options);
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_ELLIPSES)) {
value_set_bool(v, text_selector->ellipses);
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_LOCALIZE_OPTIONS)) {
value_set_bool(v, text_selector->localize_options);
return RET_OK;
} else if (tk_str_eq(name, TEXT_SELECTOR_PROP_Y_SPEED_SCALE)) {
value_set_float(v, text_selector->yspeed_scale);
return RET_OK;
} else if (tk_str_eq(name, TEXT_SELECTOR_PROP_LOOP_OPTIONS)) {
value_set_bool(v, text_selector->loop_options);
return RET_OK;
} else if (tk_str_eq(name, TEXT_SELECTOR_PROP_ANIMATION_TIME)) {
value_set_uint32(v, text_selector->animating_time);
return RET_OK;
} else if (tk_str_eq(name, TEXT_SELECTOR_PROP_ENABLE_VALUE_ANIMATOR)) {
value_set_bool(v, text_selector->enable_value_animator);
return RET_OK;
} else if (tk_str_eq(name, TEXT_SELECTOR_PROP_MASH_EASING)) {
value_set_int(v, text_selector->mask_easing);
return RET_OK;
} else if (tk_str_eq(name, TEXT_SELECTOR_PROP_MASH_AREA_SCALE)) {
value_set_float(v, text_selector->mask_area_scale);
return RET_OK;
}
return RET_NOT_FOUND;
}
static ret_t text_selector_set_prop(widget_t* widget, const char* name, const value_t* v) {
text_selector_t* text_selector = TEXT_SELECTOR(widget);
return_value_if_fail(widget != NULL && text_selector != NULL, RET_BAD_PARAMS);
if (tk_str_eq(name, WIDGET_PROP_VALUE)) {
text_selector_set_value(widget, value_int(v));
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_TEXT)) {
text_selector_set_text(widget, value_str(v));
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_ELLIPSES)) {
return text_selector_set_ellipses(widget, value_bool(v));
} else if (tk_str_eq(name, TEXT_SELECTOR_PROP_VISIBLE_NR)) {
text_selector_set_visible_nr(widget, value_int(v));
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_SELECTED_INDEX)) {
text_selector_set_selected_index(widget, value_int(v));
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_YOFFSET)) {
text_selector->yoffset = value_int(v);
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_XOFFSET)) {
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_OPTIONS)) {
text_selector_set_options(widget, value_str(v));
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_LOCALIZE_OPTIONS)) {
return text_selector_set_localize_options(widget, value_bool(v));
} else if (tk_str_eq(name, TEXT_SELECTOR_PROP_Y_SPEED_SCALE)) {
return text_selector_set_yspeed_scale(widget, value_float(v));
} else if (tk_str_eq(name, TEXT_SELECTOR_PROP_LOOP_OPTIONS)) {
return text_selector_set_loop_options(widget, value_bool(v));
} else if (tk_str_eq(name, TEXT_SELECTOR_PROP_ANIMATION_TIME)) {
return text_selector_set_animating_time(widget, value_uint32(v));
} else if (tk_str_eq(name, TEXT_SELECTOR_PROP_ENABLE_VALUE_ANIMATOR)) {
return text_selector_set_enable_value_animator(widget, value_bool(v));
} else if (tk_str_eq(name, TEXT_SELECTOR_PROP_MASH_EASING)) {
return text_selector_set_mask_easing(widget, (easing_type_t)value_int(v));
} else if (tk_str_eq(name, TEXT_SELECTOR_PROP_MASH_AREA_SCALE)) {
return text_selector_set_mask_area_scale(widget, value_float(v));
}
return RET_NOT_FOUND;
}
static ret_t text_selector_on_pointer_down(text_selector_t* text_selector, pointer_event_t* e) {
velocity_t* v = &(text_selector->velocity);
velocity_reset(v);
text_selector->ydown = e->y;
text_selector->yoffset_save = text_selector->yoffset;
velocity_update(v, e->e.time, e->x, e->y);
return RET_OK;
}
static ret_t text_selector_on_pointer_move(text_selector_t* text_selector, pointer_event_t* e) {
velocity_t* v = &(text_selector->velocity);
int32_t dy = e->y - text_selector->ydown;
velocity_update(v, e->e.time, e->x, e->y);
if (text_selector->wa == NULL && dy) {
text_selector->yoffset = text_selector->yoffset_save - dy;
}
return RET_OK;
}
static ret_t text_selector_set_selected_index_only(text_selector_t* text_selector, int32_t index) {
widget_t* widget = WIDGET(text_selector);
return_value_if_fail(widget != NULL && text_selector != NULL, RET_BAD_PARAMS);
if (index != text_selector->selected_index) {
value_change_event_t evt;
text_selector_option_t* option = text_selector_get_option(widget, index);
value_change_event_init(&evt, EVT_VALUE_WILL_CHANGE, widget);
value_set_uint32(&(evt.old_value), text_selector->selected_index);
value_set_uint32(&(evt.new_value), index);
if (widget_dispatch(widget, (event_t*)&evt) != RET_STOP) {
text_selector->last_selected_index = text_selector->selected_index;
text_selector->selected_index = index;
if (widget->tr_text != NULL) {
widget->tr_text = tk_str_copy(widget->tr_text, option->tr_text);
}
evt.e.type = EVT_VALUE_CHANGED;
widget_dispatch(widget, (event_t*)&evt);
widget_invalidate(widget, NULL);
}
}
widget_invalidate(widget, NULL);
return RET_OK;
}
static ret_t text_selector_sync_selected_index_with_yoffset(text_selector_t* text_selector) {
int32_t mid_index = text_selector->visible_nr / 2;
int32_t item_height = text_selector->draw_widget_h / text_selector->visible_nr;
int32_t selected_index = text_selector->yoffset / item_height + mid_index;
if (text_selector->loop_options) {
selected_index = selected_index % text_selector_count_options(WIDGET(text_selector));
}
return text_selector_set_selected_index_only(text_selector, selected_index);
}
static int32_t text_selector_get_yoffset_for_selected_index(text_selector_t* text_selector,
int32_t mid_index,
int32_t item_height) {
int32_t yoffset = 0;
if (text_selector->loop_options) {
int32_t options_nr = text_selector_count_options(WIDGET(text_selector));
float_t middle = (float_t)options_nr / 2.0f;
float_t d_nr = tk_abs((float_t)text_selector->selected_index -
(float_t)text_selector->last_selected_index);
int32_t move_nr = middle - tk_abs(d_nr - middle);
yoffset = text_selector->yoffset;
if ((text_selector->last_selected_index + move_nr) % options_nr ==
text_selector->selected_index) {
yoffset += (move_nr * item_height);
} else {
yoffset -= (move_nr * item_height);
}
} else {
yoffset = (text_selector->selected_index - mid_index) * item_height;
}
return yoffset;
}
static ret_t text_selector_sync_yoffset_with_selected_index(text_selector_t* text_selector,
bool_t is_anim) {
widget_t* widget = WIDGET(text_selector);
int32_t mid_index = text_selector->visible_nr / 2;
int32_t item_height = text_selector->draw_widget_h / text_selector->visible_nr;
if (is_anim && !widget->loading) {
int32_t yoffset =
text_selector_get_yoffset_for_selected_index(text_selector, mid_index, item_height);
if (text_selector->wa != NULL) {
widget_animator_destroy(text_selector->wa);
text_selector->wa = NULL;
}
return text_selector_scroll_to(widget, yoffset);
} else {
text_selector->yoffset = (text_selector->selected_index - mid_index) * item_height;
return widget_invalidate(widget, NULL);
}
}
static ret_t text_selector_on_scroll_done(void* ctx, event_t* e) {
int32_t options_nr = 0;
int32_t item_height = 0;
int32_t min_yoffset = 0;
int32_t max_yoffset = 0;
int32_t empty_item_height = 0;
widget_t* widget = WIDGET(ctx);
text_selector_t* text_selector = TEXT_SELECTOR(ctx);
return_value_if_fail(text_selector != NULL && widget != NULL, RET_BAD_PARAMS);
options_nr = text_selector_count_options(widget);
item_height = text_selector->draw_widget_h / text_selector->visible_nr;
empty_item_height = (text_selector->visible_nr / 2) * item_height;
min_yoffset = -empty_item_height;
max_yoffset = (options_nr * item_height + empty_item_height) - text_selector->draw_widget_h;
text_selector->wa = NULL;
if (text_selector->loop_options) {
text_selector->yoffset =
text_selector_range_yoffset(text_selector->yoffset, min_yoffset, max_yoffset, item_height,
empty_item_height, text_selector->loop_options);
}
text_selector_sync_selected_index_with_yoffset(text_selector);
text_selector->yoffset_save = text_selector->yoffset;
return RET_REMOVE;
}
static ret_t text_selector_scroll_to(widget_t* widget, int32_t yoffset_end) {
int32_t yoffset = 0;
int32_t item_height = 0;
int32_t min_yoffset = 0;
int32_t max_yoffset = 0;
int32_t empty_item_height = 0;
text_selector_t* text_selector = TEXT_SELECTOR(widget);
int32_t options_nr = text_selector_count_options(widget);
return_value_if_fail(text_selector != NULL, RET_BAD_PARAMS);
item_height = text_selector->draw_widget_h / text_selector->visible_nr;
empty_item_height = (text_selector->visible_nr / 2) * item_height;
min_yoffset = -empty_item_height;
max_yoffset = (options_nr * item_height + empty_item_height) - text_selector->draw_widget_h;
if (!text_selector->loop_options) {
if (yoffset_end < min_yoffset) {
yoffset_end = min_yoffset;
}
if (yoffset_end > (max_yoffset)) {
yoffset_end = max_yoffset;
}
}
yoffset_end = tk_roundi((float)yoffset_end / (float)item_height) * item_height;
yoffset = text_selector->yoffset;
if (yoffset == yoffset_end) {
return RET_OK;
}
#ifndef WITHOUT_WIDGET_ANIMATORS
text_selector->wa =
widget_animator_scroll_create(widget, text_selector->animating_time, 0, EASING_SIN_INOUT);
return_value_if_fail(text_selector->wa != NULL, RET_OOM);
widget_animator_set_name(text_selector->wa, TEXT_SELECTOR_WA_NAME);
widget_animator_scroll_set_params(text_selector->wa, 0, yoffset, 0, yoffset_end);
widget_animator_on(text_selector->wa, EVT_ANIM_END, text_selector_on_scroll_done, text_selector);
widget_animator_start(text_selector->wa);
#else
text_selector->yoffset = yoffset_end;
text_selector_on_scroll_done(widget, NULL);
#endif /*WITHOUT_WIDGET_ANIMATORS*/
return RET_OK;
}
static ret_t text_selector_on_pointer_up(text_selector_t* text_selector, pointer_event_t* e) {
int32_t yoffset_end = 0;
widget_t* widget = WIDGET(text_selector);
velocity_t* v = &(text_selector->velocity);
int32_t item_height = text_selector->draw_widget_h / text_selector->visible_nr;
velocity_update(v, e->e.time, e->x, e->y);
yoffset_end = text_selector->yoffset - v->yv * text_selector->yspeed_scale;
if (e->y == text_selector->ydown) {
/*click*/
int32_t mid_index = 0;
int32_t pointer_index = 0;
point_t p = {e->x, e->y};
mid_index = text_selector->visible_nr / 2;
widget_to_local(widget, &p);
pointer_index = (p.y - text_selector->yoffset) / item_height;
if (pointer_index == mid_index) {
return RET_OK;
} else {
yoffset_end = text_selector->yoffset + item_height * (pointer_index - mid_index);
}
}
text_selector_scroll_to(widget, yoffset_end);
return RET_OK;
}
static ret_t text_selector_up(widget_t* widget) {
int32_t yoffset = 0;
text_selector_t* text_selector = TEXT_SELECTOR(widget);
return_value_if_fail(text_selector != NULL, RET_BAD_PARAMS);
yoffset = text_selector->yoffset - (text_selector->draw_widget_h / text_selector->visible_nr);
return text_selector_scroll_to(widget, yoffset);
}
static ret_t text_selector_down(widget_t* widget) {
int32_t yoffset = 0;
text_selector_t* text_selector = TEXT_SELECTOR(widget);
return_value_if_fail(text_selector != NULL, RET_BAD_PARAMS);
yoffset = text_selector->yoffset + (text_selector->draw_widget_h / text_selector->visible_nr);
return text_selector_scroll_to(widget, yoffset);
}
static ret_t text_selector_on_event(widget_t* widget, event_t* e) {
ret_t ret = RET_OK;
uint16_t type = e->type;
text_selector_t* text_selector = TEXT_SELECTOR(widget);
return_value_if_fail(text_selector != NULL && e != NULL, RET_BAD_PARAMS);
switch (type) {
case EVT_POINTER_DOWN:
text_selector->pressed = TRUE;
widget_grab(widget->parent, widget);
text_selector_on_pointer_down(text_selector, (pointer_event_t*)e);
break;
case EVT_POINTER_UP: {
text_selector->pressed = FALSE;
text_selector_on_pointer_up(text_selector, (pointer_event_t*)e);
widget_ungrab(widget->parent, widget);
break;
}
case EVT_POINTER_DOWN_ABORT: {
text_selector->pressed = FALSE;
text_selector->yoffset = text_selector->yoffset_save;
break;
}
case EVT_KEY_DOWN: {
key_event_t* evt = (key_event_t*)e;
if (evt->key == TK_KEY_UP) {
text_selector_up(widget);
} else if (evt->key == TK_KEY_DOWN) {
text_selector_down(widget);
}
break;
}
case EVT_POINTER_MOVE: {
pointer_event_t* evt = (pointer_event_t*)e;
if (evt->pressed && text_selector->pressed) {
text_selector_on_pointer_move(text_selector, evt);
widget_invalidate(widget, NULL);
ret = RET_STOP;
}
break;
}
case EVT_WHEEL: {
wheel_event_t* evt = (wheel_event_t*)e;
if (evt->dy > 0) {
text_selector_down(widget);
} else if (evt->dy < 0) {
text_selector_up(widget);
}
ret = RET_STOP;
}
case EVT_RESIZE:
case EVT_MOVE_RESIZE: {
text_selector_sync_yoffset_with_selected_index(text_selector, FALSE);
break;
}
default:
break;
}
return ret;
}
static ret_t text_selector_on_locale_changed(void* ctx, event_t* e) {
widget_t* widget = WIDGET(ctx);
text_selector_t* text_selector = TEXT_SELECTOR(widget);
return_value_if_fail(text_selector != NULL, RET_BAD_PARAMS);
if (text_selector->localize_options) {
text_selector_set_all_options_localize_text(widget);
}
return RET_OK;
}
static ret_t text_selector_init(widget_t* widget) {
text_selector_t* text_selector = TEXT_SELECTOR(widget);
return_value_if_fail(text_selector != NULL, RET_BAD_PARAMS);
text_selector->visible_nr = 5;
text_selector->pressed = FALSE;
text_selector->is_init = FALSE;
text_selector->yspeed_scale = 1.0f;
text_selector->enable_value_animator = TRUE;
text_selector->locale_info_id = TK_INVALID_ID;
text_selector->animating_time = TK_ANIMATING_TIME;
text_selector->mask_easing = EASING_CUBIC_IN;
text_selector->mask_area_scale = 1;
str_init(&(text_selector->text), 0);
return RET_OK;
}
TK_DECL_VTABLE(text_selector) = {.size = sizeof(text_selector_t),
.inputable = TRUE,
.type = WIDGET_TYPE_TEXT_SELECTOR,
.clone_properties = s_text_selector_properties,
.persistent_properties = s_text_selector_properties,
.get_parent_vt = TK_GET_PARENT_VTABLE(widget),
.create = text_selector_create,
.init = text_selector_init,
.on_paint_self = text_selector_on_paint_self,
.on_layout_children = text_selector_on_layout_children,
.set_prop = text_selector_set_prop,
.get_prop = text_selector_get_prop,
.on_destroy = text_selector_on_destroy,
.on_event = text_selector_on_event};
widget_t* text_selector_create(widget_t* parent, xy_t x, xy_t y, wh_t w, wh_t h) {
widget_t* widget = widget_create(parent, TK_REF_VTABLE(text_selector), x, y, w, h);
return_value_if_fail(text_selector_init(widget) == RET_OK, NULL) return widget;
}
ret_t text_selector_reset_options(widget_t* widget) {
text_selector_option_t* iter = NULL;
text_selector_option_t* next = NULL;
text_selector_t* text_selector = TEXT_SELECTOR(widget);
return_value_if_fail(text_selector != NULL, RET_BAD_PARAMS);
if (text_selector->wa != NULL) {
widget_animator_t* ani =
widget_animator_manager_find(widget_animator_manager(), widget, TEXT_SELECTOR_WA_NAME);
if (ani != NULL && text_selector->wa == ani) {
widget_animator_destroy(text_selector->wa);
}
text_selector->wa = NULL;
}
iter = text_selector->option_items;
while (iter != NULL) {
next = iter->next;
TKMEM_FREE(iter->tr_text);
wstr_reset(&(iter->text));
TKMEM_FREE(iter);
iter = next;
}
text_selector->option_items = NULL;
TKMEM_FREE(text_selector->options);
widget_invalidate(widget, NULL);
return RET_OK;
}
static ret_t text_selector_set_options_localize_text(widget_t* widget,
text_selector_option_t* option) {
const char* tr_text = NULL;
text_selector_t* text_selector = TEXT_SELECTOR(widget);
return_value_if_fail(widget != NULL && text_selector != NULL && option != NULL, RET_BAD_PARAMS);
if (text_selector->localize_options) {
tr_text = locale_info_tr(widget_get_locale_info(widget), option->tr_text);
wstr_set_utf8(&(option->text), tr_text);
} else {
wstr_set_utf8(&(option->text), option->tr_text);
}
return RET_OK;
}
static ret_t text_selector_set_all_options_localize_text(widget_t* widget) {
text_selector_option_t* iter = NULL;
text_selector_t* text_selector = TEXT_SELECTOR(widget);
return_value_if_fail(widget != NULL && text_selector != NULL, RET_BAD_PARAMS);
iter = text_selector->option_items;
while (iter != NULL) {
text_selector_set_options_localize_text(widget, iter);
iter = iter->next;
}
return RET_OK;
}
ret_t text_selector_append_option(widget_t* widget, int32_t value, const char* text) {
int32_t size = 0;
text_selector_option_t* iter = NULL;
text_selector_option_t* option = NULL;
text_selector_t* text_selector = TEXT_SELECTOR(widget);
return_value_if_fail(text_selector != NULL && text != NULL, RET_BAD_PARAMS);
size = sizeof(text_selector_option_t);
option = (text_selector_option_t*)TKMEM_ALLOC(size);
return_value_if_fail(option != NULL, RET_OOM);
memset(option, 0x00, size);
wstr_init(&(option->text), 0);
option->tr_text = tk_str_copy(option->tr_text, text);
option->value = value;
text_selector_set_options_localize_text(widget, option);
if (text_selector->option_items != NULL) {
iter = text_selector->option_items;
while (iter->next != NULL) iter = iter->next;
iter->next = option;
} else {
text_selector->option_items = option;
}
return widget_invalidate(widget, NULL);
}
int32_t text_selector_count_options(widget_t* widget) {
int32_t nr = 0;
text_selector_option_t* iter = NULL;
text_selector_t* text_selector = TEXT_SELECTOR(widget);
return_value_if_fail(text_selector != NULL, nr);
iter = text_selector->option_items;
while (iter != NULL) {
nr++;
iter = iter->next;
}
return nr;
}
int32_t text_selector_get_option_by_value(widget_t* widget, int32_t value) {
uint32_t i = 0;
text_selector_option_t* iter = NULL;
text_selector_t* text_selector = TEXT_SELECTOR(widget);
return_value_if_fail(text_selector != NULL, -1);
iter = text_selector->option_items;
while (iter != NULL) {
if (value == iter->value) {
return i;
}
i++;
iter = iter->next;
}
return -1;
}
int32_t text_selector_get_option_by_text(widget_t* widget, const char* text) {
wstr_t str;
uint32_t i = 0;
text_selector_option_t* iter = NULL;
text_selector_t* text_selector = TEXT_SELECTOR(widget);
return_value_if_fail(text_selector != NULL, -1);
wstr_init(&str, 0);
wstr_set_utf8(&str, text);
iter = text_selector->option_items;
while (iter != NULL) {
if (wcscmp(str.str, iter->text.str) == 0) {
wstr_reset(&str);
return i;
}
i++;
iter = iter->next;
}
wstr_reset(&str);
return -1;
}
text_selector_option_t* text_selector_get_option(widget_t* widget, uint32_t index) {
uint32_t i = 0;
text_selector_option_t* iter = NULL;
text_selector_t* text_selector = TEXT_SELECTOR(widget);
return_value_if_fail(text_selector != NULL, NULL);
iter = text_selector->option_items;
while (iter != NULL) {
if (i == index) {
return iter;
}
i++;
iter = iter->next;
}
return NULL;
}
ret_t text_selector_set_selected_index(widget_t* widget, uint32_t index) {
text_selector_t* text_selector = TEXT_SELECTOR(widget);
text_selector_option_t* option = text_selector_get_option(widget, index);
return_value_if_fail(text_selector != NULL, RET_BAD_PARAMS);
return_value_if_fail(option != NULL, RET_BAD_PARAMS);
if (index != text_selector->selected_index) {
text_selector_set_selected_index_only(text_selector, index);
text_selector_sync_yoffset_with_selected_index(text_selector,
text_selector->enable_value_animator);
}
return widget_invalidate(widget, NULL);
}
ret_t text_selector_set_visible_nr(widget_t* widget, uint32_t visible_nr) {
text_selector_t* text_selector = TEXT_SELECTOR(widget);
return_value_if_fail(text_selector != NULL, RET_BAD_PARAMS);
if (visible_nr > 1) {
text_selector->visible_nr = visible_nr == 3 ? 3 : 5;
} else {
text_selector->visible_nr = 1;
}
text_selector_sync_yoffset_with_selected_index(text_selector, FALSE);
return widget_invalidate(widget, NULL);
}
int32_t text_selector_get_value(widget_t* widget) {
text_selector_option_t* option = NULL;
text_selector_t* text_selector = TEXT_SELECTOR(widget);
return_value_if_fail(text_selector != NULL, -1);
option = text_selector_get_option(widget, text_selector->selected_index);
return option != NULL ? option->value : -1;
}
ret_t text_selector_set_value(widget_t* widget, int32_t value) {
int32_t index = text_selector_get_option_by_value(widget, value);
text_selector_t* text_selector = TEXT_SELECTOR(widget);
return_value_if_fail(text_selector != NULL && index >= 0, RET_BAD_PARAMS);
return text_selector_set_selected_index(widget, index);
}
static const wchar_t* text_selector_get_wtext(widget_t* widget) {
text_selector_option_t* option = NULL;
text_selector_t* text_selector = TEXT_SELECTOR(widget);
return_value_if_fail(text_selector != NULL, NULL);
option = text_selector_get_option(widget, text_selector->selected_index);
return option != NULL ? option->text.str : NULL;
}
const char* text_selector_get_text(widget_t* widget) {
text_selector_t* text_selector = TEXT_SELECTOR(widget);
return_value_if_fail(text_selector != NULL, NULL);
str_from_wstr(&(text_selector->text), text_selector_get_wtext(widget));
return text_selector->text.str;
}
ret_t text_selector_set_text(widget_t* widget, const char* text) {
int32_t index = text_selector_get_option_by_text(widget, text);
text_selector_t* text_selector = TEXT_SELECTOR(widget);
return_value_if_fail(text_selector != NULL && index >= 0, RET_BAD_PARAMS);
return text_selector_set_selected_index(widget, index);
}
ret_t text_selector_set_loop_options(widget_t* widget, bool_t loop_options) {
text_selector_t* text_selector = TEXT_SELECTOR(widget);
return_value_if_fail(text_selector != NULL, RET_BAD_PARAMS);
text_selector->loop_options = loop_options;
return RET_OK;
}
ret_t text_selector_set_localize_options(widget_t* widget, bool_t localize_options) {
text_selector_t* text_selector = TEXT_SELECTOR(widget);
return_value_if_fail(text_selector != NULL, RET_BAD_PARAMS);
text_selector->localize_options = localize_options;
if (text_selector->localize_options) {
text_selector->locale_info_id =
locale_info_on(locale_info(), EVT_LOCALE_CHANGED, text_selector_on_locale_changed, widget);
} else {
if (text_selector->locale_info_id != TK_INVALID_ID) {
locale_info_off(locale_info(), text_selector->locale_info_id);
}
}
return text_selector_set_all_options_localize_text(widget);
}
ret_t text_selector_set_yspeed_scale(widget_t* widget, float_t yspeed_scale) {
text_selector_t* text_selector = TEXT_SELECTOR(widget);
return_value_if_fail(text_selector != NULL, RET_BAD_PARAMS);
text_selector->yspeed_scale = yspeed_scale;
return RET_OK;
}
ret_t text_selector_set_animating_time(widget_t* widget, uint32_t animating_time) {
text_selector_t* text_selector = TEXT_SELECTOR(widget);
return_value_if_fail(text_selector != NULL, RET_BAD_PARAMS);
text_selector->animating_time = animating_time;
return RET_OK;
}
ret_t text_selector_set_enable_value_animator(widget_t* widget, bool_t enable_value_animator) {
text_selector_t* text_selector = TEXT_SELECTOR(widget);
return_value_if_fail(text_selector != NULL, RET_BAD_PARAMS);
text_selector->enable_value_animator = enable_value_animator;
return RET_OK;
}
ret_t text_selector_set_mask_easing(widget_t* widget, easing_type_t mask_easing) {
text_selector_t* text_selector = TEXT_SELECTOR(widget);
return_value_if_fail(text_selector != NULL, RET_BAD_PARAMS);
text_selector->mask_easing = mask_easing;
return RET_OK;
}
ret_t text_selector_set_mask_area_scale(widget_t* widget, float_t mask_area_scale) {
text_selector_t* text_selector = TEXT_SELECTOR(widget);
return_value_if_fail(text_selector != NULL, RET_BAD_PARAMS);
text_selector->mask_area_scale = mask_area_scale;
return RET_OK;
}
widget_t* text_selector_cast(widget_t* widget) {
return_value_if_fail(WIDGET_IS_INSTANCE_OF(widget, text_selector), NULL);
return widget;
}
ret_t text_selector_set_ellipses(widget_t* widget, bool_t ellipses) {
text_selector_t* text_selector = TEXT_SELECTOR(widget);
return_value_if_fail(text_selector != NULL, RET_BAD_PARAMS);
text_selector->ellipses = ellipses;
return widget_invalidate(widget, NULL);
}
|
0 |
repos/awtk/src/ext_widgets
|
repos/awtk/src/ext_widgets/switch/switch.c
|
/**
* File: switch.c
* Author: AWTK Develop Team
* Brief: switch
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-09-26 Li XianJing <[email protected]> created
*
*/
#include "tkc/mem.h"
#include "switch/switch.h"
#include "base/image_manager.h"
#include "base/widget_vtable.h"
#include "widget_animators/widget_animator_scroll.h"
#define ANIMATING_TIME 300
static ret_t switch_on_pointer_down(switch_t* aswitch, pointer_event_t* e) {
velocity_t* v = &(aswitch->velocity);
velocity_reset(v);
aswitch->xdown = e->x;
aswitch->xoffset_save = aswitch->xoffset;
velocity_update(v, e->e.time, e->x, e->y);
return RET_OK;
}
static ret_t switch_on_pointer_move(switch_t* aswitch, pointer_event_t* e) {
velocity_t* v = &(aswitch->velocity);
widget_t* widget = WIDGET(aswitch);
int32_t dx = e->x - aswitch->xdown;
int32_t max_xoffset = aswitch->max_xoffset_ratio * widget->w;
velocity_update(v, e->e.time, e->x, e->y);
if (aswitch->wa == NULL && dx) {
aswitch->xoffset = aswitch->xoffset_save - dx;
}
aswitch->xoffset = tk_max(0, aswitch->xoffset);
aswitch->xoffset = tk_min(aswitch->xoffset, max_xoffset);
return RET_OK;
}
static ret_t switch_on_scroll_done(void* ctx, event_t* e) {
widget_t* widget = WIDGET(ctx);
switch_t* aswitch = SWITCH(ctx);
return_value_if_fail(widget != NULL && aswitch != NULL, RET_BAD_PARAMS);
aswitch->wa = NULL;
switch_set_value(widget, aswitch->xoffset == 0);
return RET_REMOVE;
}
static ret_t switch_scroll_to(widget_t* widget, int32_t xoffset_end) {
int32_t xoffset = 0;
switch_t* aswitch = SWITCH(widget);
return_value_if_fail(aswitch != NULL, RET_FAIL);
xoffset = aswitch->xoffset;
if (xoffset == xoffset_end) {
switch_set_value(widget, aswitch->xoffset == 0);
return RET_OK;
}
#ifndef WITHOUT_WIDGET_ANIMATORS
aswitch->wa = widget_animator_scroll_create(widget, ANIMATING_TIME, 0, EASING_SIN_INOUT);
return_value_if_fail(aswitch->wa != NULL, RET_OOM);
widget_animator_scroll_set_params(aswitch->wa, xoffset, 0, xoffset_end, 0);
widget_animator_on(aswitch->wa, EVT_ANIM_END, switch_on_scroll_done, aswitch);
widget_animator_start(aswitch->wa);
#else
aswitch->xoffset = xoffset_end;
switch_on_scroll_done(widget, NULL);
#endif /*WITHOUT_WIDGET_ANIMATORS*/
return RET_OK;
}
static ret_t switch_on_pointer_up(switch_t* aswitch, pointer_event_t* e) {
ret_t ret = RET_OK;
velocity_t* v = NULL;
int32_t xoffset_end = 0;
int32_t min_xoffset = 0;
int32_t max_xoffset = 0;
widget_t* widget = WIDGET(aswitch);
return_value_if_fail(widget != NULL && aswitch != NULL, RET_BAD_PARAMS);
v = &(aswitch->velocity);
max_xoffset = aswitch->max_xoffset_ratio * widget->w;
velocity_update(v, e->e.time, e->x, e->y);
xoffset_end = aswitch->xoffset - v->xv;
if (e->x == aswitch->xdown) {
/*click*/
pointer_event_t click;
ret = widget_dispatch(widget, pointer_event_init(&click, EVT_CLICK, widget, e->x, e->y));
} else {
if (xoffset_end < max_xoffset / 2) {
xoffset_end = min_xoffset;
} else {
xoffset_end = max_xoffset;
}
switch_scroll_to(widget, xoffset_end);
}
return ret;
}
static ret_t switch_on_event(widget_t* widget, event_t* e) {
uint16_t type = e->type;
switch_t* aswitch = SWITCH(widget);
ret_t ret = RET_OK;
return_value_if_fail(widget != NULL && aswitch != NULL, RET_BAD_PARAMS);
switch (type) {
case EVT_POINTER_DOWN: {
aswitch->pressed = TRUE;
aswitch->point_down_aborted = FALSE;
widget_grab(widget->parent, widget);
switch_on_pointer_down(aswitch, (pointer_event_t*)e);
break;
}
case EVT_POINTER_DOWN_ABORT: {
if (aswitch->pressed) {
aswitch->pressed = FALSE;
aswitch->point_down_aborted = TRUE;
aswitch->xoffset = aswitch->xoffset_save;
widget_ungrab(widget->parent, widget);
}
break;
}
case EVT_POINTER_UP: {
aswitch->pressed = FALSE;
if (!aswitch->point_down_aborted) {
pointer_event_t* evt = (pointer_event_t*)e;
switch_on_pointer_move(aswitch, evt);
ret = switch_on_pointer_up(aswitch, evt);
widget_ungrab(widget->parent, widget);
} else {
aswitch->xoffset = aswitch->xoffset_save;
}
break;
}
case EVT_CLICK: {
int max_xoffset = aswitch->max_xoffset_ratio * widget->w;
switch_scroll_to(widget, aswitch->value ? max_xoffset : 0);
break;
}
case EVT_POINTER_MOVE: {
pointer_event_t* evt = (pointer_event_t*)e;
if (aswitch->pressed && !aswitch->point_down_aborted) {
switch_on_pointer_move(aswitch, evt);
widget_invalidate(widget, NULL);
ret = RET_STOP;
}
break;
}
case EVT_RESIZE:
case EVT_MOVE_RESIZE: {
if (aswitch->value) {
aswitch->xoffset = 0;
} else {
aswitch->xoffset = aswitch->max_xoffset_ratio * widget->w;
}
break;
}
default:
break;
}
return ret;
}
ret_t switch_fill_rect_color(widget_t* widget, canvas_t* c, rect_t* r, bool_t bg) {
style_t* style = widget->astyle;
switch_t* aswitch = SWITCH(widget);
ENSURE(aswitch);
color_t trans = color_init(0, 0, 0, 0);
uint32_t radius = style_get_int(style, STYLE_ID_ROUND_RADIUS, 0);
const char* color_key = bg ? (aswitch->value ? STYLE_ID_SELECTED_BG_COLOR : STYLE_ID_BG_COLOR)
: (aswitch->value ? STYLE_ID_SELECTED_FG_COLOR : STYLE_ID_FG_COLOR);
color_t color = style_get_color(style, color_key, trans);
if (color.rgba.a == 0 && aswitch->value) {
color_key = bg ? STYLE_ID_BG_COLOR : STYLE_ID_FG_COLOR;
color = style_get_color(style, color_key, trans);
}
if (color.rgba.a && r->w > 0 && r->h > 0) {
canvas_set_fill_color(c, color);
if (radius > 3) {
vgcanvas_t* vg = canvas_get_vgcanvas(c);
if (vg != NULL) {
xy_t x = r->x + 0.5;
xy_t y = r->y + 0.5;
vgcanvas_set_fill_color(vg, color);
vgcanvas_translate(vg, c->ox, c->oy);
vgcanvas_rounded_rect(vg, x, y, r->w, r->h, radius);
vgcanvas_translate(vg, -c->ox, -c->oy);
vgcanvas_fill(vg);
} else {
canvas_fill_rect(c, r->x, r->y, r->w, r->h);
}
} else {
canvas_fill_rect(c, r->x, r->y, r->w, r->h);
}
}
return RET_OK;
}
static ret_t switch_on_paint_background_img(widget_t* widget, canvas_t* c, bitmap_t* img) {
float_t fw = 0;
int32_t iw = 0;
int32_t ih = 0;
float_t wscale = 0;
float_t hscale = 0;
int32_t xoffset = 0;
int32_t round_radius = 0;
vgcanvas_t* vg = canvas_get_vgcanvas(c);
switch_t* aswitch = SWITCH(widget);
return_value_if_fail(img != NULL && widget != NULL && aswitch != NULL && vg != NULL,
RET_BAD_PARAMS);
iw = img->w;
ih = img->h;
wscale = (float_t)(widget->w) / (float_t)iw;
hscale = (float_t)(widget->h) / (float_t)ih;
xoffset = (float_t)(aswitch->xoffset) / wscale;
round_radius = style_get_int(widget->astyle, STYLE_ID_ROUND_RADIUS, 0) / hscale;
fw = iw * (1.0f - aswitch->max_xoffset_ratio);
wscale = (float_t)(widget->w) / fw;
if (vg == NULL || (round_radius < 5 && tk_abs(wscale - 1) <= 0.000001f)) {
int32_t x = (widget->w - (int32_t)fw) >> 1;
int32_t y = (widget->h - ih) >> 1;
rect_t src = rect_init(xoffset, 0, (int32_t)fw, ih);
rect_t dst = rect_init(x, y, (int32_t)fw, ih);
dst.y = tk_max(0, y);
dst.h = tk_min(dst.h, widget->h);
return canvas_draw_image(c, img, &src, &dst);
}
if (vg != NULL) {
vgcanvas_save(vg);
vgcanvas_translate(vg, c->ox, c->oy);
vgcanvas_scale(vg, wscale, hscale);
vgcanvas_translate(vg, -xoffset, 0);
vgcanvas_rounded_rect(vg, xoffset, 0, fw, ih, round_radius);
vgcanvas_paint(vg, FALSE, img);
vgcanvas_restore(vg);
}
return RET_OK;
}
static ret_t switch_on_paint_background(widget_t* widget, canvas_t* c) {
style_t* style = NULL;
const char* image_name = NULL;
switch_t* aswitch = SWITCH(widget);
return_value_if_fail(aswitch != NULL && widget->astyle != NULL, RET_BAD_PARAMS);
style = widget->astyle;
image_name = style_get_str(style, STYLE_ID_BG_IMAGE, NULL);
if (image_name != NULL && *image_name) {
bitmap_t img;
if (widget_load_image(widget, image_name, &img) == RET_OK) {
return switch_on_paint_background_img(widget, c, &img);
}
} else {
int32_t w = widget->w; //tk_roundi(widget->w * 1.5 * (1 - aswitch->max_xoffset_ratio));
rect_t r = rect_init((widget->w - w) / 2.0f, 0, w, widget->h);
return switch_fill_rect_color(widget, c, &r, TRUE);
}
return RET_FAIL;
}
static ret_t switch_on_paint_self(widget_t* widget, canvas_t* c) {
float_t xoffset, xoffset_ratio;
int32_t max_xoffset;
int32_t bar_size;
int32_t w;
rect_t r = rect_init(0, 0, 0, 0);
int32_t margin = 0;
int32_t margin_left = 0;
int32_t margin_right = 0;
int32_t margin_top = 0;
int32_t margin_bottom = 0;
style_t* style = NULL;
const char* image_name = NULL;
const char* image_key = NULL;
switch_t* aswitch = SWITCH(widget);
return_value_if_fail(aswitch != NULL && widget->astyle != NULL, RET_BAD_PARAMS);
style = widget->astyle;
image_key = STYLE_ID_FG_IMAGE;
image_name = style_get_str(style, image_key, NULL);
margin = style_get_int(style, STYLE_ID_MARGIN, 0);
margin_top = style_get_int(style, STYLE_ID_MARGIN_TOP, margin);
margin_left = style_get_int(style, STYLE_ID_MARGIN_LEFT, margin);
margin_right = style_get_int(style, STYLE_ID_MARGIN_RIGHT, margin);
margin_bottom = style_get_int(style, STYLE_ID_MARGIN_BOTTOM, margin);
w = tk_roundi(widget->w * 1.5 * (1 - aswitch->max_xoffset_ratio));
bar_size = tk_roundi(w / 2);
max_xoffset = aswitch->max_xoffset_ratio * widget->w;
xoffset_ratio = (float_t)(w - bar_size) / max_xoffset;
xoffset = (float_t)(aswitch->xoffset) * xoffset_ratio;
r.x = widget->w / 2.0 - xoffset + margin_left;
r.y = margin_top;
r.w = bar_size - margin_left - margin_right;
r.h = widget->h - margin_top - margin_bottom;
if (image_name == NULL || *image_name == 0) {
switch_fill_rect_color(widget, c, &r, FALSE);
} else {
bitmap_t img;
if (widget_load_image(widget, image_name, &img) == RET_OK) {
image_draw_type_t draw_type =
(image_draw_type_t)style_get_int(style, STYLE_ID_FG_IMAGE_DRAW_TYPE, IMAGE_DRAW_CENTER);
canvas_draw_image_ex(c, &img, draw_type, &r);
}
}
return RET_OK;
}
ret_t switch_set_value(widget_t* widget, bool_t value) {
switch_t* aswitch = SWITCH(widget);
return_value_if_fail(aswitch != NULL, RET_BAD_PARAMS);
if (aswitch->value != value) {
value_change_event_t evt;
value_change_event_init(&evt, EVT_VALUE_WILL_CHANGE, widget);
value_set_bool(&(evt.old_value), aswitch->value);
value_set_bool(&(evt.new_value), value);
if (widget_dispatch(widget, (event_t*)&evt) != RET_STOP) {
aswitch->value = value;
evt.e.type = EVT_VALUE_CHANGED;
widget_dispatch(widget, (event_t*)&evt);
widget_invalidate(widget, NULL);
}
}
if (aswitch->value) {
aswitch->xoffset = 0;
} else {
aswitch->xoffset = aswitch->max_xoffset_ratio * widget->w;
}
widget_invalidate(widget, NULL);
return RET_OK;
}
static ret_t switch_get_prop(widget_t* widget, const char* name, value_t* v) {
switch_t* aswitch = SWITCH(widget);
return_value_if_fail(aswitch != NULL && name != NULL && v != NULL, RET_BAD_PARAMS);
if (tk_str_eq(name, WIDGET_PROP_VALUE)) {
value_set_bool(v, aswitch->value);
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_YOFFSET)) {
value_set_int(v, 0);
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_XOFFSET)) {
value_set_int(v, aswitch->xoffset);
return RET_OK;
} else if (tk_str_eq(name, SWITCH_PROP_MAX_XOFFSET_RATIO)) {
value_set_float(v, aswitch->max_xoffset_ratio);
return RET_OK;
}
return RET_NOT_FOUND;
}
static ret_t switch_set_prop(widget_t* widget, const char* name, const value_t* v) {
switch_t* aswitch = SWITCH(widget);
return_value_if_fail(aswitch != NULL && name != NULL && v != NULL, RET_BAD_PARAMS);
if (tk_str_eq(name, WIDGET_PROP_VALUE)) {
return switch_set_value(widget, value_bool(v));
} else if (tk_str_eq(name, WIDGET_PROP_XOFFSET)) {
aswitch->xoffset = value_int(v);
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_YOFFSET)) {
return RET_OK;
} else if (tk_str_eq(name, SWITCH_PROP_MAX_XOFFSET_RATIO)) {
aswitch->max_xoffset_ratio = value_float(v);
if (aswitch->value) {
aswitch->xoffset = 0;
} else {
aswitch->xoffset = aswitch->max_xoffset_ratio * widget->w;
}
return RET_OK;
}
return RET_NOT_FOUND;
}
static ret_t switch_init(widget_t* widget) {
switch_t* aswitch = SWITCH(widget);
return_value_if_fail(aswitch != NULL, RET_BAD_PARAMS);
aswitch->value = TRUE;
aswitch->pressed = FALSE;
aswitch->max_xoffset_ratio = 1.0f / 3.0f;
return RET_OK;
}
static const char* s_switch_properties[] = {WIDGET_PROP_VALUE, WIDGET_PROP_XOFFSET,
SWITCH_PROP_MAX_XOFFSET_RATIO, NULL};
TK_DECL_VTABLE(switch) = {
.inputable = TRUE,
.size = sizeof(switch_t),
.type = WIDGET_TYPE_SWITCH,
.space_key_to_activate = TRUE,
.return_key_to_activate = TRUE,
.clone_properties = s_switch_properties,
.persistent_properties = s_switch_properties,
.get_parent_vt = TK_GET_PARENT_VTABLE(widget),
.create = switch_create,
.init = switch_init,
.on_event = switch_on_event,
.on_paint_background = switch_on_paint_background,
.on_paint_self = switch_on_paint_self,
.get_prop = switch_get_prop,
.set_prop = switch_set_prop,
};
widget_t* switch_create(widget_t* parent, xy_t x, xy_t y, wh_t w, wh_t h) {
widget_t* widget = widget_create(parent, TK_REF_VTABLE(switch), x, y, w, h);
return_value_if_fail(switch_init(widget) == RET_OK, NULL);
return widget;
}
widget_t* switch_cast(widget_t* widget) {
return_value_if_fail(WIDGET_IS_INSTANCE_OF(widget, switch), NULL);
return widget;
}
|
0 |
repos/awtk/src/ext_widgets
|
repos/awtk/src/ext_widgets/switch/switch.h
|
/**
* File: switch.h
* Author: AWTK Develop Team
* Brief: switch
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-09-26 Li XianJing <[email protected]> created
*
*/
#ifndef TK_SWITCH_H
#define TK_SWITCH_H
#include "base/widget.h"
#include "base/velocity.h"
#include "base/widget_animator.h"
BEGIN_C_DECLS
/**
* @class switch_t
* @parent widget_t
* @annotation ["scriptable","design","widget"]
* 开关控件。
*
* switch\_t是[widget\_t](widget_t.md)的子类控件，widget\_t的函数均适用于switch\_t控件。
*
* 在xml中使用"switch"标签创建开关控件。如：
*
* ```xml
* <switch x="10" y="60" w="60" h="22" />
* ```
*
* > 更多用法请参考：[switch.xml](
* https://github.com/zlgopen/awtk/blob/master/design/default/ui/switch.xml)
*
* 在c代码中使用函数switch\_create创建开关控件。如：
*
* ```c
* widget_t* sw = switch_create(win, 10, 10, 80, 30);
* widget_on(sw, EVT_VALUE_CHANGED, on_changed, NULL);
* ```
*
* > 完整示例请参考：[switch demo](
* https://github.com/zlgopen/awtk-c-demos/blob/master/demos/switch.c)
*
* 可用通过style来设置控件的显示风格，如背景图片等。如：
*
* ```xml
* <style name="default">
* <normal bg_image="switch" />
* </style>
* ```
*
* > 更多用法请参考：[theme default](
* https://github.com/zlgopen/awtk/blob/master/design/default/styles/default.xml#L452)
*
*/
typedef struct _switch_t {
widget_t widget;
/**
* @property {bool_t} value
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 值。
*/
bool_t value;
/**
* @property {float_t} max_xoffset_ratio
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 当开关处于关闭时，图片偏移相对于图片宽度的比例(缺省为1/3)。
*/
float_t max_xoffset_ratio;
/*private*/
int32_t xdown;
int32_t xoffset;
int32_t xoffset_save;
velocity_t velocity;
widget_animator_t* wa;
bool_t point_down_aborted;
bool_t pressed;
} switch_t;
/**
* @event {pointer_event_t} EVT_CLICK
* 点击事件。
*/
/**
* @event {value_change_event_t} EVT_VALUE_WILL_CHANGE
* 值(开关状态)即将改变事件。
*/
/**
* @event {value_change_event_t} EVT_VALUE_CHANGED
* 值(开关状态)改变事件。
*/
/**
* @method switch_create
* 创建switch对象
* @annotation ["constructor", "scriptable"]
* @param {widget_t*} parent 父控件
* @param {xy_t} x x坐标
* @param {xy_t} y y坐标
* @param {wh_t} w 宽度
* @param {wh_t} h 高度
*
* @return {widget_t*} 对象。
*/
widget_t* switch_create(widget_t* parent, xy_t x, xy_t y, wh_t w, wh_t h);
/**
* @method switch_set_value
* 设置控件的值。
* @annotation ["scriptable"]
* @param {widget_t*} widget switch对象。
* @param {bool_t} value 值
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t switch_set_value(widget_t* widget, bool_t value);
/**
* @method switch_cast
* 转换switch对象(供脚本语言使用)。
* @annotation ["cast", "scriptable"]
* @param {widget_t*} widget switch对象。
*
* @return {widget_t*} switch对象。
*/
widget_t* switch_cast(widget_t* widget);
#define SWITCH_PROP_MAX_XOFFSET_RATIO "max_xoffset_ratio"
#define WIDGET_TYPE_SWITCH "switch"
#define SWITCH(widget) ((switch_t*)(switch_cast(WIDGET(widget))))
/*public for subclass and runtime type check*/
TK_EXTERN_VTABLE(switch);
END_C_DECLS
#endif /*TK_SWITCH_H*/
|
0 |
repos/awtk/src/ext_widgets
|
repos/awtk/src/ext_widgets/vpage/vpage.c
|
/**
* File: vpage.c
* Author: AWTK Develop Team
* Brief: 虚拟页面(根据情况自动加载/卸载页面)。
*
* Copyright (c) 2021 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2021-06-09 Li XianJing <[email protected]> created
*
*/
#include "tkc/mem.h"
#include "tkc/utils.h"
#include "base/ui_loader.h"
#include "base/window_manager.h"
#include "ui_loader/ui_serializer.h"
#include "widget_animators/widget_animator_prop.h"
#include "vpage.h"
#define PROP_VPAGE_ANIMATOR "vpage_animator"
static ret_t vpage_on_leave_animation_done(void* ctx, event_t* e);
ret_t vpage_set_ui_asset(widget_t* widget, const char* ui_asset) {
vpage_t* vpage = VPAGE(widget);
return_value_if_fail(vpage != NULL, RET_BAD_PARAMS);
vpage->ui_asset = tk_str_copy(vpage->ui_asset, ui_asset);
return RET_OK;
}
ret_t vpage_set_anim_hint(widget_t* widget, const char* anim_hint) {
vpage_t* vpage = VPAGE(widget);
return_value_if_fail(vpage != NULL, RET_BAD_PARAMS);
vpage->anim_hint = tk_str_copy(vpage->anim_hint, anim_hint);
return RET_OK;
}
static ret_t vpage_get_prop(widget_t* widget, const char* name, value_t* v) {
vpage_t* vpage = VPAGE(widget);
return_value_if_fail(vpage != NULL && name != NULL && v != NULL, RET_BAD_PARAMS);
if (tk_str_eq(VPAGE_PROP_UI_ASSET, name)) {
value_set_str(v, vpage->ui_asset);
return RET_OK;
} else if (tk_str_eq(WIDGET_PROP_ANIM_HINT, name)) {
value_set_str(v, vpage->anim_hint);
return RET_OK;
}
return RET_NOT_FOUND;
}
static ret_t vpage_set_prop(widget_t* widget, const char* name, const value_t* v) {
return_value_if_fail(widget != NULL && name != NULL && v != NULL, RET_BAD_PARAMS);
if (tk_str_eq(VPAGE_PROP_UI_ASSET, name)) {
vpage_set_ui_asset(widget, value_str(v));
return RET_OK;
} else if (tk_str_eq(WIDGET_PROP_ANIM_HINT, name)) {
vpage_set_anim_hint(widget, value_str(v));
return RET_OK;
}
return RET_NOT_FOUND;
}
static ret_t vpage_on_destroy(widget_t* widget) {
vpage_t* vpage = VPAGE(widget);
return_value_if_fail(widget != NULL && vpage != NULL, RET_BAD_PARAMS);
TKMEM_FREE(vpage->ui_asset);
TKMEM_FREE(vpage->anim_hint);
return RET_OK;
}
static ret_t vpage_dispatch_event(widget_t* widget, int32_t etype) {
event_t e = event_init(etype, widget);
return widget_dispatch_async(widget, &e);
}
static ret_t vpage_on_enter_done(widget_t* widget) {
vpage_dispatch_event(widget, EVT_VPAGE_OPEN);
return RET_OK;
}
static ret_t vpage_on_enter_animation_done(void* ctx, event_t* e) {
widget_t* widget = WIDGET(ctx);
widget_set_prop_pointer(widget, PROP_VPAGE_ANIMATOR, NULL);
return vpage_on_enter_done(widget);
}
static ret_t vpage_on_enter(widget_t* widget, uint32_t index, uint32_t old_index) {
uint32_t nr = 0;
bool_t can_animate = 0;
vpage_t* vpage = VPAGE(widget);
widget_animator_t* am = NULL;
return_value_if_fail(vpage != NULL, RET_BAD_PARAMS);
nr = widget_count_children(widget->parent);
can_animate = old_index < nr && widget_is_window_opened(widget);
if (vpage->anim_hint != NULL && can_animate) {
if (tk_str_eq(vpage->anim_hint, "htranslate")) {
am = widget_animator_prop_create(widget, TK_ANIMATING_TIME, 0, EASING_SIN_INOUT, "x");
if (old_index < index) {
widget_animator_prop_set_params(am, widget->w, 0);
} else {
widget_animator_prop_set_params(am, -widget->w, 0);
}
} else {
am = widget_animator_prop_create(widget, TK_ANIMATING_TIME, 0, EASING_SIN_INOUT, "y");
if (old_index < index) {
widget_animator_prop_set_params(am, widget->h, 0);
} else {
widget_animator_prop_set_params(am, -widget->h, 0);
}
}
if (am != NULL) {
widget_animator_t* am_old =
(widget_animator_t*)widget_get_prop_pointer(widget, PROP_VPAGE_ANIMATOR);
if (am_old) {
widget_animator_destroy(am_old);
vpage_on_leave_animation_done(widget, NULL);
}
widget_set_prop_pointer(widget, PROP_VPAGE_ANIMATOR, (void*)am);
widget_animator_on(am, EVT_ANIM_END, vpage_on_enter_animation_done, widget);
}
}
if (vpage->ui_asset != NULL) {
widget_t* children = ui_loader_load_widget_with_parent(vpage->ui_asset, widget);
event_t will_open = event_init(EVT_WINDOW_WILL_OPEN, children);
if (children == NULL) {
if (am != NULL) {
widget_animator_destroy(am);
}
return RET_FAIL;
}
widget_layout(children);
/*some widget depends on will open to initialize*/
widget_dispatch_recursive(children, &will_open);
}
widget_set_visible(widget, TRUE);
vpage_dispatch_event(widget, EVT_VPAGE_WILL_OPEN);
window_manager_set_ignore_input_events(window_manager(), FALSE);
if (am != NULL) {
widget_animator_start(am);
} else {
vpage_on_enter_done(widget);
}
return RET_OK;
}
static ret_t vpage_on_leave_done(widget_t* widget) {
vpage_t* vpage = VPAGE(widget);
ENSURE(vpage);
if (vpage->ui_asset != NULL) {
vpage_dispatch_event(widget, EVT_VPAGE_CLOSE);
widget_destroy_children(widget);
}
widget_set_visible(widget, FALSE);
window_manager_set_ignore_input_events(window_manager(), FALSE);
return RET_OK;
}
static ret_t vpage_on_leave_animation_done(void* ctx, event_t* e) {
widget_t* widget = WIDGET(ctx);
widget_set_prop_pointer(widget, PROP_VPAGE_ANIMATOR, NULL);
return vpage_on_leave_done(widget);
}
static ret_t vpage_on_leave(widget_t* widget, uint32_t index, uint32_t new_index) {
vpage_t* vpage = VPAGE(widget);
return_value_if_fail(vpage != NULL, RET_BAD_PARAMS);
if (vpage->anim_hint != NULL) {
widget_animator_t* am = NULL;
if (tk_str_eq(vpage->anim_hint, "htranslate")) {
am = widget_animator_prop_create(widget, TK_ANIMATING_TIME, 0, EASING_SIN_INOUT, "x");
if (new_index < index) {
widget_animator_prop_set_params(am, 0, widget->w);
} else {
widget_animator_prop_set_params(am, 0, -widget->w);
}
} else {
am = widget_animator_prop_create(widget, TK_ANIMATING_TIME, 0, EASING_SIN_INOUT, "y");
if (new_index < index) {
widget_animator_prop_set_params(am, 0, widget->h);
} else {
widget_animator_prop_set_params(am, 0, -widget->h);
}
}
if (am != NULL) {
widget_animator_t* am_old =
(widget_animator_t*)widget_get_prop_pointer(widget, PROP_VPAGE_ANIMATOR);
if (am_old) {
widget_animator_destroy(am_old);
vpage_on_enter_animation_done(widget, NULL);
}
widget_set_visible(widget, TRUE);
window_manager_set_ignore_input_events(window_manager(), TRUE);
widget_set_prop_pointer(widget, PROP_VPAGE_ANIMATOR, (void*)am);
widget_animator_on(am, EVT_ANIM_END, vpage_on_leave_animation_done, widget);
widget_animator_start(am);
} else {
vpage_on_leave_done(widget);
}
} else {
vpage_on_leave_done(widget);
}
return RET_OK;
}
static ret_t vpage_on_current_page_changed(void* ctx, event_t* e) {
widget_t* widget = WIDGET(ctx);
value_change_event_t* evt = value_change_event_cast(e);
uint32_t old_index = value_uint32(&(evt->old_value));
uint32_t new_index = value_uint32(&(evt->new_value));
uint32_t index = widget_index_of(widget);
if (old_index == index) {
if (widget_is_window_opened(widget)) {
vpage_on_leave(widget, index, new_index);
}
log_debug("leave vpage: %u\r\n", index);
} else if (new_index == index) {
vpage_on_enter(widget, index, old_index);
log_debug("enter vpage: %u\r\n", index);
}
return RET_OK;
}
static ret_t vpage_on_attach_parent(widget_t* widget, widget_t* parent) {
widget_on(parent, EVT_VALUE_CHANGED, vpage_on_current_page_changed, widget);
return RET_OK;
}
static ret_t vpage_on_detach_parent(widget_t* widget, widget_t* parent) {
return widget_off_by_ctx(parent, widget);
}
const char* s_vpage_properties[] = {VPAGE_PROP_UI_ASSET, WIDGET_PROP_ANIM_HINT, NULL};
TK_DECL_VTABLE(vpage) = {.size = sizeof(vpage_t),
.type = WIDGET_TYPE_VPAGE,
.clone_properties = s_vpage_properties,
.persistent_properties = s_vpage_properties,
.get_parent_vt = TK_GET_PARENT_VTABLE(widget),
.create = vpage_create,
.set_prop = vpage_set_prop,
.get_prop = vpage_get_prop,
.on_attach_parent = vpage_on_attach_parent,
.on_detach_parent = vpage_on_detach_parent,
.on_destroy = vpage_on_destroy};
widget_t* vpage_create(widget_t* parent, xy_t x, xy_t y, wh_t w, wh_t h) {
widget_t* widget = widget_create(parent, TK_REF_VTABLE(vpage), x, y, w, h);
vpage_t* vpage = VPAGE(widget);
return_value_if_fail(vpage != NULL, NULL);
return widget;
}
widget_t* vpage_cast(widget_t* widget) {
return_value_if_fail(WIDGET_IS_INSTANCE_OF(widget, vpage), NULL);
return widget;
}
|
0 |
repos/awtk/src/ext_widgets
|
repos/awtk/src/ext_widgets/vpage/vpage.h
|
/**
* File: vpage.h
* Author: AWTK Develop Team
* Brief: 虚拟页面(根据情况自动加载/卸载页面, 并提供入场/出场动画)。
*
* Copyright (c) 2021 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2021-06-09 Li XianJing <[email protected]> created
*
*/
#ifndef TK_VPAGE_H
#define TK_VPAGE_H
#include "base/widget.h"
BEGIN_C_DECLS
/**
* @class vpage_t
* @parent widget_t
* @annotation ["scriptable","design","widget"]
* 虚拟页面(根据情况自动加载/卸载页面，并提供入场/出场动画)。
*
* > 虚拟页面只能作为pages的直接子控件使用。
*
* 如果指定了ui_asset:
*
* * 当页面切换到后台时自动卸载，并触发EVT\_VPAGE\_CLOSE消息。
* * 当页面切换到前台时自动加载，在动画前出发EVT\_VPAGE\_WILL\_OPEN消息，在动画完成时触发 EVT\_VPAGE\_CLOSE消息。
*
* vpage\_t也可以当作普通view嵌入到pages中，让tab控件在切换时具有动画效果。
*
* 在xml中使用"vpage"标签创建控件。如：
*
* ```xml
* <!-- ui -->
* <vpage x="c" y="50" w="100" h="100" ui_asset="mypage"/>
* ```
*
* 可用通过style来设置控件的显示风格，如字体的大小和颜色等等(一般无需指定)。如：
*
* ```xml
* <!-- style -->
* <vpage>
* <style name="default">
* <normal />
* </style>
* </vpage>
* ```
*/
typedef struct _vpage_t {
widget_t widget;
/**
* @property {char*} ui_asset
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* UI资源名称。
*/
char* ui_asset;
/**
* @property {char*} anim_hint
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 动画类型(目前支持：vtranslate: 垂直平移，htranslate: 水平平移)。
*/
char* anim_hint;
} vpage_t;
/**
* @event {event_t} EVT_VPAGE_WILL_OPEN
* 页面即将打开(动画前)。
*/
/**
* @event {event_t} EVT_VPAGE_OPEN
* 页面打开完成(动画后)。
*/
/**
* @event {event_t} EVT_VPAGE_CLOSE
* 页面已经关闭(动画后)。
*/
/**
* @method vpage_create
* @annotation ["constructor", "scriptable"]
* 创建vpage对象
* @param {widget_t*} parent 父控件
* @param {xy_t} x x坐标
* @param {xy_t} y y坐标
* @param {wh_t} w 宽度
* @param {wh_t} h 高度
*
* @return {widget_t*} vpage对象。
*/
widget_t* vpage_create(widget_t* parent, xy_t x, xy_t y, wh_t w, wh_t h);
/**
* @method vpage_cast
* 转换为vpage对象(供脚本语言使用)。
* @annotation ["cast", "scriptable"]
* @param {widget_t*} widget vpage对象。
*
* @return {widget_t*} vpage对象。
*/
widget_t* vpage_cast(widget_t* widget);
/**
* @method vpage_set_ui_asset
* 设置 UI资源名称。
* @annotation ["scriptable"]
* @param {widget_t*} widget widget对象。
* @param {const char*} ui_asset UI资源名称。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t vpage_set_ui_asset(widget_t* widget, const char* ui_asset);
/**
* @method vpage_set_anim_hint
* 设置动画类型(vtranslate: 垂直平移，htranslate: 水平平移)。
* @annotation ["scriptable"]
* @param {widget_t*} widget widget对象。
* @param {const char*} anim_hint 动画类型。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t vpage_set_anim_hint(widget_t* widget, const char* anim_hint);
/**
* @enum vpage_event_t
* @annotation ["scriptable"]
* @prefix EVT_
* 虚拟页面的事件。
*/
typedef enum _vpage_event_t {
/**
* @const EVT_VPAGE_WILL_OPEN
* 页面即将打开(动画前)。
*/
EVT_VPAGE_WILL_OPEN = EVT_USER_START + 100,
/**
* @const EVT_VPAGE_OPEN
* 页面打开完成(动画后)。
*/
EVT_VPAGE_OPEN,
/**
* @const EVT_VPAGE_CLOSE
* 页面已经关闭(动画后)。
*/
EVT_VPAGE_CLOSE
} vpage_event_t;
#define VPAGE_PROP_UI_ASSET "ui_asset"
#define VPAGE_ANIM_VTRANSLATE "vtranslate"
#define VPAGE_ANIM_HTRANSLATE "htranslate"
#define WIDGET_TYPE_VPAGE "vpage"
#define VPAGE(widget) ((vpage_t*)(vpage_cast(WIDGET(widget))))
/*public for subclass and runtime type check*/
TK_EXTERN_VTABLE(vpage);
END_C_DECLS
#endif /*TK_VPAGE_H*/
|
0 |
repos/awtk/src/ext_widgets
|
repos/awtk/src/ext_widgets/svg_image/svg_image.c
|
/**
* File: svg_image.h
* Author: AWTK Develop Team
* Brief: svg_image
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-11-22 Li XianJing <[email protected]> created
*
*/
#include "tkc/mem.h"
#include "svg/bsvg.h"
#include "tkc/utils.h"
#include "base/enums.h"
#include "svg/bsvg_draw.h"
#include "base/widget_vtable.h"
#include "svg_image/svg_image.h"
#include "base/canvas_offline.h"
static ret_t svg_image_load_bsvg(widget_t* widget) {
svg_image_t* svg_image = SVG_IMAGE(widget);
image_base_t* image_base = IMAGE_BASE(widget);
return_value_if_fail(svg_image != NULL && image_base != NULL, RET_BAD_PARAMS);
if (svg_image->bsvg_asset != NULL) {
/* change svg image or resize widget need destory */
if (svg_image->canvas_offline != NULL) {
canvas_offline_destroy(svg_image->canvas_offline);
svg_image->canvas_offline = NULL;
}
widget_unload_asset(widget, svg_image->bsvg_asset);
svg_image->bsvg_asset = NULL;
}
svg_image->bsvg_asset =
widget_load_asset_ex(widget, ASSET_TYPE_IMAGE, ASSET_TYPE_IMAGE_BSVG, image_base->image);
return_value_if_fail(svg_image->bsvg_asset != NULL, RET_NOT_FOUND);
if (svg_image->bsvg_asset->subtype != ASSET_TYPE_IMAGE_BSVG) {
widget_unload_asset(widget, svg_image->bsvg_asset);
log_debug("invalid bsvg asset: %s\n", image_base->image);
svg_image->bsvg_asset = NULL;
}
return RET_OK;
}
static ret_t svg_image_draw_type_ex(widget_t* widget, void* ctx) {
svg_image_t* svg_image = SVG_IMAGE(widget);
return_value_if_fail(widget != NULL && svg_image != NULL && ctx != NULL, RET_BAD_PARAMS);
switch (svg_image->draw_type) {
case IMAGE_DRAW_DEFAULT: {
svg_image->scale_x = 1.0f;
svg_image->scale_y = 1.0f;
break;
}
case IMAGE_DRAW_SCALE: {
bsvg_t* bsvg = (bsvg_t*)ctx;
svg_image->scale_x = (float_t)((widget->w * 1.0f) / (bsvg->header->w * 1.0f));
svg_image->scale_y = (float_t)((widget->h * 1.0f) / (bsvg->header->h * 1.0f));
break;
}
case IMAGE_DRAW_SCALE_AUTO: {
bsvg_t* bsvg = (bsvg_t*)ctx;
if (widget->w < widget->h) {
svg_image->scale_x = (float_t)((widget->w * 1.0f) / (bsvg->header->w * 1.0f));
svg_image->scale_y = svg_image->scale_x;
} else {
svg_image->scale_y = (float_t)((widget->h * 1.0f) / (bsvg->header->h * 1.0f));
svg_image->scale_x = svg_image->scale_y;
}
break;
}
default: {
log_debug("not impl svg draw type: %d\n", svg_image->draw_type);
svg_image->draw_type = IMAGE_DRAW_DEFAULT;
break;
}
}
return RET_OK;
}
static ret_t svg_image_paint_before_adjust(widget_t* widget) {
bsvg_t bsvg;
svg_image_t* svg_image = SVG_IMAGE(widget);
return_value_if_fail(widget != NULL && svg_image != NULL, RET_BAD_PARAMS);
const asset_info_t* asset = svg_image->bsvg_asset;
return_value_if_fail(asset != NULL && asset->data != NULL, RET_BAD_PARAMS);
return_value_if_fail(bsvg_init(&bsvg, (const uint32_t*)asset->data, asset->size) != NULL,
RET_BAD_PARAMS);
if (widget->w <= 0 || widget->h <= 0 || bsvg.header->w <= 0 || bsvg.header->h <= 0) {
return RET_OK;
}
/* resize */
if (svg_image->org_h != widget->h || svg_image->org_w != widget->w) {
svg_image->org_w = widget->w;
svg_image->org_h = widget->h;
svg_image_draw_type_ex(widget, &bsvg);
/* change svg image or resize widget need destory */
if (svg_image->canvas_offline != NULL) {
canvas_offline_destroy(svg_image->canvas_offline);
svg_image->canvas_offline = NULL;
}
}
return RET_OK;
}
static ret_t svg_image_paint_online_canvas(widget_t* widget, canvas_t* c) {
bsvg_t bsvg;
int32_t x = 0;
int32_t y = 0;
rect_t r = {0};
rect_t r_save = {0};
rect_t r_vg_save = {0};
style_t* style = widget->astyle;
vgcanvas_t* vg = canvas_get_vgcanvas(c);
color_t black = color_init(0, 0, 0, 0xff);
svg_image_t* svg_image = SVG_IMAGE(widget);
color_t bg = style_get_color(style, STYLE_ID_BG_COLOR, black);
color_t fg = style_get_color(style, STYLE_ID_FG_COLOR, black);
return_value_if_fail(svg_image != NULL && widget != NULL && vg != NULL, RET_BAD_PARAMS);
const asset_info_t* asset = svg_image->bsvg_asset;
return_value_if_fail(asset != NULL && asset->data != NULL, RET_BAD_PARAMS);
return_value_if_fail(bsvg_init(&bsvg, (const uint32_t*)asset->data, asset->size) != NULL,
RET_BAD_PARAMS);
if (bsvg.header->w > 0 && bsvg.header->h > 0) {
x = (widget->w - ((int32_t)bsvg.header->w * svg_image->scale_x)) / 2;
y = (widget->h - ((int32_t)bsvg.header->h * svg_image->scale_y)) / 2;
}
canvas_save(c);
canvas_get_clip_rect(c, &r_save);
vgcanvas_save(vg);
r_vg_save = rect_from_rectf(vgcanvas_get_clip_rect(vg));
r = rect_init(c->ox, c->oy, widget->w, widget->h);
r = rect_intersect(&r, &r_save);
canvas_set_clip_rect(c, &r);
vgcanvas_clip_rect(vg, r.x, r.y, r.w, r.h);
image_transform(widget, c);
vgcanvas_translate(vg, x, y);
vgcanvas_set_fill_color(vg, bg);
vgcanvas_set_stroke_color(vg, fg);
vgcanvas_scale(vg, svg_image->scale_x, svg_image->scale_y);
bsvg_draw(&bsvg, vg);
vgcanvas_clip_rect(vg, r_vg_save.x, r_vg_save.y, r_vg_save.w, r_vg_save.h);
vgcanvas_restore(vg);
canvas_set_clip_rect(c, &r_save);
canvas_restore(c);
return RET_OK;
}
static ret_t svg_image_repaint_offline_cache(widget_t* widget, canvas_t* c) {
svg_image_t* svg_image = SVG_IMAGE(widget);
return_value_if_fail(svg_image != NULL, RET_FAIL);
if (svg_image->canvas_offline == NULL) {
#if defined(WITH_BITMAP_RGBA) || defined(WITH_GPU)
svg_image->canvas_offline = canvas_offline_create_by_widget(widget, BITMAP_FMT_RGBA8888);
#else
svg_image->canvas_offline = canvas_offline_create_by_widget(widget, BITMAP_FMT_BGRA8888);
#endif
}
canvas_offline_begin_draw(svg_image->canvas_offline);
canvas_offline_clear_canvas(svg_image->canvas_offline);
svg_image_paint_online_canvas(widget, svg_image->canvas_offline);
canvas_offline_end_draw(svg_image->canvas_offline);
return RET_OK;
}
static ret_t svg_image_paint_offline_canvas(widget_t* widget, canvas_t* c) {
svg_image_t* svg_image = SVG_IMAGE(widget);
return_value_if_fail(svg_image != NULL, RET_FAIL);
if (svg_image->canvas_offline == NULL || image_need_transform(widget)) {
/* need repaint offline canvas cache */
svg_image_repaint_offline_cache(widget, c);
}
if (svg_image->canvas_offline != NULL) {
/* draw by bitmap */
canvas_draw_image_at(c, canvas_offline_get_bitmap(svg_image->canvas_offline), 0, 0);
}
return RET_OK;
}
static ret_t svg_image_on_paint_self(widget_t* widget, canvas_t* c) {
svg_image_t* svg_image = SVG_IMAGE(widget);
return_value_if_fail(svg_image != NULL && widget != NULL, RET_BAD_PARAMS);
if (svg_image->bsvg_asset != NULL) {
return_value_if_fail(svg_image_paint_before_adjust(widget) == RET_OK, RET_FAIL);
if (svg_image->is_cache_mode == TRUE) {
svg_image_paint_offline_canvas(widget, c);
} else {
svg_image_paint_online_canvas(widget, c);
}
}
widget_paint_helper(widget, c, NULL, NULL);
return RET_OK;
}
static ret_t svg_image_on_destroy(widget_t* widget) {
svg_image_t* svg_image = SVG_IMAGE(widget);
return_value_if_fail(svg_image != NULL, RET_BAD_PARAMS);
if (svg_image->bsvg_asset != NULL) {
widget_unload_asset(widget, svg_image->bsvg_asset);
svg_image->bsvg_asset = NULL;
}
if (svg_image->canvas_offline != NULL) {
canvas_offline_destroy(svg_image->canvas_offline);
svg_image->canvas_offline = NULL;
}
return image_base_on_destroy(widget);
}
ret_t svg_image_set_image(widget_t* widget, const char* name) {
svg_image_t* svg_image = SVG_IMAGE(widget);
return_value_if_fail(svg_image != NULL && name != NULL, RET_BAD_PARAMS);
image_base_set_image(widget, name);
svg_image_load_bsvg(widget);
return widget_invalidate(widget, NULL);
}
ret_t svg_image_set_cache_mode(widget_t* widget, bool_t is_cache_mode) {
svg_image_t* svg_image = SVG_IMAGE(widget);
return_value_if_fail(svg_image != NULL, RET_BAD_PARAMS);
svg_image->is_cache_mode = is_cache_mode;
return widget_invalidate(widget, NULL);
}
ret_t svg_image_set_draw_type(widget_t* widget, image_draw_type_t draw_type) {
svg_image_t* svg_image = SVG_IMAGE(widget);
return_value_if_fail(svg_image != NULL, RET_BAD_PARAMS);
svg_image->draw_type = draw_type;
return widget_invalidate(widget, NULL);
}
static ret_t svg_image_get_prop(widget_t* widget, const char* name, value_t* v) {
svg_image_t* svg_image = SVG_IMAGE(widget);
return_value_if_fail(svg_image != NULL, RET_BAD_PARAMS);
if (tk_str_eq(name, WIDGET_PROP_DRAW_TYPE)) {
value_set_int(v, svg_image->draw_type);
return RET_OK;
} else {
return image_base_get_prop(widget, name, v);
}
}
static ret_t svg_image_set_prop(widget_t* widget, const char* name, const value_t* v) {
return_value_if_fail(widget != NULL && name != NULL && v != NULL, RET_BAD_PARAMS);
if (tk_str_eq(name, WIDGET_PROP_IMAGE)) {
svg_image_set_image(widget, value_str(v));
return RET_OK;
} else if (tk_str_eq(name, SVG_IMAGE_CACHE_MODE)) {
svg_image_set_cache_mode(widget, value_bool(v));
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_DRAW_TYPE)) {
if (v->type == VALUE_TYPE_STRING) {
const key_type_value_t* kv = image_draw_type_find(value_str(v));
if (kv != NULL) {
return svg_image_set_draw_type(widget, (image_draw_type_t)(kv->value));
}
} else {
return svg_image_set_draw_type(widget, (image_draw_type_t)value_int(v));
}
return RET_OK;
} else {
return image_base_set_prop(widget, name, v);
}
}
static ret_t svg_image_init(widget_t* widget) {
svg_image_t* svg_image = SVG_IMAGE(widget);
return_value_if_fail(svg_image != NULL, RET_BAD_PARAMS);
svg_image->is_cache_mode = FALSE;
svg_image->canvas_offline = NULL;
svg_image->draw_type = IMAGE_DRAW_DEFAULT;
image_base_init(widget);
return RET_OK;
}
static const char* s_svg_image_properties[] = {WIDGET_PROP_IMAGE, WIDGET_PROP_SCALE_X,
WIDGET_PROP_SCALE_Y, WIDGET_PROP_ANCHOR_X,
WIDGET_PROP_ANCHOR_Y, WIDGET_PROP_ROTATION,
WIDGET_PROP_CLICKABLE, WIDGET_PROP_SELECTABLE,
WIDGET_PROP_DRAW_TYPE, NULL};
TK_DECL_VTABLE(svg_image) = {.size = sizeof(svg_image_t),
.type = WIDGET_TYPE_SVG_IMAGE,
.clone_properties = s_svg_image_properties,
.persistent_properties = s_svg_image_properties,
.get_parent_vt = TK_GET_PARENT_VTABLE(image_base),
.create = svg_image_create,
.init = svg_image_init,
.on_destroy = svg_image_on_destroy,
.on_event = image_base_on_event,
.on_paint_self = svg_image_on_paint_self,
.on_copy = image_base_on_copy,
.set_prop = svg_image_set_prop,
.get_prop = svg_image_get_prop};
widget_t* svg_image_create(widget_t* parent, xy_t x, xy_t y, wh_t w, wh_t h) {
widget_t* widget = widget_create(parent, TK_REF_VTABLE(svg_image), x, y, w, h);
return_value_if_fail(svg_image_init(widget) == RET_OK, NULL);
return widget;
}
widget_t* svg_image_cast(widget_t* widget) {
return_value_if_fail(WIDGET_IS_INSTANCE_OF(widget, svg_image), NULL);
return widget;
}
|
0 |
repos/awtk/src/ext_widgets
|
repos/awtk/src/ext_widgets/svg_image/README.md
|
# SVG
目前支持的特性，请参考src/svg/README.md
|
0 |
repos/awtk/src/ext_widgets
|
repos/awtk/src/ext_widgets/svg_image/svg_image.h
|
/**
* File: svg_image.h
* Author: AWTK Develop Team
* Brief: svg_image
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-11-22 Li XianJing <[email protected]> created
*
*/
#ifndef TK_SVG_IMAGE_H
#define TK_SVG_IMAGE_H
#include "base/widget.h"
#include "base/image_base.h"
BEGIN_C_DECLS
/**
* @class svg_image_t
* @parent image_base_t
* @annotation ["scriptable","design","widget"]
* SVG图片控件。
*
* svg\_image\_t是[image\_base\_t](image_base_t.md)的子类控件，image\_base\_t的函数均适用于svg\_image\_t控件。
*
* 在xml中使用"svg"标签创建SVG图片控件。如：
*
* ```xml
* <svg image="girl"/>
* ```
*
* >更多用法请参考：[svg image](
* https://github.com/zlgopen/awtk/blob/master/design/default/ui/svg_image.xml)
*
* 在c代码中使用函数svg\_image\_create创建SVG图片控件。如：
*
* ```c
* widget_t* image = svg_image_create(win, 10, 10, 200, 200);
* image_set_image(image, "girl");
* ```
*
* > 创建之后: 需要用widget\_set\_image设置图片名称。
*
* > 完整示例请参考：[svg image demo](
* https://github.com/zlgopen/awtk-c-demos/blob/master/demos/svg_image.c)
*
* 可用通过style来设置控件的显示风格，如背景和边框等。如：
*
* ```xml
* <svg>
* <style name="default">
* <normal border_color="green" fg_color="red" />
* </style>
* </svg>
* ```
*
* > 更多用法请参考：[theme default](
* https://github.com/zlgopen/awtk/blob/master/design/default/styles/default.xml)
*
*/
typedef struct _svg_image_t {
image_base_t image_base;
/**
* @property {bool_t} is_cache_mode
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 离线缓存渲染模式。
*/
bool_t is_cache_mode;
/**
* @property {image_draw_type_t} draw_type
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* svg图片的绘制方式(支持旋转缩放, 目前仅支持scale、scale_auto模式)。
*/
image_draw_type_t draw_type;
/*private*/
wh_t org_w;
wh_t org_h;
float_t scale_x;
float_t scale_y;
canvas_t* canvas_offline;
const asset_info_t* bsvg_asset;
} svg_image_t;
/**
* @method svg_image_create
* 创建svg_image对象
* @annotation ["constructor", "scriptable"]
* @param {widget_t*} parent 父控件
* @param {xy_t} x x坐标
* @param {xy_t} y y坐标
* @param {wh_t} w 宽度
* @param {wh_t} h 高度
*
* @return {widget_t*} 对象。
*/
widget_t* svg_image_create(widget_t* parent, xy_t x, xy_t y, wh_t w, wh_t h);
/**
* @method svg_image_set_image
* 设置控件的图片名称。
*
*> 如果需要显示文件系统中的图片，只需将图片名称换成实际的文件名，并加上"file://"前缀即可。
*
* @annotation ["scriptable"]
* @param {widget_t*} widget image对象。
* @param {const char*} name 图片名称，该图片必须存在于资源管理器。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t svg_image_set_image(widget_t* widget, const char* name);
/**
* @method svg_image_set_cache_mode
* 控件设置是否开启离线缓存渲染模式。
*
*> 在确保svg图片不经常变化大小及状态的情况下，开启离线缓存渲染能够减少解析bsvg的开销，提高效率。
*
* @annotation ["scriptable"]
* @param {widget_t*} widget image对象。
* @param {bool_t} is_cache_mode 是否开启缓存模式。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t svg_image_set_cache_mode(widget_t* widget, bool_t is_cache_mode);
/**
* @method svg_image_set_draw_type
* 控件设置svg图片绘制模式。
*
* @annotation ["scriptable"]
* @param {widget_t*} widget image对象。
* @param {image_draw_type_t} draw_type 绘制模式。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t svg_image_set_draw_type(widget_t* widget, image_draw_type_t draw_type);
/**
* @method svg_image_cast
* 转换为svg_image对象(供脚本语言使用)。
* @annotation ["cast", "scriptable"]
* @param {widget_t*} widget svg_image对象。
*
* @return {widget_t*} svg_image对象。
*/
widget_t* svg_image_cast(widget_t* widget);
#define WIDGET_TYPE_SVG_IMAGE "svg"
#define SVG_IMAGE_CACHE_MODE "cache_mode"
#define SVG_IMAGE(widget) ((svg_image_t*)(svg_image_cast(WIDGET(widget))))
/*public for subclass and runtime type check*/
TK_EXTERN_VTABLE(svg_image);
END_C_DECLS
#endif /*TK_SVG_IMAGE_H*/
|
0 |
repos/awtk/src/ext_widgets
|
repos/awtk/src/ext_widgets/time_clock/time_clock.c
|
/**
* File: time_clock.h
* Author: AWTK Develop Team
* Brief: time_clock
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-08-29 Li XianJing <[email protected]> created
*
*/
#include "tkc/mem.h"
#include "base/timer.h"
#include "tkc/utils.h"
#include "tkc/matrix.h"
#include "tkc/date_time.h"
#include "base/image_manager.h"
#include "time_clock/time_clock.h"
static ret_t time_clock_init(widget_t* widget);
static ret_t time_clock_update_time(time_clock_t* time_clock);
ret_t time_clock_set_hour_anchor(widget_t* widget, const char* anchor_x, const char* anchor_y) {
time_clock_t* time_clock = TIME_CLOCK(widget);
return_value_if_fail(time_clock != NULL, RET_BAD_PARAMS);
if (anchor_x != NULL) {
time_clock->hour_anchor_x = tk_str_copy(time_clock->hour_anchor_x, anchor_x);
}
if (anchor_y != NULL) {
time_clock->hour_anchor_y = tk_str_copy(time_clock->hour_anchor_y, anchor_y);
}
return RET_OK;
}
ret_t time_clock_set_minute_anchor(widget_t* widget, const char* anchor_x, const char* anchor_y) {
time_clock_t* time_clock = TIME_CLOCK(widget);
return_value_if_fail(time_clock != NULL, RET_BAD_PARAMS);
if (anchor_x != NULL) {
time_clock->minute_anchor_x = tk_str_copy(time_clock->minute_anchor_x, anchor_x);
}
if (anchor_y != NULL) {
time_clock->minute_anchor_y = tk_str_copy(time_clock->minute_anchor_y, anchor_y);
}
return RET_OK;
}
ret_t time_clock_set_second_anchor(widget_t* widget, const char* anchor_x, const char* anchor_y) {
time_clock_t* time_clock = TIME_CLOCK(widget);
return_value_if_fail(time_clock != NULL, RET_BAD_PARAMS);
if (anchor_x != NULL) {
time_clock->second_anchor_x = tk_str_copy(time_clock->second_anchor_x, anchor_x);
}
if (anchor_y != NULL) {
time_clock->second_anchor_y = tk_str_copy(time_clock->second_anchor_y, anchor_y);
}
return RET_OK;
}
ret_t time_clock_set_hour(widget_t* widget, int32_t hour) {
time_clock_t* time_clock = TIME_CLOCK(widget);
return_value_if_fail(time_clock != NULL, RET_BAD_PARAMS);
time_clock->hour = hour;
return RET_OK;
}
ret_t time_clock_set_minute(widget_t* widget, int32_t minute) {
time_clock_t* time_clock = TIME_CLOCK(widget);
return_value_if_fail(time_clock != NULL, RET_BAD_PARAMS);
time_clock->minute = minute;
return RET_OK;
}
ret_t time_clock_set_second(widget_t* widget, int32_t second) {
time_clock_t* time_clock = TIME_CLOCK(widget);
return_value_if_fail(time_clock != NULL, RET_BAD_PARAMS);
time_clock->second = second;
return RET_OK;
}
ret_t time_clock_set_hour_image(widget_t* widget, const char* hour_image) {
time_clock_t* time_clock = TIME_CLOCK(widget);
return_value_if_fail(time_clock != NULL, RET_BAD_PARAMS);
time_clock->hour_image = tk_str_copy(time_clock->hour_image, hour_image);
return RET_OK;
}
ret_t time_clock_set_minute_image(widget_t* widget, const char* minute_image) {
time_clock_t* time_clock = TIME_CLOCK(widget);
return_value_if_fail(time_clock != NULL, RET_BAD_PARAMS);
time_clock->minute_image = tk_str_copy(time_clock->minute_image, minute_image);
return RET_OK;
}
ret_t time_clock_set_second_image(widget_t* widget, const char* second_image) {
time_clock_t* time_clock = TIME_CLOCK(widget);
return_value_if_fail(time_clock != NULL, RET_BAD_PARAMS);
time_clock->second_image = tk_str_copy(time_clock->second_image, second_image);
return RET_OK;
}
ret_t time_clock_set_bg_image(widget_t* widget, const char* bg_image) {
time_clock_t* time_clock = TIME_CLOCK(widget);
return_value_if_fail(time_clock != NULL, RET_BAD_PARAMS);
time_clock->bg_image = tk_str_copy(time_clock->bg_image, bg_image);
return RET_OK;
}
ret_t time_clock_set_image(widget_t* widget, const char* image) {
time_clock_t* time_clock = TIME_CLOCK(widget);
return_value_if_fail(time_clock != NULL, RET_BAD_PARAMS);
time_clock->image = tk_str_copy(time_clock->image, image);
return RET_OK;
}
static ret_t time_clock_get_prop(widget_t* widget, const char* name, value_t* v) {
time_clock_t* time_clock = TIME_CLOCK(widget);
return_value_if_fail(time_clock != NULL && name != NULL && v != NULL, RET_BAD_PARAMS);
if (tk_str_eq(name, TIME_CLOCK_PROP_HOUR)) {
value_set_int(v, time_clock->hour);
return RET_OK;
} else if (tk_str_eq(name, TIME_CLOCK_PROP_MINUTE)) {
value_set_int(v, time_clock->minute);
return RET_OK;
} else if (tk_str_eq(name, TIME_CLOCK_PROP_SECOND)) {
value_set_int(v, time_clock->second);
return RET_OK;
} else if (tk_str_eq(name, TIME_CLOCK_PROP_HOUR_IMAGE)) {
value_set_str(v, time_clock->hour_image);
return RET_OK;
} else if (tk_str_eq(name, TIME_CLOCK_PROP_SECOND_IMAGE)) {
value_set_str(v, time_clock->second_image);
return RET_OK;
} else if (tk_str_eq(name, TIME_CLOCK_PROP_MINUTE_IMAGE)) {
value_set_str(v, time_clock->minute_image);
return RET_OK;
} else if (tk_str_eq(name, TIME_CLOCK_PROP_BG_IMAGE)) {
value_set_str(v, time_clock->bg_image);
return RET_OK;
} else if (tk_str_eq(name, TIME_CLOCK_PROP_IMAGE)) {
value_set_str(v, time_clock->image);
return RET_OK;
} else if (tk_str_eq(name, TIME_CLOCK_PROP_HOUR_ANCHOR_X)) {
value_set_str(v, time_clock->hour_anchor_x);
return RET_OK;
} else if (tk_str_eq(name, TIME_CLOCK_PROP_HOUR_ANCHOR_Y)) {
value_set_str(v, time_clock->hour_anchor_y);
return RET_OK;
} else if (tk_str_eq(name, TIME_CLOCK_PROP_MINUTE_ANCHOR_X)) {
value_set_str(v, time_clock->minute_anchor_x);
return RET_OK;
} else if (tk_str_eq(name, TIME_CLOCK_PROP_MINUTE_ANCHOR_Y)) {
value_set_str(v, time_clock->minute_anchor_y);
return RET_OK;
} else if (tk_str_eq(name, TIME_CLOCK_PROP_SECOND_ANCHOR_X)) {
value_set_str(v, time_clock->second_anchor_x);
return RET_OK;
} else if (tk_str_eq(name, TIME_CLOCK_PROP_SECOND_ANCHOR_Y)) {
value_set_str(v, time_clock->second_anchor_y);
return RET_OK;
}
return RET_NOT_FOUND;
}
static ret_t time_clock_set_prop(widget_t* widget, const char* name, const value_t* v) {
return_value_if_fail(widget != NULL && name != NULL && v != NULL, RET_BAD_PARAMS);
if (tk_str_eq(name, TIME_CLOCK_PROP_HOUR)) {
return time_clock_set_hour(widget, value_int(v));
} else if (tk_str_eq(name, TIME_CLOCK_PROP_MINUTE)) {
return time_clock_set_minute(widget, value_int(v));
} else if (tk_str_eq(name, TIME_CLOCK_PROP_SECOND)) {
return time_clock_set_second(widget, value_int(v));
} else if (tk_str_eq(name, TIME_CLOCK_PROP_HOUR_IMAGE)) {
return time_clock_set_hour_image(widget, value_str(v));
} else if (tk_str_eq(name, TIME_CLOCK_PROP_SECOND_IMAGE)) {
return time_clock_set_second_image(widget, value_str(v));
} else if (tk_str_eq(name, TIME_CLOCK_PROP_MINUTE_IMAGE)) {
return time_clock_set_minute_image(widget, value_str(v));
} else if (tk_str_eq(name, TIME_CLOCK_PROP_BG_IMAGE)) {
return time_clock_set_bg_image(widget, value_str(v));
} else if (tk_str_eq(name, TIME_CLOCK_PROP_IMAGE)) {
return time_clock_set_image(widget, value_str(v));
} else if (tk_str_eq(name, TIME_CLOCK_PROP_HOUR_ANCHOR_X)) {
return time_clock_set_hour_anchor(widget, value_str(v), NULL);
} else if (tk_str_eq(name, TIME_CLOCK_PROP_HOUR_ANCHOR_Y)) {
return time_clock_set_hour_anchor(widget, NULL, value_str(v));
} else if (tk_str_eq(name, TIME_CLOCK_PROP_MINUTE_ANCHOR_X)) {
return time_clock_set_minute_anchor(widget, value_str(v), NULL);
} else if (tk_str_eq(name, TIME_CLOCK_PROP_MINUTE_ANCHOR_Y)) {
return time_clock_set_minute_anchor(widget, NULL, value_str(v));
} else if (tk_str_eq(name, TIME_CLOCK_PROP_SECOND_ANCHOR_X)) {
return time_clock_set_second_anchor(widget, value_str(v), NULL);
} else if (tk_str_eq(name, TIME_CLOCK_PROP_SECOND_ANCHOR_Y)) {
return time_clock_set_second_anchor(widget, NULL, value_str(v));
}
return RET_NOT_FOUND;
}
static ret_t time_clock_on_timer(const timer_info_t* info) {
widget_t* widget = NULL;
time_clock_t* time_clock = NULL;
return_value_if_fail(info != NULL, RET_REMOVE);
widget = WIDGET(info->ctx);
time_clock = TIME_CLOCK(widget);
return_value_if_fail(widget != NULL && time_clock != NULL, RET_BAD_PARAMS);
if (time_clock_update_time(time_clock) != RET_OK) {
time_clock->second++;
if (time_clock->second >= 60) {
time_clock->second = 0;
time_clock->minute++;
if (time_clock->minute >= 60) {
time_clock->minute = 0;
time_clock->hour++;
if (time_clock->hour >= 12) {
time_clock->hour = 0;
}
}
}
}
widget_invalidate_force(widget, NULL);
return RET_REPEAT;
}
static ret_t time_clock_on_destroy(widget_t* widget) {
time_clock_t* time_clock = TIME_CLOCK(widget);
return_value_if_fail(widget != NULL && time_clock != NULL, RET_BAD_PARAMS);
TKMEM_FREE(time_clock->image);
TKMEM_FREE(time_clock->bg_image);
TKMEM_FREE(time_clock->hour_image);
TKMEM_FREE(time_clock->minute_image);
TKMEM_FREE(time_clock->second_image);
TKMEM_FREE(time_clock->hour_anchor_x);
TKMEM_FREE(time_clock->hour_anchor_y);
TKMEM_FREE(time_clock->minute_anchor_x);
TKMEM_FREE(time_clock->minute_anchor_y);
TKMEM_FREE(time_clock->second_anchor_x);
TKMEM_FREE(time_clock->second_anchor_y);
return RET_OK;
}
static ret_t time_clock_load_image(widget_t* widget, const char* name, bitmap_t* bitmap) {
if (name != NULL && bitmap != NULL) {
return widget_load_image(widget, name, bitmap);
}
return RET_FAIL;
}
static ret_t time_clock_draw_image(widget_t* widget, canvas_t* c, bitmap_t* img, float_t dx,
float_t dy, float_t anchor_x, float_t anchor_y,
float_t rotation) {
vgcanvas_t* vg = canvas_get_vgcanvas(c);
vgcanvas_save(vg);
vgcanvas_translate(vg, c->ox + dx, c->oy + dy);
vgcanvas_translate(vg, anchor_x, anchor_y);
vgcanvas_rotate(vg, rotation);
vgcanvas_translate(vg, -anchor_x, -anchor_y);
vgcanvas_draw_image(vg, img, 0, 0, img->w, img->h, 0, 0, img->w, img->h);
vgcanvas_restore(vg);
return RET_OK;
}
static ret_t time_clock_on_paint_self(widget_t* widget, canvas_t* c) {
bitmap_t bitmap;
float_t rotation = 0;
time_clock_t* time_clock = TIME_CLOCK(widget);
ENSURE(time_clock);
rect_t dst = rect_init(0, 0, widget->w, widget->h);
if (time_clock_load_image(widget, time_clock->bg_image, &bitmap) == RET_OK) {
canvas_draw_image_ex(c, &bitmap, IMAGE_DRAW_CENTER, &dst);
}
if (time_clock_load_image(widget, time_clock->hour_image, &bitmap) == RET_OK) {
float_t anchor_x = tk_eval_ratio_or_px(time_clock->hour_anchor_x, bitmap.w);
float_t anchor_y = tk_eval_ratio_or_px(time_clock->hour_anchor_y, bitmap.h);
float_t dx = dst.w / 2 - anchor_x;
float_t dy = dst.h / 2 - anchor_y;
float_t hour = time_clock->hour + time_clock->minute / 60.0f;
rotation = (2 * M_PI * hour) / 12.0f;
time_clock_draw_image(widget, c, &bitmap, dx, dy, anchor_x, anchor_y, rotation);
}
if (time_clock_load_image(widget, time_clock->minute_image, &bitmap) == RET_OK) {
float_t anchor_x = tk_eval_ratio_or_px(time_clock->minute_anchor_x, bitmap.w);
float_t anchor_y = tk_eval_ratio_or_px(time_clock->minute_anchor_y, bitmap.h);
float_t dx = dst.w / 2 - anchor_x;
float_t dy = dst.h / 2 - anchor_y;
float_t minute = time_clock->minute + time_clock->second / 60.0f;
rotation = (2 * M_PI * minute) / 60.0f;
time_clock_draw_image(widget, c, &bitmap, dx, dy, anchor_x, anchor_y, rotation);
}
if (time_clock_load_image(widget, time_clock->second_image, &bitmap) == RET_OK) {
float_t anchor_x = tk_eval_ratio_or_px(time_clock->second_anchor_x, bitmap.w);
float_t anchor_y = tk_eval_ratio_or_px(time_clock->second_anchor_y, bitmap.h);
float_t dx = dst.w / 2 - anchor_x;
float_t dy = dst.h / 2 - anchor_y;
rotation = (2 * M_PI * time_clock->second) / 60.0f;
time_clock_draw_image(widget, c, &bitmap, dx, dy, anchor_x, anchor_y, rotation);
}
if (time_clock_load_image(widget, time_clock->image, &bitmap) == RET_OK) {
canvas_draw_image_ex(c, &bitmap, IMAGE_DRAW_CENTER, &dst);
}
return RET_OK;
}
static const char* s_time_clock_properties[] = {
TIME_CLOCK_PROP_HOUR,
TIME_CLOCK_PROP_MINUTE,
TIME_CLOCK_PROP_SECOND,
TIME_CLOCK_PROP_IMAGE,
TIME_CLOCK_PROP_BG_IMAGE,
TIME_CLOCK_PROP_HOUR_IMAGE,
TIME_CLOCK_PROP_MINUTE_IMAGE,
TIME_CLOCK_PROP_SECOND_IMAGE,
TIME_CLOCK_PROP_HOUR_ANCHOR_X TIME_CLOCK_PROP_HOUR_ANCHOR_Y,
TIME_CLOCK_PROP_MINUTE_ANCHOR_X,
TIME_CLOCK_PROP_MINUTE_ANCHOR_Y TIME_CLOCK_PROP_SECOND_ANCHOR_X,
TIME_CLOCK_PROP_SECOND_ANCHOR_Y,
NULL};
TK_DECL_VTABLE(time_clock) = {.size = sizeof(time_clock_t),
.type = WIDGET_TYPE_TIME_CLOCK,
.clone_properties = s_time_clock_properties,
.persistent_properties = s_time_clock_properties,
.get_parent_vt = TK_GET_PARENT_VTABLE(widget),
.create = time_clock_create,
.init = time_clock_init,
.on_paint_self = time_clock_on_paint_self,
.set_prop = time_clock_set_prop,
.get_prop = time_clock_get_prop,
.on_destroy = time_clock_on_destroy};
static ret_t time_clock_update_time(time_clock_t* time_clock) {
date_time_t dt;
if (date_time_init(&dt) != NULL) {
time_clock->hour = dt.hour % 12;
time_clock->minute = dt.minute;
time_clock->second = dt.second;
return RET_OK;
} else {
return RET_FAIL;
}
}
static ret_t time_clock_init(widget_t* widget) {
time_clock_t* time_clock = TIME_CLOCK(widget);
return_value_if_fail(time_clock != NULL, RET_BAD_PARAMS);
time_clock_update_time(time_clock);
widget_add_timer(widget, time_clock_on_timer, 1000);
time_clock->hour_anchor_x = tk_str_copy(NULL, "0.5");
time_clock->hour_anchor_y = tk_str_copy(NULL, "0.5");
time_clock->minute_anchor_x = tk_str_copy(NULL, "0.5");
time_clock->minute_anchor_y = tk_str_copy(NULL, "0.5");
time_clock->second_anchor_x = tk_str_copy(NULL, "0.5");
time_clock->second_anchor_y = tk_str_copy(NULL, "0.5");
return RET_OK;
}
widget_t* time_clock_create(widget_t* parent, xy_t x, xy_t y, wh_t w, wh_t h) {
widget_t* widget = widget_create(parent, TK_REF_VTABLE(time_clock), x, y, w, h);
return_value_if_fail(time_clock_init(widget) == RET_OK, NULL);
return widget;
}
widget_t* time_clock_cast(widget_t* widget) {
return_value_if_fail(WIDGET_IS_INSTANCE_OF(widget, time_clock), NULL);
return widget;
}
|
0 |
repos/awtk/src/ext_widgets
|
repos/awtk/src/ext_widgets/time_clock/time_clock.h
|
/**
* File: time_clock.h
* Author: AWTK Develop Team
* Brief: time_clock
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-08-30 Li XianJing <[email protected]> created
*
*/
#ifndef TK_TIME_CLOCK_H
#define TK_TIME_CLOCK_H
#include "base/widget.h"
BEGIN_C_DECLS
/**
* @class time_clock_t
* @parent widget_t
* @annotation ["scriptable","design","widget"]
* 模拟时钟控件。
*
* time\_clock\_t是[widget\_t](widget_t.md)的子类控件，widget\_t的函数均适用于time\_clock\_t控件。
*
* 在xml中使用"time\_clock"标签创建模拟时钟控件。如：
*
* ```xml
* <time_clock x="c" y="m" w="300" h="300" bg_image="clock_bg" image="clock"
* hour_image="clock_hour" minute_image="clock_minute" second_image="clock_second"/>
* ```
*
* > 更多用法请参考：[time\_clock.xml](
* https://github.com/zlgopen/awtk/blob/master/design/default/ui/time_clock.xml)
*
* 在c代码中使用函数time\_clock\_create创建模拟时钟控件。如：
*
* ```c
* widget_t* tc = time_clock_create(win, 10, 10, 240, 240);
* time_clock_set_image(tc, "clock");
* time_clock_set_bg_image(tc, "clock_bg");
* time_clock_set_hour_image(tc, "clock_hour");
* time_clock_set_minute_image(tc, "clock_minute");
* time_clock_set_second_image(tc, "clock_second");
* ```
*
* > 完整示例请参考：[time_clock demo](
* https://github.com/zlgopen/awtk-c-demos/blob/master/demos/time_clock.c)
*
* time\_clock一般不需要设置style。
*
*/
typedef struct _time_clock_t {
widget_t widget;
/**
* @property {int32_t} hour
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 小时。
*/
int32_t hour;
/**
* @property {int32_t} minute
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 分钟。
*/
int32_t minute;
/**
* @property {int32_t} second
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 秒。
*/
int32_t second;
/**
* @property {char*} image
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 中心图片。
*/
char* image;
/**
* @property {char*} bg_image
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 背景图片。
*/
char* bg_image;
/**
* @property {char*} hour_image
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 时针图片。
*/
char* hour_image;
/**
* @property {char*} minute_image
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 分针图片。
*/
char* minute_image;
/**
* @property {char*} second_image
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 秒针图片。
*/
char* second_image;
/**
* @property {char*} hour_anchor_x
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 时针图片旋转锚点x坐标。(后面加上px为像素点，不加px为相对百分比坐标0.0f到1.0f)
*/
char* hour_anchor_x;
/**
* @property {char*} hour_anchor_y
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 时针图片旋转锚点y坐标。(后面加上px为像素点，不加px为相对百分比坐标0.0f到1.0f)
*/
char* hour_anchor_y;
/**
* @property {char*} minute_anchor_x
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 分针图片旋转锚点x坐标。(后面加上px为像素点，不加px为相对百分比坐标0.0f到1.0f)
*/
char* minute_anchor_x;
/**
* @property {char*} minute_anchor_y
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 分针图片旋转锚点y坐标。(后面加上px为像素点，不加px为相对百分比坐标0.0f到1.0f)
*/
char* minute_anchor_y;
/**
* @property {char*} second_anchor_x
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 秒针图片旋转锚点x坐标。(后面加上px为像素点，不加px为相对百分比坐标0.0f到1.0f)
*/
char* second_anchor_x;
/**
* @property {char*} second_anchor_y
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 秒针图片旋转锚点y坐标。(后面加上px为像素点，不加px为相对百分比坐标0.0f到1.0f)
*/
char* second_anchor_y;
} time_clock_t;
/**
* @method time_clock_create
* 创建time_clock对象
* @annotation ["constructor", "scriptable"]
* @param {widget_t*} parent 父控件
* @param {xy_t} x x坐标
* @param {xy_t} y y坐标
* @param {wh_t} w 宽度
* @param {wh_t} h 高度
*
* @return {widget_t*} 对象。
*/
widget_t* time_clock_create(widget_t* parent, xy_t x, xy_t y, wh_t w, wh_t h);
/**
* @method time_clock_cast
* 转换为time_clock对象(供脚本语言使用)。
* @annotation ["cast", "scriptable"]
* @param {widget_t*} widget time_clock对象。
*
* @return {widget_t*} time_clock对象。
*/
widget_t* time_clock_cast(widget_t* widget);
/**
* @method time_clock_set_hour
* 设置小时的值。
* @annotation ["scriptable"]
* @param {widget_t*} widget 控件对象。
* @param {int32_t} hour 小时的值。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t time_clock_set_hour(widget_t* widget, int32_t hour);
/**
* @method time_clock_set_minute
* 设置分钟的值。
* @annotation ["scriptable"]
* @param {widget_t*} widget 控件对象。
* @param {int32_t} minute 分钟的值。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t time_clock_set_minute(widget_t* widget, int32_t minute);
/**
* @method time_clock_set_second
* 设置秒的值。
* @annotation ["scriptable"]
* @param {widget_t*} widget 控件对象。
* @param {int32_t} second 秒的值。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t time_clock_set_second(widget_t* widget, int32_t second);
/**
* @method time_clock_set_hour_image
* 设置小时的图片。
* @annotation ["scriptable"]
* @param {widget_t*} widget 控件对象。
* @param {const char*} hour 小时的图片。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t time_clock_set_hour_image(widget_t* widget, const char* hour);
/**
* @method time_clock_set_minute_image
* 设置分钟的图片。
* @annotation ["scriptable"]
* @param {widget_t*} widget 控件对象。
* @param {const char*} minute_image 分钟的图片。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t time_clock_set_minute_image(widget_t* widget, const char* minute_image);
/**
* @method time_clock_set_second_image
* 设置秒的图片。
* @annotation ["scriptable"]
* @param {widget_t*} widget 控件对象。
* @param {const char*} second_image 秒的图片。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t time_clock_set_second_image(widget_t* widget, const char* second_image);
/**
* @method time_clock_set_bg_image
* 设置背景图片。
* @annotation ["scriptable"]
* @param {widget_t*} widget 控件对象。
* @param {const char*} bg_image 背景图片。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t time_clock_set_bg_image(widget_t* widget, const char* bg_image);
/**
* @method time_clock_set_image
* 设置中心图片。
* @annotation ["scriptable"]
* @param {widget_t*} widget 控件对象。
* @param {const char*} image 图片。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t time_clock_set_image(widget_t* widget, const char* image);
/**
* @method time_clock_set_hour_anchor
* 设置小时指针的旋转锚点。
* > 后面加上px为像素点，不加px为相对百分比坐标0.0f到1.0f
*
* @annotation ["scriptable"]
* @param {widget_t*} widget 控件对象。
* @param {const char*} anchor_x 指针的锚点坐标x。
* @param {const char*} anchor_y 指针的锚点坐标y。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t time_clock_set_hour_anchor(widget_t* widget, const char* anchor_x, const char* anchor_y);
/**
* @method time_clock_set_minute_anchor
* 设置分钟指针的旋转锚点。
* > 后面加上px为像素点，不加px为相对百分比坐标0.0f到1.0f
*
* @annotation ["scriptable"]
* @param {widget_t*} widget 控件对象。
* @param {const char*} anchor_x 指针的锚点坐标x。
* @param {const char*} anchor_y 指针的锚点坐标y。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t time_clock_set_minute_anchor(widget_t* widget, const char* anchor_x, const char* anchor_y);
/**
* @method time_clock_set_second_anchor
* 设置秒钟指针的旋转锚点。
* > 后面加上px为像素点，不加px为相对百分比坐标0.0f到1.0f
*
* @annotation ["scriptable"]
* @param {widget_t*} widget 控件对象。
* @param {const char*} anchor_x 指针的锚点坐标x。
* @param {const char*} anchor_y 指针的锚点坐标y。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t time_clock_set_second_anchor(widget_t* widget, const char* anchor_x, const char* anchor_y);
#define TIME_CLOCK_PROP_HOUR "hour"
#define TIME_CLOCK_PROP_MINUTE "minute"
#define TIME_CLOCK_PROP_SECOND "second"
#define TIME_CLOCK_PROP_IMAGE "image"
#define TIME_CLOCK_PROP_BG_IMAGE "bg_image"
#define TIME_CLOCK_PROP_HOUR_IMAGE "hour_image"
#define TIME_CLOCK_PROP_MINUTE_IMAGE "minute_image"
#define TIME_CLOCK_PROP_SECOND_IMAGE "second_image"
#define TIME_CLOCK_PROP_HOUR_ANCHOR_X "hour_anchor_x"
#define TIME_CLOCK_PROP_HOUR_ANCHOR_Y "hour_anchor_y"
#define TIME_CLOCK_PROP_MINUTE_ANCHOR_X "minute_anchor_x"
#define TIME_CLOCK_PROP_MINUTE_ANCHOR_Y "minute_anchor_y"
#define TIME_CLOCK_PROP_SECOND_ANCHOR_X "second_anchor_x"
#define TIME_CLOCK_PROP_SECOND_ANCHOR_Y "second_anchor_y"
#define WIDGET_TYPE_TIME_CLOCK "time_clock"
#define TIME_CLOCK(widget) ((time_clock_t*)(time_clock_cast(WIDGET(widget))))
/*public for subclass and runtime type check*/
TK_EXTERN_VTABLE(time_clock);
/*public for test*/
ret_t time_clock_set_anchor_for_str(float_t max_size, const char* anchor, float_t* image_anchor);
END_C_DECLS
#endif /*TK_TIME_CLOCK_H*/
|
0 |
repos/awtk/src/ext_widgets
|
repos/awtk/src/ext_widgets/timer_widget/timer_widget.c
|
/**
* File: timer_widget.c
* Author: AWTK Develop Team
* Brief: 定时器。
*
* Copyright (c) 2022 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2022-07-07 Li XianJing <[email protected]> created
*
*/
#include "tkc/mem.h"
#include "tkc/utils.h"
#include "timer_widget.h"
ret_t timer_widget_set_duration(widget_t* widget, uint32_t duration) {
timer_widget_t* timer_widget = TIMER_WIDGET(widget);
return_value_if_fail(timer_widget != NULL, RET_BAD_PARAMS);
if (timer_widget->timer_id != TK_INVALID_ID) {
timer_modify(timer_widget->timer_id, duration);
}
timer_widget->duration = duration;
return RET_OK;
}
static ret_t timer_widget_get_prop(widget_t* widget, const char* name, value_t* v) {
timer_widget_t* timer_widget = TIMER_WIDGET(widget);
return_value_if_fail(timer_widget != NULL && name != NULL && v != NULL, RET_BAD_PARAMS);
if (tk_str_eq(TIMER_WIDGET_PROP_DURATION, name)) {
value_set_uint32(v, timer_widget->duration);
return RET_OK;
}
return RET_NOT_FOUND;
}
static ret_t timer_widget_set_prop(widget_t* widget, const char* name, const value_t* v) {
return_value_if_fail(widget != NULL && name != NULL && v != NULL, RET_BAD_PARAMS);
if (tk_str_eq(TIMER_WIDGET_PROP_DURATION, name)) {
timer_widget_set_duration(widget, value_uint32(v));
return RET_OK;
}
return RET_NOT_FOUND;
}
static ret_t timer_widget_on_destroy(widget_t* widget) {
timer_widget_t* timer_widget = TIMER_WIDGET(widget);
return_value_if_fail(widget != NULL && timer_widget != NULL, RET_BAD_PARAMS);
if (timer_widget->timer_id != TK_INVALID_ID) {
timer_remove(timer_widget->timer_id);
}
return RET_OK;
}
static ret_t timer_widget_on_paint_self(widget_t* widget, canvas_t* c) {
timer_widget_t* timer_widget = TIMER_WIDGET(widget);
(void)timer_widget;
return RET_OK;
}
static ret_t timer_widget_on_timer(const timer_info_t* info) {
widget_t* widget = WIDGET(info->ctx);
if (widget->enable) {
widget_dispatch_simple_event(widget, EVT_TIMER);
}
return RET_REPEAT;
}
static ret_t timer_widget_on_event(widget_t* widget, event_t* e) {
timer_widget_t* timer_widget = TIMER_WIDGET(widget);
return_value_if_fail(widget != NULL && timer_widget != NULL, RET_BAD_PARAMS);
if (e->type == EVT_WINDOW_OPEN) {
timer_widget->timer_id = timer_add(timer_widget_on_timer, widget, timer_widget->duration);
}
return RET_OK;
}
static ret_t timer_widget_init(widget_t* widget) {
timer_widget_t* timer_widget = TIMER_WIDGET(widget);
return_value_if_fail(timer_widget != NULL, RET_BAD_PARAMS);
timer_widget->duration = 1000;
return RET_OK;
}
const char* s_timer_widget_properties[] = {TIMER_WIDGET_PROP_DURATION, NULL};
TK_DECL_VTABLE(timer_widget) = {.size = sizeof(timer_widget_t),
.type = WIDGET_TYPE_TIMER_WIDGET,
.clone_properties = s_timer_widget_properties,
.persistent_properties = s_timer_widget_properties,
.get_parent_vt = TK_GET_PARENT_VTABLE(widget),
.create = timer_widget_create,
.init = timer_widget_init,
.on_paint_self = timer_widget_on_paint_self,
.set_prop = timer_widget_set_prop,
.get_prop = timer_widget_get_prop,
.on_event = timer_widget_on_event,
.on_destroy = timer_widget_on_destroy};
widget_t* timer_widget_create(widget_t* parent, xy_t x, xy_t y, wh_t w, wh_t h) {
widget_t* widget = widget_create(parent, TK_REF_VTABLE(timer_widget), x, y, w, h);
return_value_if_fail(timer_widget_init(widget) == RET_OK, NULL) return widget;
}
widget_t* timer_widget_cast(widget_t* widget) {
return_value_if_fail(WIDGET_IS_INSTANCE_OF(widget, timer_widget), NULL);
return widget;
}
|
0 |
repos/awtk/src/ext_widgets
|
repos/awtk/src/ext_widgets/timer_widget/timer_widget.h
|
/**
* File: timer_widget.h
* Author: AWTK Develop Team
* Brief: 定时器。
*
* Copyright (c) 2022 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2022-07-07 Li XianJing <[email protected]> created
*
*/
#ifndef TK_TIMER_WIDGET_H
#define TK_TIMER_WIDGET_H
#include "base/widget.h"
BEGIN_C_DECLS
/**
* @class timer_widget_t
* @parent widget_t
* @annotation ["scriptable","design","widget"]
* 定时器。
* > 主要目的是方便以拖拽的方式创建定时器，并用AWBlock编写简单的事件处理程序。
* 在xml中使用"timer"标签创建控件。如：
*
* ```xml
* <!-- ui -->
* <timer x="c" y="50" w="100" h="100" duration="1000"/>
* ```
*
* 可用通过style来设置控件的显示风格，如字体的大小和颜色等等。如：
* > 本控件默认不可见，无需指定style。
*
* ```xml
* <!-- style -->
* <timer>
* <style name="default" font_size="32">
* <normal text_color="black" />
* </style>
* </timer>
* ```
*/
typedef struct _timer_widget_t {
widget_t widget;
/**
* @property {uint32_t} duration
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 时长(毫秒)。
*/
uint32_t duration;
/*private*/
uint32_t timer_id;
} timer_widget_t;
/**
* @event {event_t} EVT_TIMER
* 定时器事件。
*/
/**
* @method timer_widget_create
* @annotation ["constructor", "scriptable"]
* 创建timer_widget对象
* @param {widget_t*} parent 父控件
* @param {xy_t} x x坐标
* @param {xy_t} y y坐标
* @param {wh_t} w 宽度
* @param {wh_t} h 高度
*
* @return {widget_t*} timer_widget对象。
*/
widget_t* timer_widget_create(widget_t* parent, xy_t x, xy_t y, wh_t w, wh_t h);
/**
* @method timer_widget_cast
* 转换为timer_widget对象(供脚本语言使用)。
* @annotation ["cast", "scriptable"]
* @param {widget_t*} widget timer_widget对象。
*
* @return {widget_t*} timer_widget对象。
*/
widget_t* timer_widget_cast(widget_t* widget);
/**
* @method timer_widget_set_duration
* 设置 时长(毫秒)。
* @annotation ["scriptable"]
* @param {widget_t*} widget widget对象。
* @param {uint32_t} duration 时长(毫秒)。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t timer_widget_set_duration(widget_t* widget, uint32_t duration);
#define TIMER_WIDGET_PROP_DURATION "duration"
#define WIDGET_TYPE_TIMER_WIDGET "timer"
#define TIMER_WIDGET(widget) ((timer_widget_t*)(timer_widget_cast(WIDGET(widget))))
/*public for subclass and runtime type check*/
TK_EXTERN_VTABLE(timer_widget);
END_C_DECLS
#endif /*TK_TIMER_WIDGET_H*/
|
0 |
repos/awtk/src/ext_widgets
|
repos/awtk/src/ext_widgets/slide_view/slide_view.h
|
/**
* File: slide_view.h
* Author: AWTK Develop Team
* Brief: slide_view
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-06-05 Li XianJing <[email protected]> created
*
*/
#ifndef TK_SLIDE_VIEW_H
#define TK_SLIDE_VIEW_H
#include "base/widget.h"
#include "base/velocity.h"
BEGIN_C_DECLS
/**
* @class slide_view_t
* @parent widget_t
* @annotation ["scriptable","design","widget"]
* 滑动视图。
*
* 滑动视图可以管理多个页面，并通过滑动来切换当前页面。也可以管理多张图片，让它们自动切换。
*
* slide\_view\_t是[widget\_t](widget_t.md)的子类控件，widget\_t的函数均适用于slide\_view\_t控件。
*
* 在xml中使用"slide\_view"标签创建滑动视图控件。如：
*
* ```xml
* <slide_view x="0" y="0" w="100%" h="100%" style="dot">
* <view x="0" y="0" w="100%" h="100%" children_layout="default(w=60,h=60,m=5,s=10)">
* ...
* </view>
* <view x="0" y="0" w="100%" h="100%" children_layout="default(w=60,h=60,m=5,s=10)">
* ...
* </view>
* </slide_view>
* ```
*
* > 更多用法请参考：[slide_view.xml](
*https://github.com/zlgopen/awtk/blob/master/design/default/ui/slide_view.xml)
*
* 在c代码中使用函数slide\_view\_create创建滑动视图控件。如：
*
* ```c
* slide_view = slide_view_create(win, 0, 0, win->w, win->h);
* ```
*
* > 完整示例请参考：
* [slide_view demo](
* https://github.com/zlgopen/awtk-c-demos/blob/master/demos/slide_view.c)
*
* 可用通过style来设置控件的显示风格，如背景颜色和指示器的图标等等。如：
*
* ```xml
* <style name="dot">
* <normal icon="dot" active_icon="active_dot"/>
* </style>
* ```
*
* > 如果希望背景图片跟随滚动，请将背景图片设置到页面上，否则设置到slide\_view上。
*
* > 更多用法请参考：[theme default](
* https://github.com/zlgopen/awtk/blob/master/design/default/styles/default.xml#L458)
*
*/
typedef struct _slide_view_t {
widget_t widget;
/**
* @property {bool_t} vertical
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 是否为上下滑动模式。
*/
bool_t vertical;
/**
* @property {uint16_t} auto_play
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 自动播放。0表示禁止自动播放，非0表示自动播放时每一页播放的时间(毫秒)。
*/
uint16_t auto_play;
/**
* @property {bool_t} loop
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 循环切换模式。
*
* 向后切换：切换到最后一页时，再往后切换就到第一页。
* 向前切换：切换到第一页时，再往前切换就到最后一页。
*/
bool_t loop;
/**
* @property {char*} anim_hint
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 页面切换效果。
*
*/
char* anim_hint;
/**
* @property {uint32_t} drag_threshold
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 拖动临界值。
*
*/
uint32_t drag_threshold;
/**
* @property {uint32_t} animating_time
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 动画时间（单位：毫秒）。
*
*/
uint32_t animating_time;
/* private */
velocity_t velocity;
point_t down;
int32_t xoffset;
int32_t yoffset;
uint32_t active;
uint32_t last_active;
uint32_t timer_id;
bool_t dragged;
bool_t pressed;
bool_t animating;
bool_t check_last;
bool_t remove_when_anim_done;
/* for save focused child */
str_t str_target;
uint32_t init_idle_id;
uint32_t focused_idle_id;
/* for animation */
widget_t* prev;
widget_t* next;
/* for move */
uint32_t move_idle_id;
} slide_view_t;
/**
* @event {value_change_event_t} EVT_VALUE_WILL_CHANGE
* 值(当前页)即将改变事件。
*/
/**
* @event {value_change_event_t} EVT_VALUE_CHANGED
* 值(当前页)改变事件。
*/
/**
* @event {event_t} EVT_PAGE_CHANGED
* 页面改变事件。
*/
/**
* @event {event_t} EVT_PAGE_CHANGING
* 页面正在改变。
*/
/**
* @method slide_view_create
* 创建slide_view对象
* @annotation ["constructor", "scriptable"]
* @param {widget_t*} parent 父控件
* @param {xy_t} x x坐标
* @param {xy_t} y y坐标
* @param {wh_t} w 宽度
* @param {wh_t} h 高度
*
* @return {widget_t*} 对象。
*/
widget_t* slide_view_create(widget_t* parent, xy_t x, xy_t y, wh_t w, wh_t h);
/**
* @method slide_view_cast
* 转换为slide_view对象(供脚本语言使用)。
* @annotation ["cast", "scriptable"]
* @param {widget_t*} widget slide_view对象。
*
* @return {widget_t*} slide_view对象。
*/
widget_t* slide_view_cast(widget_t* widget);
/**
* @method slide_view_set_auto_play
* 设置为自动播放模式。
* @annotation ["scriptable"]
* @param {widget_t*} widget slide_view对象。
* @param {uint16_t} auto_play 0表示禁止自动播放，非0表示自动播放时每一页播放的时间(毫秒)。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t slide_view_set_auto_play(widget_t* widget, uint16_t auto_play);
/**
* @method slide_view_set_active
* 设置当前页的序号(默认启用动画)。
* @annotation ["scriptable"]
* @param {widget_t*} widget slide_view对象。
* @param {uint32_t} index 当前页的序号。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t slide_view_set_active(widget_t* widget, uint32_t index);
/**
* @method slide_view_set_active_ex
* 设置当前页的序号。
* @annotation ["scriptable"]
* @param {widget_t*} widget slide_view对象。
* @param {uint32_t} index 当前页的序号。
* @param {bool_t} animate 是否启用动画。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t slide_view_set_active_ex(widget_t* widget, uint32_t index, bool_t animate);
/**
* @method slide_view_set_vertical
* 设置为上下滑动(缺省为左右滑动)。
* @annotation ["scriptable"]
* @param {widget_t*} widget slide_view对象。
* @param {bool_t} vertical TRUE表示上下滑动，FALSE表示左右滑动。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t slide_view_set_vertical(widget_t* widget, bool_t vertical);
/**
* @method slide_view_set_anim_hint
* 设置页面切换动画。
*
* anim_hint取值如下：
*
* * "translate"：平移。
* * "overlap"：覆盖。
* * "overlap\_with\_alpha"：覆盖并改变透明度。
*
*> 使用"overlap"或"overlap\_with\_alpha"动画时，背景图片最好指定到page上。
*>
*> 使用"overlap\_with\_alpha"动画时，slideview的背景设置为黑色，
*> 或slideview的背景设置为透明，窗口的背景设置为黑色，以获得更好的视觉效果和性能。
*
* @annotation ["scriptable"]
* @param {widget_t*} widget slide_view对象。
* @param {const char*} anim_hint 页面切换动画。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t slide_view_set_anim_hint(widget_t* widget, const char* anim_hint);
/**
* @method slide_view_set_loop
* 设置循环切换模式。
* @annotation ["scriptable"]
* @param {widget_t*} widget slide_view对象。
* @param {bool_t} loop 是否启用循环切换模式。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t slide_view_set_loop(widget_t* widget, bool_t loop);
/**
* @method slide_view_set_drag_threshold
* 设置拖拽临界值。
* @annotation ["scriptable"]
* @param {widget_t*} widget slide_view对象。
* @param {uint32_t} drag_threshold 拖动临界值。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t slide_view_set_drag_threshold(widget_t* widget, uint32_t drag_threshold);
/**
* @method slide_view_set_animating_time
* 设置动画时间(毫秒)。
* @annotation ["scriptable"]
* @param {widget_t*} widget slide_view对象。
* @param {uint32_t} animating_time 动画时间(毫秒)。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t slide_view_set_animating_time(widget_t* widget, uint32_t animating_time);
/**
* @method slide_view_remove_index
* 删除指定序号页面。
* @annotation ["scriptable"]
* @param {widget_t*} widget slide_view对象。
* @param {uint32_t} index 删除页面的序号。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t slide_view_remove_index(widget_t* widget, uint32_t index);
/*public for test only*/
widget_t* slide_view_get_prev(slide_view_t* slide_view);
widget_t* slide_view_get_next(slide_view_t* slide_view);
ret_t slide_view_activate_prev(slide_view_t* slide_view);
ret_t slide_view_activate_next(slide_view_t* slide_view);
#define SLIDE_VIEW(widget) ((slide_view_t*)(slide_view_cast(WIDGET(widget))))
/*public for subclass and runtime type check*/
TK_EXTERN_VTABLE(slide_view);
END_C_DECLS
#endif /*TK_SLIDE_VIEW_H*/
|
0 |
repos/awtk/src/ext_widgets
|
repos/awtk/src/ext_widgets/slide_view/slide_indicator.h
|
/**
* File: slide_indicator.h
* Author: AWTK Develop Team
* Brief: slide_indicator
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2019-05-29 Xu ChaoZe <[email protected]> created
*
*/
#ifndef TK_SLIDE_INDICATOR_H
#define TK_SLIDE_INDICATOR_H
#include "tkc/darray.h"
#include "base/widget.h"
BEGIN_C_DECLS
/**
* @enum indicator_default_paint_t
* @prefix INDICATOR_DEFAULT_PAINT_
* @annotation ["scriptable"]
* 指示器默认绘制的类型。
*/
typedef enum _indicator_default_paint_t {
/**
* @const INDICATOR_DEFAULT_PAINT_AUTO
* 自动选择。
*/
INDICATOR_DEFAULT_PAINT_AUTO = 0,
/**
* @const INDICATOR_DEFAULT_PAINT_FILL_DOT
* 实心圆点指示器，当前项填充selected_fg_color，其他填充fg_color。
*/
INDICATOR_DEFAULT_PAINT_FILL_DOT = 1,
/**
* @const INDICATOR_DEFAULT_PAINT_STROKE_DOT
* 镂空圆点指示器，当前项填充selected_fg_color，其他镂空fg_color。
*/
INDICATOR_DEFAULT_PAINT_STROKE_DOT = 2,
/**
* @const INDICATOR_DEFAULT_PAINT_FILL_RECT
* 实心矩形指示器，当前项填充selected_fg_color，其他填充fg_color。
*/
INDICATOR_DEFAULT_PAINT_FILL_RECT = 3,
/**
* @const INDICATOR_DEFAULT_PAINT_STROKE_RECT
* 镂空矩形指示器，当前项填充selected_fg_color，其他镂空fg_color。
*/
INDICATOR_DEFAULT_PAINT_STROKE_RECT = 4
} indicator_default_paint_t;
/**
* @class slide_indicator_t
* @parent widget_t
* @annotation ["scriptable","design","widget"]
* slide_view的指示器控件。
*
*> 支持直线、弧线排布，默认有4种绘制样式，若设置了icon/active_icon，则优先使用icon/active_icon
*
* slide\_indicator\_t是[widget\_t](widget_t.md)的子类控件，widget\_t的函数均适用于slide\_indicator\_t控件。
*
* 在xml中使用"slide\_indicator"或"slide\_indicator\_arc"标签创建指示器控件。如：
*
* ```xml
* <slide_view name="view" x="0" y="0" w="100%" h="100%">
* ...
* </slide_view>
* <slide_indicator name="indicator" x="right" y="0" w="6" h="100%"/>
* ```
*
* > 更多用法请参考：[slide\_view.xml](
*https://github.com/zlgopen/awtk/blob/master/design/default/ui/slide_view.xml)
*
* 在c代码中使用函数slide\_indicator\_create创建指示器控件。如：
*
* ```c
* widget_t* slide_indicator = slide_indicator_create(parent, 0, 0, 0, 0);
* ```
*
* ```xml
* <style name="default">
* <normal fg_color="#FFFFFF80" selected_fg_color="#FFFFFF"/>
* </style>
* ```
*
* > 更多用法请参考：[theme default](
*https://github.com/zlgopen/awtk/blob/master/design/default/styles/default.xml#L350)
*
*/
typedef struct _slide_indicator_t {
widget_t widget;
/**
* @property {uint32_t} value
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 值(缺省为0)。
*/
uint32_t value;
/**
* @property {uint32_t} max
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 最大值(缺省为100)。
*/
uint32_t max;
/**
* @property {indicator_default_paint_t} default_paint
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 指示器的类型。
*/
indicator_default_paint_t default_paint;
/**
* @property {uint16_t} auto_hide
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 自动隐藏。0表示禁止，非0表示无操作后延迟多久隐藏。
*/
uint16_t auto_hide;
/**
* @property {int32_t} margin
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 指示器与边缘的边距。
*/
int32_t margin;
/**
* @property {float_t} spacing
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 指示器的中心之间的间距（圆弧显示时，间距的单位为弧度，否则为像素）。
*/
float_t spacing;
/**
* @property {uint32_t} size
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 指示器的大小。
*/
uint32_t size;
/**
* @property {char*} anchor_x
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 锚点x坐标。(后面加上px为像素点，不加px为相对百分比坐标0.0f到1.0f)
*/
char* anchor_x;
/**
* @property {char*} anchor_y
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 锚点y坐标。(后面加上px为像素点，不加px为相对百分比坐标0.0f到1.0f)
*/
char* anchor_y;
/**
* @property {char*} indicated_target
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 指示器指示的目标控件的名称。
*/
char* indicated_target;
/**
* @property {bool_t} transition
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 是否启用过渡效果。
*/
bool_t transition;
/*private*/
uint8_t pressed : 1;
uint8_t chilren_indicated : 1;
bool_t reset_icon_rect_list;
bool_t loop;
bool_t is_value_changing;
widget_animator_t* wa_opactiy;
widget_t* indicated_widget;
uint64_t last_move_point_time;
point_t last_move_point;
uint32_t check_hide_idle;
darray_t icon_rect_list;
float_t icon_rect_spacing;
int32_t curr_value;
float_t value_offset;
} slide_indicator_t;
/**
* @event {value_change_event_t} EVT_VALUE_WILL_CHANGE
* 值(当前页的序号)即将改变事件。
*/
/**
* @event {value_change_event_t} EVT_VALUE_CHANGED
* 值(当前页的序号)改变事件。
*/
/**
* @event {event_t} EVT_PAGE_CHANGED
* 页面改变事件。
*/
/**
* @event {event_t} EVT_PAGE_CHANGING
* 页面正在改变。
*/
/**
* @method slide_indicator_create
* 创建slide_indicator对象
* @annotation ["constructor", "scriptable"]
* @param {widget_t*} parent 父控件
* @param {xy_t} x x坐标
* @param {xy_t} y y坐标
* @param {wh_t} w 宽度
* @param {wh_t} h 高度
*
* @return {widget_t*} 对象。
*/
widget_t* slide_indicator_create(widget_t* parent, xy_t x, xy_t y, wh_t w, wh_t h);
/**
* @method slide_indicator_create_linear
* 创建slide_indicator对象（线性显示）
* @annotation ["constructor", "scriptable"]
* @param {widget_t*} parent 父控件
* @param {xy_t} x x坐标
* @param {xy_t} y y坐标
* @param {wh_t} w 宽度
* @param {wh_t} h 高度
*
* @return {widget_t*} 对象。
*/
widget_t* slide_indicator_create_linear(widget_t* parent, xy_t x, xy_t y, wh_t w, wh_t h);
/**
* @method slide_indicator_create_arc
* 创建slide_indicator对象（圆弧显示）
* @annotation ["constructor", "scriptable"]
* @param {widget_t*} parent 父控件
* @param {xy_t} x x坐标
* @param {xy_t} y y坐标
* @param {wh_t} w 宽度
* @param {wh_t} h 高度
*
* @return {widget_t*} 对象。
*/
widget_t* slide_indicator_create_arc(widget_t* parent, xy_t x, xy_t y, wh_t w, wh_t h);
/**
* @method slide_indicator_cast
* 转换为slide_indicator对象(供脚本语言使用)。
* @annotation ["cast", "scriptable"]
* @param {widget_t*} widget slide_indicator对象。
*
* @return {widget_t*} slide_indicator对象。
*/
widget_t* slide_indicator_cast(widget_t* widget);
/**
* @method slide_indicator_set_value
* 设置当前页的序号。
* @annotation ["scriptable"]
* @param {widget_t*} widget slide_indicator对象。
* @param {uint32_t} value 当前项的序号。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t slide_indicator_set_value(widget_t* widget, uint32_t value);
/**
* @method slide_indicator_set_max
* 设置指示器的数量。
* @annotation ["scriptable"]
* @param {widget_t*} widget slide_indicator对象。
* @param {uint32_t} max 数量。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t slide_indicator_set_max(widget_t* widget, uint32_t max);
/**
* @method slide_indicator_set_default_paint
* 设置指示器的默认绘制类型。
* @annotation ["scriptable"]
* @param {widget_t*} widget slide_indicator对象。
* @param {indicator_default_paint_t} default_paint 默认绘制类型。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t slide_indicator_set_default_paint(widget_t* widget, indicator_default_paint_t default_paint);
/**
* @method slide_indicator_set_auto_hide
* 设置指示器是否自动隐藏。
* @annotation ["scriptable"]
* @param {widget_t*} widget slide_indicator对象。
* @param {uint16_t} auto_hide 0表示禁止，非0表示无操作后延迟多久隐藏。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t slide_indicator_set_auto_hide(widget_t* widget, uint16_t auto_hide);
/**
* @method slide_indicator_set_margin
* 设置指示器的边距(默认为10像素)。
* @annotation ["scriptable"]
* @param {widget_t*} widget slide_indicator对象。
* @param {int32_t} margin 指示器的边距。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t slide_indicator_set_margin(widget_t* widget, int32_t margin);
/**
* @method slide_indicator_set_spacing
* 设置指示器的间距(指示器有弧度时为角度值，否则为直线间距)。
* @annotation ["scriptable"]
* @param {widget_t*} widget slide_indicator对象。
* @param {float_t} spacing 指示器的间距。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t slide_indicator_set_spacing(widget_t* widget, float_t spacing);
/**
* @method slide_indicator_set_size
* 设置指示器的大小(默认为8)。
* @annotation ["scriptable"]
* @param {widget_t*} widget slide_indicator对象。
* @param {uint32_t} size 指示器的大小。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t slide_indicator_set_size(widget_t* widget, uint32_t size);
/**
* @method slide_indicator_set_anchor
* 设置旋转锚点。
* @annotation ["scriptable"]
* @param {widget_t*} widget slide_indicator对象。
* @param {const char*} anchor_x 锚点坐标x。(后面加上px为像素点，不加px为相对百分比坐标)
* @param {const char*} anchor_y 锚点坐标y。(后面加上px为像素点，不加px为相对百分比坐标)
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t slide_indicator_set_anchor(widget_t* widget, const char* anchor_x, const char* anchor_y);
/**
* @method slide_indicator_set_indicated_target
* 设置指示器指示的目标。
* @annotation ["scriptable"]
* @param {widget_t*} widget slide_indicator对象。
* @param {const char*} target_name 指示器指示的目标控件的名称
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t slide_indicator_set_indicated_target(widget_t* widget, const char* target_name);
/**
* @method slide_indicator_set_transition
* 设置是否启用过渡效果。
* @annotation ["scriptable"]
* @param {widget_t*} widget slide_indicator对象。
* @param {bool_t} transition 是否启用过渡效果
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t slide_indicator_set_transition(widget_t* widget, bool_t transition);
#define SLIDE_INDICATOR(widget) ((slide_indicator_t*)(slide_indicator_cast(WIDGET(widget))))
#define SLIDE_INDICATOR_PROP_DEFAULT_PAINT "default_paint"
#define SLIDE_INDICATOR_PROP_AUTO_HIDE "auto_hide"
#define SLIDE_INDICATOR_PROP_INDICATED_TARGET "indicated_target"
#define SLIDE_INDICATOR_PROP_SIZE "size"
#define SLIDE_INDICATOR_PROP_transition "transition"
/*public for subclass and runtime type check*/
TK_EXTERN_VTABLE(slide_indicator_linear);
TK_EXTERN_VTABLE(slide_indicator_arc);
END_C_DECLS
#endif /*TK_SLIDE_INDICATOR_H*/
|
0 |
repos/awtk/src/ext_widgets
|
repos/awtk/src/ext_widgets/slide_view/slide_view.c
|
/**
* File: slide_view.h
* Author: AWTK Develop Team
* Brief: slide_view
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-06-05 Li XianJing <[email protected]> created
*
*/
#include "tkc/mem.h"
#include "tkc/utils.h"
#include "base/timer.h"
#include "tkc/easing.h"
#include "slide_view/slide_view.h"
#include "widgets/default_focused_child.inc"
#include "widget_animators/widget_animator_scroll.h"
static ret_t slide_view_save_target(widget_t* widget);
static ret_t slide_view_restore_target(widget_t* widget);
static ret_t slide_view_set_active_no_animate_impl(widget_t* widget, uint32_t active, bool_t force);
static ret_t slide_view_set_active_no_animate(widget_t* widget, uint32_t active);
static bool_t anim_hint_is_overlap(slide_view_t* slide_view) {
return tk_str_eq(slide_view->anim_hint, "overlap") ||
tk_str_eq(slide_view->anim_hint, "overlap_with_alpha");
}
static bool_t anim_hint_is_overlap_with_alpha(slide_view_t* slide_view) {
return tk_str_eq(slide_view->anim_hint, "overlap_with_alpha");
}
static bool_t slide_view_is_loopable(slide_view_t* slide_view) {
return slide_view->auto_play || slide_view->loop;
}
static ret_t slide_view_set_xoffset(slide_view_t* slide_view, int32_t xoffset) {
offset_change_event_t evt;
if (slide_view->xoffset != xoffset) {
offset_change_event_init(&evt, EVT_PAGE_CHANGING, WIDGET(slide_view), 0, (float_t)xoffset);
slide_view->xoffset = xoffset;
widget_dispatch(WIDGET(slide_view), (event_t*)&evt);
}
return RET_OK;
}
static ret_t slide_view_set_yoffset(slide_view_t* slide_view, int32_t yoffset) {
offset_change_event_t evt;
if (slide_view->yoffset != yoffset) {
offset_change_event_init(&evt, EVT_PAGE_CHANGING, WIDGET(slide_view), 0, (float_t)yoffset);
slide_view->yoffset = yoffset;
widget_dispatch(WIDGET(slide_view), (event_t*)&evt);
}
return RET_OK;
}
static ret_t canvas_set_clip_rect_with_offset(canvas_t* c, rect_t* r, rect_t* save_r, int32_t ox,
int32_t oy) {
rect_t rr = *r;
vgcanvas_t* vg = canvas_get_vgcanvas(c);
rr.x += ox;
rr.y += oy;
rr = rect_intersect(&rr, save_r);
vgcanvas_clip_rect(vg, rr.x, rr.y, rr.w, rr.h);
return canvas_set_clip_rect(c, &rr);
}
widget_t* slide_view_get_prev(slide_view_t* slide_view) {
widget_t* widget = WIDGET(slide_view);
uint32_t active = slide_view->active;
uint32_t nr = widget_count_children(widget);
if (active > 0) {
return widget_get_child(widget, active - 1);
} else if (slide_view_is_loopable(slide_view) && nr > 1) {
return widget_get_child(widget, nr - 1);
} else {
return NULL;
}
}
widget_t* slide_view_get_next(slide_view_t* slide_view) {
widget_t* widget = WIDGET(slide_view);
uint32_t active = slide_view->active;
uint32_t nr = widget_count_children(widget);
if ((active + 1) < nr) {
return widget_get_child(widget, active + 1);
} else if (slide_view_is_loopable(slide_view) && nr > 1) {
return widget_get_child(widget, 0);
} else {
return NULL;
}
}
ret_t slide_view_activate_prev(slide_view_t* slide_view) {
widget_t* widget = WIDGET(slide_view);
uint32_t active = slide_view->active;
uint32_t nr = widget_count_children(widget);
if (active > 0) {
return slide_view_set_active(widget, active - 1);
} else if (slide_view_is_loopable(slide_view) && nr > 1) {
return slide_view_set_active(widget, nr - 1);
} else {
return RET_FAIL;
}
}
ret_t slide_view_activate_next(slide_view_t* slide_view) {
widget_t* widget = WIDGET(slide_view);
uint32_t active = slide_view->active;
uint32_t nr = widget_count_children(widget);
if ((active + 1) < nr) {
return slide_view_set_active(widget, active + 1);
} else if (slide_view_is_loopable(slide_view) && nr > 1) {
return slide_view_set_active(widget, 0);
} else {
return RET_FAIL;
}
}
static ret_t slide_view_on_paint_self(widget_t* widget, canvas_t* c) {
(void)widget;
(void)c;
return RET_OK;
}
static ret_t slide_view_on_pointer_down(slide_view_t* slide_view, pointer_event_t* e) {
velocity_t* v = &(slide_view->velocity);
velocity_reset(v);
slide_view->down.x = e->x;
slide_view->down.y = e->y;
velocity_update(v, e->e.time, e->x, e->y);
return RET_OK;
}
static ret_t slide_view_on_scroll_done(void* ctx, event_t* e) {
uint32_t active;
widget_t* widget = WIDGET(ctx);
slide_view_t* slide_view = SLIDE_VIEW(ctx);
return_value_if_fail(widget != NULL && slide_view != NULL, RET_BAD_PARAMS);
if (slide_view->xoffset < 0 || slide_view->yoffset < 0) {
active = widget_index_of(slide_view->prev);
if (slide_view->check_last) {
active = active == slide_view->last_active ? active : slide_view->last_active;
}
if (slide_view->remove_when_anim_done) {
widget_destroy(slide_view->next);
slide_view_set_active_no_animate_impl(widget, active, TRUE);
} else {
slide_view_set_active_no_animate(widget, active);
}
} else if (slide_view->xoffset > 0 || slide_view->yoffset > 0) {
active = widget_index_of(slide_view->next);
if (slide_view->check_last) {
active = active == slide_view->last_active ? active : slide_view->last_active;
}
if (slide_view->remove_when_anim_done) {
/* because of array, so do not need move item */
widget_destroy(slide_view->prev);
} else {
slide_view_set_active_no_animate(widget, active);
}
}
slide_view->xoffset = 0;
slide_view->yoffset = 0;
slide_view->animating = FALSE;
slide_view->check_last = FALSE;
slide_view->remove_when_anim_done = FALSE;
slide_view->prev = NULL;
slide_view->next = NULL;
widget->dirty = FALSE;
widget_invalidate(widget, NULL);
return RET_OK;
}
static ret_t slide_view_animate_to(slide_view_t* slide_view, int32_t xoffset, int32_t yoffset,
int32_t xoffset_end, int32_t yoffset_end) {
widget_t* widget = WIDGET(slide_view);
#ifndef WITHOUT_WIDGET_ANIMATORS
widget_animator_t* a = NULL;
a = widget_animator_scroll_create(widget, slide_view->animating_time, 0, EASING_SIN_INOUT);
return_value_if_fail(a != NULL, RET_OOM);
widget_animator_scroll_set_params(a, xoffset, yoffset, xoffset_end, yoffset_end);
widget_animator_on(a, EVT_ANIM_END, slide_view_on_scroll_done, slide_view);
widget_animator_start(a);
slide_view->animating = TRUE;
#else
slide_view->dragged = FALSE;
slide_view->animating = FALSE;
slide_view->xoffset = xoffset_end;
slide_view->yoffset = yoffset_end;
slide_view_on_scroll_done(widget, NULL);
#endif /*WITHOUT_WIDGET_ANIMATORS*/
return RET_OK;
}
static ret_t slide_view_on_pointer_up(slide_view_t* slide_view, pointer_event_t* e) {
int32_t xoffset_end = 0;
int32_t yoffset_end = 0;
int32_t xoffset = slide_view->xoffset;
int32_t yoffset = slide_view->yoffset;
uint32_t v_threshhold = 100;
widget_t* widget = WIDGET(slide_view);
velocity_t* v = &(slide_view->velocity);
velocity_update(v, e->e.time, e->x, e->y);
if (slide_view->vertical) {
int32_t h = widget->h;
int32_t yv = tk_abs(v->yv);
bool_t rollback = (yv < v_threshhold) && (tk_abs(yoffset) < h / 2);
if (yoffset > 0 && slide_view_get_next(slide_view) == NULL) {
rollback = TRUE;
} else if (yoffset < 0 && slide_view_get_prev(slide_view) == NULL) {
rollback = TRUE;
}
if (tk_abs(yoffset) < slide_view->drag_threshold) {
rollback = TRUE;
}
if (!rollback) {
yoffset_end = yoffset > 0 ? h : -h;
}
} else {
int32_t w = widget->w;
int32_t xv = tk_abs(v->xv);
bool_t rollback = (xv < v_threshhold) && (tk_abs(xoffset) < w / 2);
if (xoffset > 0 && slide_view_get_next(slide_view) == NULL) {
rollback = TRUE;
} else if (xoffset < 0 && slide_view_get_prev(slide_view) == NULL) {
rollback = TRUE;
}
if (tk_abs(xoffset) < slide_view->drag_threshold) {
rollback = TRUE;
}
if (!rollback) {
xoffset_end = xoffset > 0 ? w : -w;
}
}
return slide_view_animate_to(slide_view, xoffset, yoffset, xoffset_end, yoffset_end);
}
static ret_t slide_view_on_pointer_move(slide_view_t* slide_view, pointer_event_t* e) {
velocity_t* v = &(slide_view->velocity);
velocity_update(v, e->e.time, e->x, e->y);
if (slide_view->vertical) {
slide_view_set_xoffset(slide_view, 0);
slide_view_set_yoffset(slide_view, slide_view->down.y - e->y);
} else {
slide_view_set_yoffset(slide_view, 0);
slide_view_set_xoffset(slide_view, slide_view->down.x - e->x);
}
return RET_OK;
}
static ret_t slide_view_on_event(widget_t* widget, event_t* e) {
ret_t ret = RET_OK;
uint16_t type = e->type;
slide_view_t* slide_view = SLIDE_VIEW(widget);
return_value_if_fail(widget != NULL && slide_view != NULL, RET_BAD_PARAMS);
if (slide_view->animating || type == EVT_PAGE_CHANGING) {
return RET_OK;
}
switch (type) {
case EVT_BLUR: {
slide_view_save_target(widget);
break;
}
case EVT_POINTER_DOWN: {
slide_view->pressed = TRUE;
widget_grab(widget->parent, widget);
slide_view_on_pointer_down(slide_view, (pointer_event_t*)e);
slide_view->prev = slide_view_get_prev(slide_view);
slide_view->next = slide_view_get_next(slide_view);
break;
}
case EVT_POINTER_UP: {
if (slide_view->pressed) {
if (slide_view->dragged) {
slide_view->check_last = FALSE;
slide_view_on_pointer_up(slide_view, (pointer_event_t*)e);
}
slide_view->dragged = FALSE;
slide_view->pressed = FALSE;
widget_ungrab(widget->parent, widget);
}
break;
}
case EVT_POINTER_DOWN_ABORT: {
if (slide_view->pressed) {
slide_view->xoffset = 0;
slide_view->yoffset = 0;
slide_view->pressed = FALSE;
slide_view->dragged = FALSE;
widget_ungrab(widget->parent, widget);
}
break;
}
case EVT_POINTER_MOVE: {
pointer_event_t* evt = (pointer_event_t*)e;
if (slide_view->dragged) {
slide_view_on_pointer_move(slide_view, evt);
widget_invalidate(widget, NULL);
} else if (evt->pressed && slide_view->pressed) {
int32_t delta = 0;
if (slide_view->vertical) {
delta = evt->y - slide_view->down.y;
} else {
delta = evt->x - slide_view->down.x;
}
if (tk_abs(delta) > slide_view->drag_threshold) {
pointer_event_t abort;
pointer_event_init(&abort, EVT_POINTER_DOWN_ABORT, widget, evt->x, evt->y);
widget_dispatch_event_to_target_recursive(widget, (event_t*)(&abort));
slide_view->dragged = TRUE;
slide_view_on_pointer_move(slide_view, evt);
widget_invalidate(widget, NULL);
}
}
break;
}
case EVT_KEY_UP: {
key_event_t* evt = (key_event_t*)e;
if (slide_view->vertical) {
if (evt->key == TK_KEY_UP || evt->key == TK_KEY_PAGEUP) {
ret = RET_STOP;
slide_view_activate_prev(slide_view);
} else if (evt->key == TK_KEY_DOWN || evt->key == TK_KEY_PAGEDOWN) {
ret = RET_STOP;
slide_view_activate_next(slide_view);
}
} else {
if (evt->key == TK_KEY_LEFT) {
ret = RET_STOP;
slide_view_activate_prev(slide_view);
} else if (evt->key == TK_KEY_RIGHT) {
ret = RET_STOP;
slide_view_activate_next(slide_view);
}
}
}
default:
break;
}
if (ret == RET_OK) {
if (slide_view->dragged) {
ret = RET_STOP;
}
}
return ret;
}
static widget_t* slide_view_find_target(widget_t* widget, xy_t x, xy_t y) {
slide_view_t* slide_view = SLIDE_VIEW(widget);
return_value_if_fail(widget != NULL && slide_view != NULL && widget->children != NULL, NULL);
if (slide_view->xoffset || slide_view->yoffset || slide_view->active >= widget->children->size) {
return NULL;
}
return widget_get_child(widget, slide_view->active);
}
static uint32_t slide_view_get_page_max_number(widget_t* widget) {
return_value_if_fail(widget != NULL, 0);
return widget_count_children(widget);
}
static ret_t slide_view_get_prop(widget_t* widget, const char* name, value_t* v) {
slide_view_t* slide_view = SLIDE_VIEW(widget);
ENSURE(slide_view);
return_value_if_fail(widget != NULL && name != NULL && v != NULL, RET_BAD_PARAMS);
if (tk_str_eq(name, WIDGET_PROP_VALUE) || tk_str_eq(name, WIDGET_PROP_ACTIVE) ||
tk_str_eq(name, WIDGET_PROP_CURR_PAGE)) {
value_set_int(v, slide_view->active);
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_VERTICAL)) {
value_set_bool(v, slide_view->vertical);
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_ANIM_HINT)) {
value_set_str(v, slide_view->anim_hint);
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_LOOP)) {
value_set_bool(v, slide_view->loop);
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_AUTO_PLAY)) {
value_set_int(v, slide_view->auto_play);
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_XOFFSET)) {
value_set_int(v, slide_view->xoffset);
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_YOFFSET)) {
value_set_int(v, slide_view->yoffset);
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_PAGE_MAX_NUMBER)) {
value_set_uint32(v, slide_view_get_page_max_number(widget));
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_DRAG_THRESHOLD)) {
value_set_uint32(v, slide_view->drag_threshold);
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_ANIMATING_TIME)) {
value_set_uint32(v, slide_view->animating_time);
return RET_OK;
}
return RET_NOT_FOUND;
}
static ret_t slide_view_set_prop(widget_t* widget, const char* name, const value_t* v) {
slide_view_t* slide_view = SLIDE_VIEW(widget);
ENSURE(slide_view);
return_value_if_fail(widget != NULL && name != NULL && v != NULL, RET_BAD_PARAMS);
if (tk_str_eq(name, WIDGET_PROP_VALUE) || tk_str_eq(name, WIDGET_PROP_ACTIVE) ||
tk_str_eq(name, WIDGET_PROP_CURR_PAGE)) {
return slide_view_set_active(widget, value_int(v));
} else if (tk_str_eq(name, WIDGET_PROP_VERTICAL)) {
return slide_view_set_vertical(widget, value_bool(v));
} else if (tk_str_eq(name, WIDGET_PROP_ANIM_HINT)) {
return slide_view_set_anim_hint(widget, value_str(v));
} else if (tk_str_eq(name, WIDGET_PROP_LOOP)) {
return slide_view_set_loop(widget, value_bool(v));
} else if (tk_str_eq(name, WIDGET_PROP_XOFFSET)) {
slide_view_set_xoffset(slide_view, value_int(v));
widget_invalidate(widget, NULL);
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_AUTO_PLAY)) {
return slide_view_set_auto_play(widget, value_int(v));
} else if (tk_str_eq(name, WIDGET_PROP_YOFFSET)) {
slide_view_set_yoffset(slide_view, value_int(v));
widget_invalidate(widget, NULL);
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_DRAG_THRESHOLD)) {
slide_view_set_drag_threshold(widget, value_uint32(v));
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_ANIMATING_TIME)) {
slide_view_set_animating_time(widget, value_uint32(v));
return RET_OK;
}
return RET_NOT_FOUND;
}
static ret_t slide_view_paint_prev_next_v_translate(slide_view_t* slide_view, canvas_t* c,
rect_t* save_r, widget_t* prev, widget_t* next,
int32_t yoffset) {
rect_t r;
int32_t ox = c->ox;
int32_t oy = c->oy;
xy_t w = WIDGET(slide_view)->w;
xy_t h = WIDGET(slide_view)->h;
int32_t r_yoffset = h - yoffset;
if (prev != NULL) {
if (yoffset > h) {
r = rect_init(0, yoffset - h, w, h + h - yoffset);
} else {
r = rect_init(0, 0, w, yoffset);
}
if (r.h > 0) {
canvas_save(c);
canvas_translate(c, 0, -r_yoffset);
canvas_set_clip_rect_with_offset(c, &r, save_r, ox, oy);
widget_paint(prev, c);
canvas_untranslate(c, 0, -r_yoffset);
canvas_restore(c);
}
}
if (next != NULL) {
if (r_yoffset > h) {
r = rect_init(0, 0, w, h + h - r_yoffset);
} else {
r = rect_init(0, yoffset, w, r_yoffset);
}
if (r.h > 0) {
canvas_save(c);
canvas_translate(c, 0, yoffset);
canvas_set_clip_rect_with_offset(c, &r, save_r, ox, oy);
widget_paint(next, c);
canvas_untranslate(c, 0, yoffset);
canvas_restore(c);
}
}
return RET_OK;
}
static ret_t slide_view_set_global_alpha(slide_view_t* slide_view, canvas_t* c, int32_t offset,
int32_t total) {
if (anim_hint_is_overlap_with_alpha(slide_view)) {
uint8_t a = 0xff - (0xff * offset) / total;
canvas_set_global_alpha(c, a);
}
return RET_OK;
}
static ret_t slide_view_paint_prev_next_v_overlap(slide_view_t* slide_view, canvas_t* c,
rect_t* save_r, widget_t* prev, widget_t* next,
int32_t yoffset) {
rect_t r;
int32_t ox = c->ox;
int32_t oy = c->oy;
xy_t w = WIDGET(slide_view)->w;
xy_t h = WIDGET(slide_view)->h;
int32_t r_yoffset = h - yoffset;
if (next != NULL && r_yoffset >= 0) {
canvas_save(c);
if (r_yoffset > h) {
widget_paint(next, c);
} else {
slide_view_set_global_alpha(slide_view, c, yoffset, h);
widget_paint(next, c);
canvas_set_global_alpha(c, 0xff);
}
canvas_restore(c);
}
if (prev != NULL) {
if (yoffset > h) {
r_yoffset = 0;
yoffset = h;
}
r = rect_init(0, 0, w, yoffset);
if (r.h > 0) {
canvas_save(c);
canvas_translate(c, 0, -r_yoffset);
canvas_set_clip_rect_with_offset(c, &r, save_r, ox, oy);
widget_paint(prev, c);
canvas_untranslate(c, 0, -r_yoffset);
canvas_restore(c);
}
}
return RET_OK;
}
static ret_t slide_view_paint_children_v_gt(slide_view_t* slide_view, canvas_t* c, rect_t* save_r) {
int32_t yoffset = tk_abs(slide_view->yoffset);
widget_t* prev = slide_view->prev;
widget_t* active = widget_get_child(WIDGET(slide_view), slide_view->active);
if (anim_hint_is_overlap(slide_view)) {
return slide_view_paint_prev_next_v_overlap(slide_view, c, save_r, prev, active, yoffset);
} else {
return slide_view_paint_prev_next_v_translate(slide_view, c, save_r, prev, active, yoffset);
}
}
static ret_t slide_view_paint_children_v_lt(slide_view_t* slide_view, canvas_t* c, rect_t* save_r) {
widget_t* next = slide_view->next;
int32_t yoffset = WIDGET(slide_view)->h - tk_abs(slide_view->yoffset);
widget_t* active = widget_get_child(WIDGET(slide_view), slide_view->active);
if (anim_hint_is_overlap(slide_view)) {
return slide_view_paint_prev_next_v_overlap(slide_view, c, save_r, active, next, yoffset);
} else {
return slide_view_paint_prev_next_v_translate(slide_view, c, save_r, active, next, yoffset);
}
}
static ret_t slide_view_paint_prev_next_h_translate(slide_view_t* slide_view, canvas_t* c,
rect_t* save_r, widget_t* prev, widget_t* next,
int32_t xoffset) {
rect_t r;
int32_t ox = c->ox;
int32_t oy = c->oy;
xy_t w = WIDGET(slide_view)->w;
xy_t h = WIDGET(slide_view)->h;
int32_t r_xoffset = w - xoffset;
if (prev != NULL) {
if (xoffset > w) {
r = rect_init(xoffset - w, 0, w + w - xoffset, h);
} else {
r = rect_init(0, 0, xoffset, h);
}
if (r.w > 0) {
canvas_save(c);
canvas_translate(c, -r_xoffset, 0);
canvas_set_clip_rect_with_offset(c, &r, save_r, ox, oy);
widget_paint(prev, c);
canvas_untranslate(c, -r_xoffset, 0);
canvas_restore(c);
}
}
if (next != NULL) {
if (r_xoffset > w) {
r = rect_init(0, 0, w + w - r_xoffset, h);
} else {
r = rect_init(xoffset, 0, r_xoffset, h);
}
if (r.w > 0) {
canvas_save(c);
canvas_translate(c, xoffset, 0);
canvas_set_clip_rect_with_offset(c, &r, save_r, ox, oy);
widget_paint(next, c);
canvas_untranslate(c, xoffset, 0);
canvas_restore(c);
}
}
return RET_OK;
}
static ret_t slide_view_paint_prev_next_h_overlap(slide_view_t* slide_view, canvas_t* c,
rect_t* save_r, widget_t* prev, widget_t* next,
int32_t xoffset) {
rect_t r;
int32_t ox = c->ox;
int32_t oy = c->oy;
xy_t w = WIDGET(slide_view)->w;
xy_t h = WIDGET(slide_view)->h;
int32_t r_xoffset = w - xoffset;
if (prev != NULL && xoffset >= 0) {
canvas_save(c);
if (xoffset > w) {
widget_paint(prev, c);
} else {
slide_view_set_global_alpha(slide_view, c, r_xoffset, w);
widget_paint(prev, c);
canvas_set_global_alpha(c, 0xff);
}
canvas_restore(c);
}
if (next != NULL) {
if (r_xoffset > w) {
xoffset = 0;
r_xoffset = w;
}
r = rect_init(xoffset, 0, r_xoffset, h);
if (r.w > 0) {
canvas_save(c);
canvas_translate(c, xoffset, 0);
canvas_set_clip_rect_with_offset(c, &r, save_r, ox, oy);
widget_paint(next, c);
canvas_untranslate(c, xoffset, 0);
canvas_restore(c);
}
}
return RET_OK;
}
static ret_t slide_view_paint_children_h_gt(slide_view_t* slide_view, canvas_t* c, rect_t* save_r) {
int32_t xoffset = tk_abs(slide_view->xoffset);
widget_t* prev = slide_view->prev;
widget_t* active = widget_get_child(WIDGET(slide_view), slide_view->active);
if (anim_hint_is_overlap(slide_view)) {
return slide_view_paint_prev_next_h_overlap(slide_view, c, save_r, prev, active, xoffset);
} else {
return slide_view_paint_prev_next_h_translate(slide_view, c, save_r, prev, active, xoffset);
}
}
static ret_t slide_view_paint_children_h_lt(slide_view_t* slide_view, canvas_t* c, rect_t* save_r) {
widget_t* next = slide_view->next;
int32_t xoffset = WIDGET(slide_view)->w - tk_abs(slide_view->xoffset);
widget_t* active = widget_get_child(WIDGET(slide_view), slide_view->active);
if (anim_hint_is_overlap(slide_view)) {
return slide_view_paint_prev_next_h_overlap(slide_view, c, save_r, active, next, xoffset);
} else {
return slide_view_paint_prev_next_h_translate(slide_view, c, save_r, active, next, xoffset);
}
}
static ret_t slide_view_on_paint_children(widget_t* widget, canvas_t* c) {
rect_t save_r;
widget_t* active = NULL;
uint8_t save_a = c->lcd->global_alpha;
vgcanvas_t* vg = canvas_get_vgcanvas(c);
slide_view_t* slide_view = SLIDE_VIEW(widget);
return_value_if_fail(widget != NULL && slide_view != NULL && widget->children != NULL,
RET_BAD_PARAMS);
if (slide_view->active >= widget->children->size) {
return RET_OK;
}
active = widget_get_child(widget, slide_view->active);
return_value_if_fail(active != NULL, RET_BAD_PARAMS);
canvas_get_clip_rect(c, &save_r);
if (slide_view->vertical) {
if (slide_view->yoffset < 0) {
slide_view_paint_children_v_gt(slide_view, c, &save_r);
} else if (slide_view->yoffset > 0) {
slide_view_paint_children_v_lt(slide_view, c, &save_r);
} else {
widget_paint(active, c);
}
} else {
if (slide_view->xoffset < 0) {
slide_view_paint_children_h_gt(slide_view, c, &save_r);
} else if (slide_view->xoffset > 0) {
slide_view_paint_children_h_lt(slide_view, c, &save_r);
} else {
widget_paint(active, c);
}
}
vgcanvas_clip_rect(vg, save_r.x, save_r.y, save_r.w, save_r.h);
canvas_set_clip_rect(c, &save_r);
canvas_set_global_alpha(c, save_a);
return RET_OK;
}
static ret_t slide_view_on_destroy(widget_t* widget) {
slide_view_t* slide_view = SLIDE_VIEW(widget);
return_value_if_fail(widget != NULL && slide_view != NULL, RET_BAD_PARAMS);
if (slide_view->init_idle_id != TK_INVALID_ID) {
idle_remove(slide_view->init_idle_id);
}
if (slide_view->focused_idle_id != TK_INVALID_ID) {
idle_remove(slide_view->focused_idle_id);
}
if (slide_view->move_idle_id != TK_INVALID_ID) {
idle_remove(slide_view->move_idle_id);
}
if (slide_view->timer_id) {
timer_remove(slide_view->timer_id);
slide_view->timer_id = 0;
}
TKMEM_FREE(slide_view->anim_hint);
str_reset(&(slide_view->str_target));
return RET_OK;
}
static ret_t slide_view_get_only_active_children(widget_t* widget, darray_t* all_focusable) {
widget_t* child = widget_find_target(widget, 1, 1);
return_value_if_fail(widget != NULL && all_focusable != NULL, RET_BAD_PARAMS);
widget_foreach(child, widget_on_visit_focusable, all_focusable);
return RET_SKIP;
}
static const char* s_slide_view_properties[] = {WIDGET_PROP_VALUE, WIDGET_PROP_LOOP,
WIDGET_PROP_VERTICAL, WIDGET_PROP_ANIM_HINT,
WIDGET_PROP_AUTO_PLAY, NULL};
TK_DECL_VTABLE(slide_view) = {.size = sizeof(slide_view_t),
.inputable = TRUE,
.type = WIDGET_TYPE_SLIDE_VIEW,
.get_only_active_children = slide_view_get_only_active_children,
.clone_properties = s_slide_view_properties,
.persistent_properties = s_slide_view_properties,
.get_parent_vt = TK_GET_PARENT_VTABLE(widget),
.create = slide_view_create,
.on_event = slide_view_on_event,
.get_prop = slide_view_get_prop,
.set_prop = slide_view_set_prop,
.find_target = slide_view_find_target,
.on_paint_children = slide_view_on_paint_children,
.on_paint_self = slide_view_on_paint_self,
.on_destroy = slide_view_on_destroy};
static ret_t slide_view_on_idle_init_save_target(const idle_info_t* idle) {
slide_view_t* slide_view = NULL;
return_value_if_fail(idle != NULL, RET_BAD_PARAMS);
slide_view = SLIDE_VIEW(idle->ctx);
ENSURE(slide_view);
if (slide_view->widget.focused) {
slide_view_restore_target(WIDGET(slide_view));
slide_view->init_idle_id = TK_INVALID_ID;
}
return RET_OK;
}
static ret_t slide_view_on_idle_move(const idle_info_t* idle) {
slide_view_t* slide_view = NULL;
return_value_if_fail(idle != NULL, RET_BAD_PARAMS);
slide_view = SLIDE_VIEW(idle->ctx);
ENSURE(slide_view);
if (slide_view->dragged) {
widget_invalidate(WIDGET(slide_view), NULL);
}
return RET_REPEAT;
}
static bool_t slide_view_target_is_slide_view(widget_t* target) {
return target->vt != NULL && tk_str_eq(target->vt->type, WIDGET_TYPE_SLIDE_VIEW);
}
static ret_t slide_view_save_target(widget_t* widget) {
widget_t* target = NULL;
widget_t* active_view = NULL;
slide_view_t* slide_view = SLIDE_VIEW(widget);
return_value_if_fail(slide_view != NULL && widget->children != NULL, RET_BAD_PARAMS);
if (slide_view->active < widget->children->size) {
active_view = widget_get_child(widget, slide_view->active);
}
if (active_view != NULL) {
target = active_view;
while (target->target != NULL) {
target = target->target;
}
default_focused_child_set_save_target(widget, active_view, slide_view_target_is_slide_view);
}
return RET_OK;
}
static ret_t slide_view_on_idle_set_target_focused(const idle_info_t* idle) {
slide_view_t* slide_view = NULL;
return_value_if_fail(idle != NULL, RET_BAD_PARAMS);
slide_view = SLIDE_VIEW(idle->ctx);
ENSURE(slide_view);
default_focused_child_set_target_focused(&(slide_view->str_target), WIDGET(slide_view));
slide_view->focused_idle_id = TK_INVALID_ID;
return RET_OK;
}
static ret_t slide_view_restore_target(widget_t* widget) {
widget_t* target = NULL;
widget_t* active_view = NULL;
slide_view_t* slide_view = SLIDE_VIEW(widget);
return_value_if_fail(slide_view != NULL && widget->children != NULL, RET_BAD_PARAMS);
if (slide_view->active < widget->children->size) {
active_view = widget_get_child(widget, slide_view->active);
}
if (active_view != NULL) {
target = default_focused_child_get_save_target(widget, active_view);
if (target == NULL || target->parent == NULL || target == widget) {
target = active_view;
}
if (slide_view_target_is_slide_view(target)) {
slide_view_restore_target(target);
} else {
default_focused_child_save_target_to_string(&(slide_view->str_target), target, widget);
if (slide_view->focused_idle_id == TK_INVALID_ID) {
slide_view->focused_idle_id = idle_add(slide_view_on_idle_set_target_focused, widget);
}
}
}
return RET_OK;
}
static ret_t slide_view_set_active_no_animate_impl(widget_t* widget, uint32_t active,
bool_t force) {
slide_view_t* slide_view = SLIDE_VIEW(widget);
return_value_if_fail(slide_view != NULL, RET_BAD_PARAMS);
if ((force || slide_view->active != active) && widget->children != NULL) {
value_change_event_t evt;
slide_view_save_target(widget);
value_change_event_init(&evt, EVT_VALUE_WILL_CHANGE, widget);
value_set_uint32(&(evt.old_value), slide_view->active);
value_set_uint32(&(evt.new_value), active);
if (widget_dispatch(widget, (event_t*)&evt) != RET_STOP) {
slide_view->active = active;
slide_view->last_active = slide_view->active;
evt.e.type = EVT_VALUE_CHANGED;
widget_dispatch(widget, (event_t*)&evt);
widget_dispatch_simple_event(widget, EVT_PAGE_CHANGED);
widget_invalidate(widget, NULL);
}
slide_view_restore_target(widget);
} else {
slide_view->active = active;
slide_view->last_active = slide_view->active;
}
return RET_OK;
}
static ret_t slide_view_set_active_no_animate(widget_t* widget, uint32_t active) {
return slide_view_set_active_no_animate_impl(widget, active, FALSE);
}
static ret_t slide_view_set_active_animate(widget_t* widget, uint32_t active) {
int32_t xoffset_end = 0;
int32_t yoffset_end = 0;
uint32_t old_active = 0;
slide_view_t* slide_view = SLIDE_VIEW(widget);
return_value_if_fail(slide_view != NULL, RET_BAD_PARAMS);
if (slide_view->animating) {
log_debug("slide_view is animating, so slide_view is busy!\r\n");
log_debug("When the animation is played, the last active takes effect!\r\n");
slide_view->check_last = TRUE;
slide_view->last_active = active;
return RET_OK;
}
old_active = slide_view->active;
if ((old_active < active &&
!(slide_view->loop && old_active == 0 && active == widget->children->size)) ||
(slide_view->loop && active == 0 && old_active == widget->children->size)) {
slide_view->prev = widget_get_child(widget, old_active);
slide_view->next = widget_get_child(widget, active);
xoffset_end = slide_view->vertical ? 0 : widget->w;
yoffset_end = slide_view->vertical ? widget->h : 0;
} else {
slide_view->next = widget_get_child(widget, old_active);
slide_view->prev = widget_get_child(widget, active);
xoffset_end = slide_view->vertical ? 0 : -widget->w;
yoffset_end = slide_view->vertical ? -widget->h : 0;
}
return slide_view_animate_to(slide_view, 0, 0, xoffset_end, yoffset_end);
}
ret_t slide_view_set_active_ex(widget_t* widget, uint32_t index, bool_t animate) {
slide_view_t* slide_view = SLIDE_VIEW(widget);
ENSURE(slide_view);
widget_t* win = widget_get_window(widget);
if (widget_count_children(widget) < 2 || slide_view->active == index || !animate || win == NULL) {
return slide_view_set_active_no_animate(widget, index);
} else {
return slide_view_set_active_animate(widget, index);
}
}
ret_t slide_view_set_active(widget_t* widget, uint32_t active) {
return slide_view_set_active_ex(widget, active, TRUE);
}
ret_t slide_view_set_vertical(widget_t* widget, bool_t vertical) {
slide_view_t* slide_view = SLIDE_VIEW(widget);
return_value_if_fail(slide_view != NULL, RET_BAD_PARAMS);
slide_view->vertical = vertical;
widget_invalidate(widget, NULL);
return RET_OK;
}
ret_t slide_view_set_anim_hint(widget_t* widget, const char* anim_hint) {
slide_view_t* slide_view = SLIDE_VIEW(widget);
return_value_if_fail(slide_view != NULL, RET_BAD_PARAMS);
slide_view->anim_hint = tk_str_copy(slide_view->anim_hint, anim_hint);
return RET_OK;
}
ret_t slide_view_set_loop(widget_t* widget, bool_t loop) {
slide_view_t* slide_view = SLIDE_VIEW(widget);
return_value_if_fail(slide_view != NULL, RET_BAD_PARAMS);
slide_view->loop = loop;
return RET_OK;
}
ret_t slide_view_set_drag_threshold(widget_t* widget, uint32_t drag_threshold) {
slide_view_t* slide_view = SLIDE_VIEW(widget);
return_value_if_fail(slide_view != NULL, RET_BAD_PARAMS);
slide_view->drag_threshold = drag_threshold;
return RET_OK;
}
ret_t slide_view_set_animating_time(widget_t* widget, uint32_t animating_time) {
slide_view_t* slide_view = SLIDE_VIEW(widget);
return_value_if_fail(slide_view != NULL, RET_BAD_PARAMS);
slide_view->animating_time = animating_time;
return RET_OK;
}
widget_t* slide_view_create(widget_t* parent, xy_t x, xy_t y, wh_t w, wh_t h) {
widget_t* widget = widget_create(parent, TK_REF_VTABLE(slide_view), x, y, w, h);
slide_view_t* slide_view = SLIDE_VIEW(widget);
return_value_if_fail(slide_view != NULL, NULL);
slide_view->loop = FALSE;
slide_view->auto_play = 0;
slide_view->vertical = FALSE;
slide_view->drag_threshold = TK_DRAG_THRESHOLD;
slide_view->animating_time = TK_ANIMATING_TIME;
slide_view->check_last = FALSE;
str_init(&(slide_view->str_target), DEFAULT_FOCUSED_CHILD_SAVE_TARGET_TAG_LENGTH);
slide_view->init_idle_id = idle_add(slide_view_on_idle_init_save_target, widget);
slide_view->move_idle_id = idle_add(slide_view_on_idle_move, widget);
return widget;
}
static ret_t slide_view_on_timer_next(const timer_info_t* timer) {
int32_t xoffset_end = 0;
int32_t yoffset_end = 0;
widget_t* widget = WIDGET(timer->ctx);
slide_view_t* slide_view = SLIDE_VIEW(timer->ctx);
return_value_if_fail(slide_view != NULL, RET_REMOVE);
return_value_if_fail(!slide_view->animating, RET_REPEAT);
if (slide_view->vertical) {
yoffset_end = widget->h;
} else {
xoffset_end = widget->w;
}
slide_view->next = slide_view_get_next(slide_view);
slide_view_animate_to(slide_view, 0, 0, xoffset_end, yoffset_end);
return RET_REPEAT;
}
ret_t slide_view_set_auto_play(widget_t* widget, uint16_t auto_play) {
slide_view_t* slide_view = SLIDE_VIEW(widget);
return_value_if_fail(slide_view != NULL, RET_BAD_PARAMS);
slide_view->auto_play = auto_play;
if (slide_view->timer_id) {
timer_remove(slide_view->timer_id);
slide_view->timer_id = 0;
}
if (auto_play) {
slide_view->timer_id =
timer_add(slide_view_on_timer_next, slide_view, auto_play + slide_view->animating_time);
return slide_view->timer_id ? RET_OK : RET_OOM;
}
return RET_OK;
}
ret_t slide_view_remove_index(widget_t* widget, uint32_t index) {
ret_t ret = RET_FAIL;
int32_t remove_index = -1;
int32_t current_index = -1;
slide_view_t* slide_view = SLIDE_VIEW(widget);
return_value_if_fail(widget != NULL && slide_view != NULL && widget->children != NULL,
RET_BAD_PARAMS);
return_value_if_fail(widget->children->size > 0 && index < widget->children->size,
RET_BAD_PARAMS);
remove_index = (int32_t)index;
current_index = (int32_t)slide_view->active;
if (widget->children->size != 1 && remove_index == current_index) {
if (remove_index == widget->children->size - 1) {
current_index = slide_view->loop ? 0 : remove_index - 1;
} else {
current_index = remove_index + 1;
}
slide_view->remove_when_anim_done = TRUE;
ret = slide_view_set_active_animate(widget, current_index);
if (ret != RET_OK) {
slide_view->remove_when_anim_done = FALSE;
}
} else {
ret = remove_index < current_index ? slide_view_set_active_no_animate(widget, current_index - 1)
: RET_OK;
if (ret == RET_OK) {
ret = widget_destroy(widget_get_child(widget, remove_index));
}
}
return ret;
}
widget_t* slide_view_cast(widget_t* widget) {
return_value_if_fail(WIDGET_IS_INSTANCE_OF(widget, slide_view), NULL);
return widget;
}
|
0 |
repos/awtk/src/ext_widgets
|
repos/awtk/src/ext_widgets/slide_view/slide_indicator.c
|
/**
* File: slide_indicator.h
* Author: AWTK Develop Team
* Brief: slide_indicator
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2019-05-29 Xu ChaoZe <[email protected]> created
*
*/
#include "tkc/mem.h"
#include "tkc/utils.h"
#include "base/timer.h"
#include "base/layout.h"
#include "base/enums.h"
#include "tkc/easing.h"
#include "tkc/utils.h"
#include "tkc/func_call_parser.h"
#include "slide_view/slide_indicator.h"
#include "widget_animators/widget_animator_opacity.h"
#include "base/widget_animator_manager.h"
#ifndef SLIDE_INDICATOR_HIDE_ANIMATOR_TIME
#define SLIDE_INDICATOR_HIDE_ANIMATOR_TIME 1000
#endif
static ret_t slide_indicator_reset_indicated_widget(widget_t* widget);
static ret_t slide_indicator_reset_indicated_widget(widget_t* widget);
static ret_t slide_indicator_set_indicated_widget(widget_t* widget, widget_t* target);
static ret_t slide_indicator_set_value_impl(widget_t* widget, uint32_t value, bool_t is_on_event);
#define _RADIAN(cx, cy, x, y) atan2(-y + (cy), x - (cx))
#define _DISTANCE(x1, y1, x2, y2) sqrt((x1 - (x2)) * (x1 - (x2)) + (y1 - (y2)) * (y1 - (y2)))
static const key_type_value_t indicator_default_paint_value[] = {
{"auto", 0, INDICATOR_DEFAULT_PAINT_AUTO},
{"stroke_dot", 0, INDICATOR_DEFAULT_PAINT_STROKE_DOT},
{"fill_dot", 0, INDICATOR_DEFAULT_PAINT_FILL_DOT},
{"stroke_rect", 0, INDICATOR_DEFAULT_PAINT_STROKE_RECT},
{"fill_rect", 0, INDICATOR_DEFAULT_PAINT_FILL_RECT}};
const key_type_value_t* indicator_default_paint_find(const char* name) {
return find_item(indicator_default_paint_value, ARRAY_SIZE(indicator_default_paint_value), name);
}
static pointf_t slide_indicator_eval_anchor(widget_t* widget) {
point_t p = {0, 0};
pointf_t anchor = {0, 0};
const char* anchor_x = NULL;
const char* anchor_y = NULL;
slide_indicator_t* slide_indicator = SLIDE_INDICATOR(widget);
return_value_if_fail(slide_indicator != NULL, anchor);
anchor_x = slide_indicator->anchor_x;
anchor_y = slide_indicator->anchor_y;
if (TK_STR_IS_EMPTY(anchor_x) || TK_STR_IS_EMPTY(anchor_y)) {
widget_t* target = slide_indicator->indicated_widget;
return_value_if_fail(target != NULL, anchor);
widget_to_screen(target, &p);
p.x += target->w / 2;
p.y += target->h / 2;
widget_to_local(widget, &p);
}
if (TK_STR_IS_EMPTY(anchor_x)) {
anchor.x = p.x;
} else {
anchor.x = tk_eval_ratio_or_px(anchor_x, widget->w);
}
if (TK_STR_IS_EMPTY(anchor_y)) {
anchor.y = p.y;
} else {
anchor.y = tk_eval_ratio_or_px(anchor_y, widget->h);
}
return anchor;
}
ret_t slide_indicator_set_anchor_x(widget_t* widget, const char* anchor) {
slide_indicator_t* slide_indicator = SLIDE_INDICATOR(widget);
return_value_if_fail(slide_indicator != NULL && anchor != NULL, RET_BAD_PARAMS);
slide_indicator->anchor_x = tk_str_copy(slide_indicator->anchor_x, anchor);
return RET_OK;
}
ret_t slide_indicator_set_anchor_y(widget_t* widget, const char* anchor) {
slide_indicator_t* slide_indicator = SLIDE_INDICATOR(widget);
return_value_if_fail(slide_indicator != NULL && anchor != NULL, RET_BAD_PARAMS);
slide_indicator->anchor_y = tk_str_copy(slide_indicator->anchor_y, anchor);
return RET_OK;
}
static ret_t slide_indicator_get_prop(widget_t* widget, const char* name, value_t* v) {
slide_indicator_t* slide_indicator = SLIDE_INDICATOR(widget);
return_value_if_fail(slide_indicator != NULL && name != NULL && v != NULL, RET_BAD_PARAMS);
if (tk_str_eq(name, WIDGET_PROP_VALUE) || tk_str_eq(name, WIDGET_PROP_CURR_PAGE)) {
value_set_int(v, slide_indicator->value);
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_MAX)) {
value_set_uint32(v, slide_indicator->max);
return RET_OK;
} else if (tk_str_eq(name, SLIDE_INDICATOR_PROP_DEFAULT_PAINT)) {
value_set_int(v, slide_indicator->default_paint);
return RET_OK;
} else if (tk_str_eq(name, SLIDE_INDICATOR_PROP_AUTO_HIDE)) {
value_set_int(v, slide_indicator->auto_hide);
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_MARGIN)) {
value_set_int(v, slide_indicator->margin);
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_SPACING)) {
value_set_float(v, slide_indicator->spacing);
return RET_OK;
} else if (tk_str_eq(name, SLIDE_INDICATOR_PROP_SIZE)) {
value_set_uint32(v, slide_indicator->size);
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_ANCHOR_X)) {
value_set_str(v, slide_indicator->anchor_x);
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_ANCHOR_Y)) {
value_set_str(v, slide_indicator->anchor_y);
return RET_OK;
} else if (tk_str_eq(name, SLIDE_INDICATOR_PROP_INDICATED_TARGET)) {
value_set_str(v, slide_indicator->indicated_target);
return RET_OK;
} else if (tk_str_eq(name, SLIDE_INDICATOR_PROP_transition)) {
value_set_bool(v, slide_indicator->transition);
return RET_OK;
}
return RET_NOT_FOUND;
}
static ret_t slide_indicator_set_prop(widget_t* widget, const char* name, const value_t* v) {
slide_indicator_t* slide_indicator = SLIDE_INDICATOR(widget);
return_value_if_fail(slide_indicator != NULL && name != NULL && v != NULL, RET_BAD_PARAMS);
if (tk_str_eq(name, WIDGET_PROP_VALUE) || tk_str_eq(name, WIDGET_PROP_CURR_PAGE)) {
return slide_indicator_set_value(widget, value_int(v));
} else if (tk_str_eq(name, WIDGET_PROP_MAX)) {
return slide_indicator_set_max(widget, value_uint32(v));
} else if (tk_str_eq(name, SLIDE_INDICATOR_PROP_DEFAULT_PAINT)) {
if (v->type == VALUE_TYPE_STRING) {
const key_type_value_t* kv = indicator_default_paint_find(value_str(v));
if (kv != NULL) {
slide_indicator_set_default_paint(widget, (indicator_default_paint_t)(kv->value));
}
} else {
slide_indicator_set_default_paint(widget, (indicator_default_paint_t)value_int(v));
}
return RET_OK;
} else if (tk_str_eq(name, SLIDE_INDICATOR_PROP_AUTO_HIDE)) {
return slide_indicator_set_auto_hide(widget, value_uint16(v));
} else if (tk_str_eq(name, WIDGET_PROP_MARGIN)) {
return slide_indicator_set_margin(widget, value_int(v));
} else if (tk_str_eq(name, WIDGET_PROP_SPACING)) {
return slide_indicator_set_spacing(widget, value_float(v));
} else if (tk_str_eq(name, SLIDE_INDICATOR_PROP_SIZE)) {
return slide_indicator_set_size(widget, value_uint32(v));
} else if (tk_str_eq(name, WIDGET_PROP_ANCHOR_X)) {
return slide_indicator_set_anchor_x(widget, value_str(v));
} else if (tk_str_eq(name, WIDGET_PROP_ANCHOR_Y)) {
return slide_indicator_set_anchor_y(widget, value_str(v));
} else if (tk_str_eq(name, SLIDE_INDICATOR_PROP_INDICATED_TARGET)) {
return slide_indicator_set_indicated_target(widget, value_str(v));
} else if (tk_str_eq(name, SLIDE_INDICATOR_PROP_transition)) {
return slide_indicator_set_transition(widget, value_bool(v));
}
return RET_NOT_FOUND;
}
static widget_t* slide_indicator_find_target(widget_t* widget) {
value_t v;
widget_t* parent = NULL;
return_value_if_fail(widget != NULL, NULL);
parent = widget->parent;
if (parent != NULL) {
WIDGET_FOR_EACH_CHILD_BEGIN(parent, iter, i)
if (iter != NULL) {
if (widget_get_prop(iter, WIDGET_PROP_CURR_PAGE, &v) == RET_OK &&
widget_get_prop(iter, WIDGET_PROP_PAGE_MAX_NUMBER, &v) == RET_OK) {
return iter;
}
}
WIDGET_FOR_EACH_CHILD_END()
}
return NULL;
}
static ret_t slide_indicator_on_layout_children(widget_t* widget) {
slide_indicator_t* slide_indicator = SLIDE_INDICATOR(widget);
return_value_if_fail(slide_indicator != NULL, RET_BAD_PARAMS);
if (slide_indicator->indicated_widget != NULL &&
slide_indicator->indicated_widget->parent == widget->parent) {
} else {
if (slide_indicator_reset_indicated_widget(widget) == RET_OK) {
widget_t* target = NULL;
if (slide_indicator->indicated_target != NULL) {
target = widget_lookup(widget->parent, slide_indicator->indicated_target, FALSE);
} else {
target = slide_indicator_find_target(widget);
}
if (target) {
slide_indicator_set_indicated_widget(widget, target);
}
}
}
slide_indicator->reset_icon_rect_list = TRUE;
return widget_layout_children_default(widget);
}
static ret_t slide_indicator_fill_rect(canvas_t* c, rect_t* r, color_t color) {
canvas_set_fill_color(c, color);
canvas_fill_rect(c, r->x, r->y, r->w, r->h);
return RET_OK;
}
static ret_t slide_indicator_stroke_rect(canvas_t* c, rect_t* r, color_t color) {
canvas_set_stroke_color(c, color);
canvas_stroke_rect(c, r->x, r->y, r->w, r->h);
return RET_OK;
}
static ret_t slide_indicator_draw_rect_by_vg(canvas_t* c, rectf_t* r, color_t color, bool_t fill) {
vgcanvas_t* vg = canvas_get_vgcanvas(c);
vgcanvas_save(vg);
vgcanvas_set_global_alpha(vg, c->global_alpha / 255.0f);
vgcanvas_translate(vg, c->ox, c->oy);
vgcanvas_begin_path(vg);
vgcanvas_set_fill_color(vg, color);
vgcanvas_rect(vg, r->x, r->y, r->w, r->h);
if (fill) {
vgcanvas_fill(vg);
} else {
vgcanvas_stroke(vg);
}
vgcanvas_restore(vg);
return RET_OK;
}
static ret_t slide_indicator_fill_dot(canvas_t* c, rectf_t* r, color_t color) {
float_t radius = tk_min(r->w, r->h) / 2;
vgcanvas_t* vg = canvas_get_vgcanvas(c);
vgcanvas_save(vg);
vgcanvas_set_global_alpha(vg, c->global_alpha / 255.0f);
vgcanvas_translate(vg, c->ox, c->oy);
vgcanvas_begin_path(vg);
vgcanvas_set_fill_color(vg, color);
vgcanvas_arc(vg, r->x + radius, r->y + radius, radius, 0, M_PI * 2, FALSE);
vgcanvas_fill(vg);
vgcanvas_restore(vg);
return RET_OK;
}
static ret_t slide_indicator_stroke_dot(canvas_t* c, rectf_t* r, color_t color) {
float_t radius = tk_min(r->w, r->h) / 2;
vgcanvas_t* vg = canvas_get_vgcanvas(c);
vgcanvas_save(vg);
vgcanvas_set_global_alpha(vg, c->global_alpha / 255.0f);
vgcanvas_translate(vg, c->ox, c->oy);
vgcanvas_begin_path(vg);
vgcanvas_set_stroke_color(vg, color);
vgcanvas_arc(vg, r->x + radius, r->y + radius, radius, 0, M_PI * 2, FALSE);
vgcanvas_stroke(vg);
vgcanvas_restore(vg);
return RET_OK;
}
static ret_t slide_indicator_default_paint_indicator(widget_t* widget, canvas_t* c, rectf_t* r,
color_t color) {
rect_t rect = rect_from_rectf(r);
slide_indicator_t* slide_indicator = SLIDE_INDICATOR(widget);
return_value_if_fail(slide_indicator != NULL, RET_BAD_PARAMS);
switch (slide_indicator->default_paint) {
case INDICATOR_DEFAULT_PAINT_STROKE_DOT:
slide_indicator_stroke_dot(c, r, color);
break;
case INDICATOR_DEFAULT_PAINT_STROKE_RECT:
slide_indicator_stroke_rect(c, &rect, color);
break;
case INDICATOR_DEFAULT_PAINT_FILL_RECT:
slide_indicator_fill_rect(c, &rect, color);
break;
default:
slide_indicator_fill_dot(c, r, color);
}
return RET_OK;
}
static float_t slide_indicator_get_max_transition_size(slide_indicator_t* slide_indicator) {
return slide_indicator->icon_rect_spacing;
}
static ret_t slide_indicator_default_paint_active_indicator(widget_t* widget, canvas_t* c,
rectf_t* r, color_t color) {
rect_t rect;
rectf_t rectf;
float_t x, y, w, h;
slide_indicator_t* slide_indicator = SLIDE_INDICATOR(widget);
return_value_if_fail(slide_indicator != NULL, RET_BAD_PARAMS);
if (slide_indicator->transition) {
float_t max_transition_size = slide_indicator_get_max_transition_size(slide_indicator);
w = r->w + max_transition_size;
h = r->h + max_transition_size;
x = r->x - max_transition_size / 2;
y = r->y - max_transition_size / 2;
} else {
x = r->x;
y = r->y;
w = r->w;
h = r->h;
}
switch (slide_indicator->default_paint) {
case INDICATOR_DEFAULT_PAINT_STROKE_RECT:
case INDICATOR_DEFAULT_PAINT_FILL_RECT:
if (slide_indicator->transition) {
rect = rect_init(x, y, w, h);
slide_indicator_fill_rect(c, &rect, color);
} else {
rectf = rectf_init(x, y, w, h);
slide_indicator_draw_rect_by_vg(c, &rectf, color, TRUE);
}
break;
default:
rectf = rectf_init(x, y, w, h);
slide_indicator_fill_dot(c, &rectf, color);
}
return RET_OK;
}
static ret_t slide_indicator_default_paint_indicator_by_transition(widget_t* widget, canvas_t* c,
rectf_t* r, color_t color,
color_t selected_color,
float_t active_offset) {
rectf_t new_rect;
float_t x, y, w, h, transition_size;
color_t new_color = color_init(0, 0, 0, 0);
color_t new_color1 = color_init(0, 0, 0, 0);
int32_t dr = selected_color.rgba.r - color.rgba.r;
int32_t dg = selected_color.rgba.g - color.rgba.g;
int32_t db = selected_color.rgba.b - color.rgba.b;
int32_t da = selected_color.rgba.a - color.rgba.a;
slide_indicator_t* slide_indicator = SLIDE_INDICATOR(widget);
return_value_if_fail(slide_indicator != NULL, RET_BAD_PARAMS);
new_color.rgba.r = color.rgba.r + dr * active_offset;
new_color.rgba.g = color.rgba.g + dg * active_offset;
new_color.rgba.b = color.rgba.b + db * active_offset;
new_color.rgba.a = color.rgba.a + da * active_offset;
if (slide_indicator->default_paint == INDICATOR_DEFAULT_PAINT_STROKE_DOT ||
slide_indicator->default_paint == INDICATOR_DEFAULT_PAINT_STROKE_RECT) {
new_color1.rgba.r = selected_color.rgba.r * active_offset;
new_color1.rgba.g = selected_color.rgba.g * active_offset;
new_color1.rgba.b = selected_color.rgba.b * active_offset;
new_color1.rgba.a = selected_color.rgba.a * active_offset;
}
transition_size = slide_indicator_get_max_transition_size(slide_indicator) * active_offset;
w = r->w + transition_size;
h = r->h + transition_size;
x = r->x - transition_size / 2;
y = r->y - transition_size / 2;
new_rect = rectf_init(x, y, w, h);
switch (slide_indicator->default_paint) {
case INDICATOR_DEFAULT_PAINT_STROKE_DOT:
slide_indicator_stroke_dot(c, &new_rect, new_color);
slide_indicator_fill_dot(c, &new_rect, new_color1);
break;
case INDICATOR_DEFAULT_PAINT_STROKE_RECT:
slide_indicator_draw_rect_by_vg(c, &new_rect, new_color, FALSE);
slide_indicator_draw_rect_by_vg(c, &new_rect, new_color1, TRUE);
break;
case INDICATOR_DEFAULT_PAINT_FILL_RECT:
slide_indicator_draw_rect_by_vg(c, &new_rect, new_color, TRUE);
break;
default:
slide_indicator_fill_dot(c, &new_rect, new_color);
break;
}
return RET_OK;
}
static ret_t slide_indicator_paint_one(widget_t* widget, canvas_t* c, rectf_t* r,
float_t active_offset) {
bitmap_t img;
style_t* style = widget->astyle;
color_t trans = color_init(0, 0, 0, 0);
slide_indicator_t* slide_indicator = SLIDE_INDICATOR(widget);
color_t color = style_get_color(style, STYLE_ID_FG_COLOR, trans);
color_t selected_color = style_get_color(style, STYLE_ID_SELECTED_FG_COLOR, trans);
const char* icon =
style_get_str(style, active_offset == 1.0f ? STYLE_ID_ACTIVE_ICON : STYLE_ID_ICON, NULL);
if (!slide_indicator->transition && icon && widget_load_image(widget, icon, &img) == RET_OK) {
int32_t x = r->x + ((int32_t)r->w >> 1);
int32_t y = r->y + ((int32_t)r->h >> 1);
canvas_draw_icon(c, &img, x, y);
} else {
if (slide_indicator->transition && 0.0f < active_offset && active_offset < 1.0f) {
slide_indicator_default_paint_indicator_by_transition(widget, c, r, color, selected_color,
active_offset);
} else if (active_offset == 1.0f) {
slide_indicator_default_paint_active_indicator(widget, c, r, selected_color);
} else {
slide_indicator_default_paint_indicator(widget, c, r, color);
}
}
return RET_OK;
}
static float_t slide_indicator_get_offset_by_index(slide_indicator_t* slide_indicator,
int32_t index) {
int32_t value = slide_indicator->curr_value;
float_t value_offset = slide_indicator->value_offset;
if (value_offset > 0.0f) {
if (value == index) {
return 1.0f - value_offset;
} else {
int32_t next_value = value + 1;
if (index == next_value) {
return value_offset;
} else if (next_value >= slide_indicator->max && slide_indicator->loop && index == 0) {
return value_offset;
}
}
} else if (value_offset < 0.0f) {
if (value == index) {
return 1.0f + value_offset;
} else {
int32_t next_value = value - 1;
if (index == next_value) {
return value_offset;
} else if (next_value < 0 && slide_indicator->loop && index == slide_indicator->max - 1) {
return value_offset;
}
}
} else {
if (value == index) {
return 1.0f;
}
}
return 0.0f;
}
static ret_t slide_indicator_paint_arc(widget_t* widget, canvas_t* c) {
uint32_t i = 0;
slide_indicator_t* slide_indicator = SLIDE_INDICATOR(widget);
darray_t* icon_rect_list = &(slide_indicator->icon_rect_list);
if (icon_rect_list->size != slide_indicator->max || slide_indicator->reset_icon_rect_list) {
rectf_t r;
uint32_t i = 0;
float_t offset = 0;
bool_t ccw = FALSE;
uint32_t nr = slide_indicator->max;
uint32_t size = slide_indicator->size;
pointf_t anchor = slide_indicator_eval_anchor(widget);
float_t cx = anchor.x;
float_t cy = anchor.y;
float_t margin = slide_indicator->margin;
float_t spacing = (slide_indicator->spacing / 180.0f * M_PI);
float_t center = _RADIAN(cx, cy, widget->w / 2, widget->h / 2);
float_t radius = _DISTANCE(cx, cy, widget->w / 2, widget->h / 2) - margin - size / 2;
if (cx > widget->w / 2 || cy < widget->h / 2) {
ccw = TRUE;
}
if (nr % 2) {
offset = ((nr / 2) * spacing);
} else {
offset = ((nr / 2) * spacing - spacing / 2);
}
offset = ccw ? (center - offset - 3 * M_PI / 2) : (center + offset + M_PI / 2);
r = rectf_init(0, 0, size, size);
darray_clear(icon_rect_list);
for (i = 0; i < nr; i++) {
rectf_t* tmp = TKMEM_ZALLOC(rectf_t);
if (ccw) {
r.x = cx + radius * sin(offset + i * spacing) - size / 2;
r.y = cy + radius * cos(-offset - i * spacing) - size / 2;
} else {
r.x = cx + radius * sin(offset - i * spacing) - size / 2;
r.y = cy + radius * cos(-offset + i * spacing) - size / 2;
}
memcpy(tmp, &r, sizeof(rectf_t));
darray_push(icon_rect_list, tmp);
}
slide_indicator->reset_icon_rect_list = FALSE;
slide_indicator->icon_rect_spacing = sin(spacing / 2) * radius * 2 / 5;
}
for (i = 0; i < icon_rect_list->size; i++) {
rectf_t* tmp = (rectf_t*)darray_get(icon_rect_list, i);
float_t offset = tk_abs(slide_indicator_get_offset_by_index(slide_indicator, i));
slide_indicator_paint_one(widget, c, tmp, offset);
}
return RET_OK;
}
static ret_t slide_indicator_paint_linear(widget_t* widget, canvas_t* c) {
uint32_t i = 0;
slide_indicator_t* slide_indicator = SLIDE_INDICATOR(widget);
darray_t* icon_rect_list = &(slide_indicator->icon_rect_list);
if (icon_rect_list->size != slide_indicator->max || slide_indicator->reset_icon_rect_list) {
rectf_t r;
uint32_t i = 0;
bool_t ccw = FALSE;
uint32_t offset = 0;
uint32_t nr = slide_indicator->max;
uint32_t size = slide_indicator->size;
pointf_t anchor = slide_indicator_eval_anchor(widget);
float_t cx = anchor.x;
float_t cy = anchor.y;
bool_t vertical = widget->w < widget->h;
uint32_t margin = slide_indicator->margin;
uint32_t spacing = slide_indicator->spacing;
uint32_t half_size = slide_indicator->size >> 1;
if (cx > widget->w / 2 || cy < widget->h / 2) {
ccw = TRUE;
}
if (nr % 2) {
offset = ((nr / 2) * spacing + half_size);
} else {
offset = ((nr / 2) * spacing - spacing / 2 + half_size);
}
if (vertical) {
if (ccw) {
r = rectf_init(widget->w - margin - size, cy - offset, size, size);
} else {
r = rectf_init(margin, cy - offset, size, size);
}
} else {
if (ccw) {
r = rectf_init(cx - offset, margin, size, size);
} else {
r = rectf_init(cx - offset, widget->h - margin - size, size, size);
}
}
darray_clear(icon_rect_list);
for (i = 0; i < nr; i++) {
rectf_t* tmp = TKMEM_ZALLOC(rectf_t);
memcpy(tmp, &r, sizeof(rectf_t));
darray_push(icon_rect_list, tmp);
if (vertical) {
r.y += spacing;
} else {
r.x += spacing;
}
}
slide_indicator->icon_rect_spacing = spacing / 5;
slide_indicator->reset_icon_rect_list = FALSE;
}
for (i = 0; i < icon_rect_list->size; i++) {
rectf_t* tmp = (rectf_t*)darray_get(icon_rect_list, i);
float_t offset = tk_abs(slide_indicator_get_offset_by_index(slide_indicator, i));
slide_indicator_paint_one(widget, c, tmp, offset);
}
return RET_OK;
}
static ret_t slide_indicator_on_animate_end(void* ctx, event_t* e) {
widget_t* widget = WIDGET(ctx);
slide_indicator_t* slide_indicator = SLIDE_INDICATOR(widget);
return_value_if_fail(widget != NULL && slide_indicator != NULL, RET_REMOVE);
slide_indicator->wa_opactiy = NULL;
widget_set_visible(widget, FALSE, FALSE);
widget_set_opacity(widget, 0xff);
return RET_REMOVE;
}
static ret_t slide_indicator_set_visible(widget_t* widget, bool_t visible) {
slide_indicator_t* slide_indicator = SLIDE_INDICATOR(widget);
return_value_if_fail(widget != NULL && slide_indicator != NULL, RET_REMOVE);
if (slide_indicator->wa_opactiy != NULL) {
widget_animator_destroy(slide_indicator->wa_opactiy);
slide_indicator->wa_opactiy = NULL;
}
if (!visible && slide_indicator->auto_hide) {
slide_indicator->wa_opactiy = widget_animator_opacity_create(
widget, SLIDE_INDICATOR_HIDE_ANIMATOR_TIME, 0, EASING_SIN_INOUT);
widget_animator_on(slide_indicator->wa_opactiy, EVT_ANIM_END, slide_indicator_on_animate_end,
slide_indicator);
widget_animator_opacity_set_params(slide_indicator->wa_opactiy, 0xff, 0);
widget_set_opacity(widget, 0xff);
widget_animator_start(slide_indicator->wa_opactiy);
} else {
if (visible) {
widget_set_opacity(widget, 0xff);
}
widget_set_visible(widget, visible);
}
return RET_OK;
}
static ret_t slide_indicator_target_on_value_changing(void* ctx, event_t* e) {
int32_t value = 0;
int32_t offset = 0;
widget_t* widget = WIDGET(e->target);
widget_t* indicator = WIDGET(ctx);
offset_change_event_t* evt = (offset_change_event_t*)e;
slide_indicator_t* slide_indicator = SLIDE_INDICATOR(indicator);
return_value_if_fail(widget != NULL && slide_indicator != NULL && evt != NULL, RET_BAD_PARAMS);
if (!slide_indicator->transition ||
(slide_indicator->transition && slide_indicator->is_value_changing)) {
slide_indicator->value_offset = 0.0f;
return RET_OK;
}
offset = (int32_t)(evt->new_offset - evt->old_offset);
if (indicator->w > indicator->h) {
value = offset / widget->w;
slide_indicator->value_offset = offset / (float_t)widget->w - value;
} else {
value = offset / widget->h;
slide_indicator->value_offset = offset / (float_t)widget->h - value;
}
value = slide_indicator->value + value;
if (slide_indicator->loop) {
if (value < 0) {
value += slide_indicator->max;
}
slide_indicator->curr_value = value % slide_indicator->max;
} else {
if (slide_indicator->value == 0 && offset < 0) {
slide_indicator->curr_value = 0;
slide_indicator->value_offset = 0.0f;
} else if (slide_indicator->value == slide_indicator->max - 1 && offset > 0) {
slide_indicator->value_offset = 0.0f;
slide_indicator->curr_value = slide_indicator->max - 1;
} else {
slide_indicator->curr_value = value;
}
}
slide_indicator->loop = widget_get_prop_bool(widget, WIDGET_PROP_LOOP, FALSE);
widget_invalidate(widget, NULL);
return RET_OK;
}
static ret_t slide_indicator_target_on_value_changed(void* ctx, event_t* e) {
value_t v;
widget_t* widget = WIDGET(e->target);
widget_t* indicator = WIDGET(ctx);
slide_indicator_t* slide_indicator = SLIDE_INDICATOR(indicator);
return_value_if_fail(widget != NULL && slide_indicator != NULL, RET_BAD_PARAMS);
if (widget_get_prop(widget, WIDGET_PROP_CURR_PAGE, &v) != RET_OK) {
widget_get_prop(widget, WIDGET_PROP_VALUE, &v);
}
if (slide_indicator->value != value_int(&v)) {
slide_indicator_set_value_impl(indicator, value_int(&v), TRUE);
}
if (widget_get_prop(widget, WIDGET_PROP_PAGE_MAX_NUMBER, &v) != RET_OK) {
uint32_t max = value_int(&v);
if (slide_indicator->max != max) {
slide_indicator->max = max;
}
}
slide_indicator->value_offset = 0.0f;
slide_indicator->is_value_changing = FALSE;
slide_indicator->curr_value = slide_indicator->value;
widget_invalidate(widget, NULL);
return RET_OK;
}
static ret_t slide_indicator_target_on_move_resize(void* ctx, event_t* e) {
widget_t* widget = WIDGET(e->target);
widget_t* indicator = WIDGET(ctx);
return_value_if_fail(widget != NULL && indicator != NULL, RET_BAD_PARAMS);
return widget_invalidate_force(indicator, NULL);
}
static ret_t slide_indicator_target_on_pointer_move(void* ctx, event_t* e) {
widget_t* indicator = WIDGET(ctx);
slide_indicator_t* slide_indicator = SLIDE_INDICATOR(indicator);
return_value_if_fail(slide_indicator != NULL, RET_BAD_PARAMS);
if (slide_indicator->auto_hide) {
pointer_event_t* evt = (pointer_event_t*)e;
slide_indicator->last_move_point.x = evt->x;
slide_indicator->last_move_point.y = evt->y;
slide_indicator->last_move_point_time = timer_manager()->get_time();
slide_indicator_set_visible(indicator, TRUE);
}
return RET_OK;
}
static ret_t slide_indicator_target_on_destroy(void* ctx, event_t* e) {
widget_t* indicator = WIDGET(ctx);
slide_indicator_t* slide_indicator = SLIDE_INDICATOR(indicator);
return_value_if_fail(slide_indicator != NULL, RET_BAD_PARAMS);
slide_indicator->indicated_widget = NULL;
return RET_OK;
}
static ret_t slide_indicator_reset_indicated_widget(widget_t* widget) {
slide_indicator_t* slide_indicator = SLIDE_INDICATOR(widget);
return_value_if_fail(slide_indicator != NULL, RET_BAD_PARAMS);
if (slide_indicator->indicated_widget != NULL) {
widget_t* target = slide_indicator->indicated_widget;
widget_off_by_func(target, EVT_MOVE, slide_indicator_target_on_move_resize, widget);
widget_off_by_func(target, EVT_MOVE_RESIZE, slide_indicator_target_on_move_resize, widget);
widget_off_by_func(target, EVT_RESIZE, slide_indicator_target_on_move_resize, widget);
widget_off_by_func(target, EVT_PAGE_CHANGED, slide_indicator_target_on_value_changed, widget);
widget_off_by_func(target, EVT_PAGE_CHANGING, slide_indicator_target_on_value_changing, widget);
widget_off_by_func(target, EVT_DESTROY, slide_indicator_target_on_destroy, widget);
if (slide_indicator->auto_hide) {
widget_off_by_func(target, EVT_POINTER_MOVE, slide_indicator_target_on_pointer_move, widget);
}
slide_indicator->indicated_widget = NULL;
}
return RET_OK;
}
static ret_t slide_indicator_set_indicated_widget(widget_t* widget, widget_t* target) {
value_t v;
slide_indicator_t* slide_indicator = SLIDE_INDICATOR(widget);
return_value_if_fail(slide_indicator != NULL && target != NULL, RET_BAD_PARAMS);
slide_indicator->indicated_widget = target;
if (widget_get_prop(target, WIDGET_PROP_PAGE_MAX_NUMBER, &v) == RET_OK) {
slide_indicator->max = value_uint32(&v);
slide_indicator->chilren_indicated = TRUE;
}
if (widget_get_prop(target, WIDGET_PROP_CURR_PAGE, &v) != RET_OK) {
widget_get_prop(target, WIDGET_PROP_VALUE, &v);
}
slide_indicator_set_value(widget, value_uint32(&v));
widget_on(target, EVT_MOVE, slide_indicator_target_on_move_resize, widget);
widget_on(target, EVT_MOVE_RESIZE, slide_indicator_target_on_move_resize, widget);
widget_on(target, EVT_RESIZE, slide_indicator_target_on_move_resize, widget);
widget_on(target, EVT_PAGE_CHANGED, slide_indicator_target_on_value_changed, widget);
widget_on(target, EVT_PAGE_CHANGING, slide_indicator_target_on_value_changing, widget);
widget_on(target, EVT_DESTROY, slide_indicator_target_on_destroy, widget);
if (slide_indicator->auto_hide) {
widget_on(target, EVT_POINTER_MOVE, slide_indicator_target_on_pointer_move, widget);
}
return RET_OK;
}
ret_t slide_indicator_on_paint_begin(widget_t* widget, canvas_t* c) {
value_t v;
slide_indicator_t* slide_indicator = SLIDE_INDICATOR(widget);
return_value_if_fail(widget != NULL && slide_indicator != NULL, RET_BAD_PARAMS);
if (slide_indicator->chilren_indicated) {
if (widget_get_prop(slide_indicator->indicated_widget, WIDGET_PROP_PAGE_MAX_NUMBER, &v) ==
RET_OK) {
slide_indicator->max = value_uint32(&v);
}
}
return RET_OK;
}
static ret_t slide_indicator_on_paint_self(widget_t* widget, canvas_t* c) {
slide_indicator_t* slide_indicator = SLIDE_INDICATOR(widget);
return_value_if_fail(widget != NULL && slide_indicator != NULL, RET_BAD_PARAMS);
slide_indicator_paint_linear(widget, c);
return RET_OK;
}
static ret_t slide_indicator_arc_on_paint_self(widget_t* widget, canvas_t* c) {
slide_indicator_t* slide_indicator = SLIDE_INDICATOR(widget);
return_value_if_fail(widget != NULL && slide_indicator != NULL, RET_BAD_PARAMS);
slide_indicator_paint_arc(widget, c);
return RET_OK;
}
ret_t slide_indicator_on_destroy(widget_t* widget) {
slide_indicator_t* slide_indicator = SLIDE_INDICATOR(widget);
return_value_if_fail(widget != NULL && slide_indicator != NULL, RET_BAD_PARAMS);
if (slide_indicator->check_hide_idle != TK_INVALID_ID) {
idle_remove(slide_indicator->check_hide_idle);
}
darray_deinit(&(slide_indicator->icon_rect_list));
slide_indicator_reset_indicated_widget(widget);
TKMEM_FREE(slide_indicator->indicated_target);
TKMEM_FREE(slide_indicator->anchor_x);
TKMEM_FREE(slide_indicator->anchor_y);
return RET_OK;
}
static ret_t slide_indicator_on_click(widget_t* widget, int32_t x, int32_t y) {
uint32_t i = 0;
point_t p = {x, y};
slide_indicator_t* slide_indicator = SLIDE_INDICATOR(widget);
return_value_if_fail(slide_indicator != NULL && widget != NULL, RET_BAD_PARAMS);
widget_to_local(widget, &p);
for (; i < slide_indicator->icon_rect_list.size; i++) {
rectf_t* r = (rectf_t*)darray_get(&(slide_indicator->icon_rect_list), i);
if (p.x >= r->x && p.y >= r->y && p.x < r->x + r->w && p.y < r->y + r->h) {
slide_indicator_set_value(widget, i);
break;
}
}
return RET_OK;
}
static ret_t slide_indicator_on_event(widget_t* widget, event_t* e) {
uint16_t type = e->type;
slide_indicator_t* slide_indicator = SLIDE_INDICATOR(widget);
return_value_if_fail(slide_indicator != NULL && widget != NULL, RET_BAD_PARAMS);
switch (type) {
case EVT_MOVE:
case EVT_RESIZE:
case EVT_MOVE_RESIZE:
slide_indicator->reset_icon_rect_list = TRUE;
break;
case EVT_POINTER_DOWN:
slide_indicator->pressed = TRUE;
widget_set_state(widget, WIDGET_STATE_PRESSED);
break;
case EVT_POINTER_MOVE:
slide_indicator_target_on_pointer_move(widget, e);
break;
case EVT_POINTER_UP:
if (slide_indicator->pressed) {
pointer_event_t* evt = (pointer_event_t*)e;
slide_indicator_on_click(widget, evt->x, evt->y);
}
case EVT_POINTER_DOWN_ABORT:
slide_indicator->pressed = FALSE;
widget_set_state(widget, WIDGET_STATE_NORMAL);
break;
default:
break;
}
return RET_OK;
}
ret_t slide_indicator_on_idle_chech_hide(const idle_info_t* idle) {
uint64_t curr_time = timer_manager()->get_time();
widget_t* widget = WIDGET(idle->ctx);
slide_indicator_t* slide_indicator = SLIDE_INDICATOR(widget);
return_value_if_fail(slide_indicator != NULL, RET_BAD_PARAMS);
if (!slide_indicator->auto_hide) {
slide_indicator->check_hide_idle = TK_INVALID_ID;
return RET_OK;
}
if (slide_indicator->last_move_point_time + slide_indicator->auto_hide < curr_time) {
if (slide_indicator->wa_opactiy == NULL && widget->visible) {
slide_indicator_set_visible(widget, FALSE);
}
}
return RET_REPEAT;
}
static ret_t slide_indicator_arc_init(widget_t* widget) {
slide_indicator_t* slide_indicator = SLIDE_INDICATOR(widget);
return_value_if_fail(slide_indicator != NULL, RET_BAD_PARAMS);
slide_indicator->spacing = 5;
return RET_OK;
}
static const char* s_slide_indicator_properties[] = {WIDGET_PROP_VALUE,
WIDGET_PROP_MAX,
SLIDE_INDICATOR_PROP_DEFAULT_PAINT,
SLIDE_INDICATOR_PROP_AUTO_HIDE,
SLIDE_INDICATOR_PROP_INDICATED_TARGET,
WIDGET_PROP_MARGIN,
WIDGET_PROP_SPACING,
SLIDE_INDICATOR_PROP_SIZE,
WIDGET_PROP_ANCHOR_X,
WIDGET_PROP_ANCHOR_Y,
NULL};
TK_DECL_VTABLE(slide_indicator_linear) = {.size = sizeof(slide_indicator_t),
.type = WIDGET_TYPE_SLIDE_INDICATOR,
.clone_properties = s_slide_indicator_properties,
.persistent_properties = s_slide_indicator_properties,
.get_parent_vt = TK_GET_PARENT_VTABLE(widget),
.create = slide_indicator_create,
.on_event = slide_indicator_on_event,
.get_prop = slide_indicator_get_prop,
.set_prop = slide_indicator_set_prop,
.on_layout_children = slide_indicator_on_layout_children,
.on_paint_begin = slide_indicator_on_paint_begin,
.on_paint_self = slide_indicator_on_paint_self,
.on_destroy = slide_indicator_on_destroy};
TK_DECL_VTABLE(slide_indicator_arc) = {.size = sizeof(slide_indicator_t),
.type = WIDGET_TYPE_SLIDE_INDICATOR_ARC,
.clone_properties = s_slide_indicator_properties,
.persistent_properties = s_slide_indicator_properties,
.get_parent_vt = TK_GET_PARENT_VTABLE(widget),
.create = slide_indicator_create_arc,
.init = slide_indicator_arc_init,
.on_event = slide_indicator_on_event,
.get_prop = slide_indicator_get_prop,
.set_prop = slide_indicator_set_prop,
.on_layout_children = slide_indicator_on_layout_children,
.on_paint_begin = slide_indicator_on_paint_begin,
.on_paint_self = slide_indicator_arc_on_paint_self,
.on_destroy = slide_indicator_on_destroy};
/*create*/
widget_t* slide_indicator_create_internal(widget_t* parent, xy_t x, xy_t y, wh_t w, wh_t h,
const widget_vtable_t* vt) {
widget_t* widget = widget_create(parent, vt, x, y, w, h);
slide_indicator_t* slide_indicator = SLIDE_INDICATOR(widget);
widget_t* target = NULL;
return_value_if_fail(slide_indicator != NULL, NULL);
slide_indicator->default_paint = INDICATOR_DEFAULT_PAINT_AUTO;
slide_indicator->auto_hide = 0;
slide_indicator->margin = 0;
slide_indicator->spacing = 16;
slide_indicator->size = 8;
slide_indicator->wa_opactiy = NULL;
slide_indicator->chilren_indicated = FALSE;
slide_indicator->reset_icon_rect_list = FALSE;
slide_indicator->check_hide_idle = TK_INVALID_ID;
darray_init(&(slide_indicator->icon_rect_list), 10, default_destroy, NULL);
slide_indicator->indicated_target = NULL;
slide_indicator->indicated_widget = NULL;
target = slide_indicator_find_target(widget);
if (target != NULL) {
slide_indicator_set_indicated_widget(widget, target);
}
return widget;
}
widget_t* slide_indicator_create_linear(widget_t* parent, xy_t x, xy_t y, wh_t w, wh_t h) {
return slide_indicator_create_internal(parent, x, y, w, h, TK_REF_VTABLE(slide_indicator_linear));
}
widget_t* slide_indicator_create_arc(widget_t* parent, xy_t x, xy_t y, wh_t w, wh_t h) {
widget_t* widget =
slide_indicator_create_internal(parent, x, y, w, h, TK_REF_VTABLE(slide_indicator_arc));
return_value_if_fail(slide_indicator_arc_init(widget) == RET_OK, NULL);
return widget;
}
widget_t* slide_indicator_create(widget_t* parent, xy_t x, xy_t y, wh_t w, wh_t h) {
return slide_indicator_create_linear(parent, x, y, w, h);
}
ret_t slide_indicator_set_value(widget_t* widget, uint32_t value) {
return slide_indicator_set_value_impl(widget, value, FALSE);
}
static ret_t slide_indicator_set_value_impl(widget_t* widget, uint32_t value, bool_t is_on_event) {
slide_indicator_t* slide_indicator = SLIDE_INDICATOR(widget);
return_value_if_fail(slide_indicator != NULL, RET_BAD_PARAMS);
if (slide_indicator->value != value) {
value_t v;
ret_t ret = RET_OK;
value_change_event_t evt;
value_change_event_init(&evt, EVT_VALUE_WILL_CHANGE, widget);
value_set_uint32(&(evt.old_value), slide_indicator->value);
value_set_uint32(&(evt.new_value), value);
if (widget_dispatch(widget, (event_t*)&evt) != RET_STOP) {
if (slide_indicator->indicated_widget != NULL && !is_on_event) {
if (widget_get_prop(slide_indicator->indicated_widget, WIDGET_PROP_CURR_PAGE, &v) !=
RET_OK) {
widget_get_prop(slide_indicator->indicated_widget, WIDGET_PROP_VALUE, &v);
}
if (value != value_int(&v)) {
value_t v1;
value_set_int(&v1, value);
ret = widget_set_prop(slide_indicator->indicated_widget, WIDGET_PROP_CURR_PAGE, &v1);
} else {
ret = RET_FAIL;
}
slide_indicator->is_value_changing = TRUE;
}
if (ret == RET_OK) {
slide_indicator->value = value;
evt.e.type = EVT_VALUE_CHANGED;
widget_dispatch(widget, (event_t*)&evt);
widget_dispatch_simple_event(widget, EVT_PAGE_CHANGED);
widget_invalidate(widget, NULL);
}
}
}
slide_indicator->curr_value = slide_indicator->value;
return RET_OK;
}
ret_t slide_indicator_set_max(widget_t* widget, uint32_t max) {
slide_indicator_t* slide_indicator = SLIDE_INDICATOR(widget);
return_value_if_fail(slide_indicator != NULL, RET_BAD_PARAMS);
slide_indicator->max = max;
slide_indicator->chilren_indicated = FALSE;
slide_indicator->reset_icon_rect_list = TRUE;
return widget_invalidate(widget, NULL);
}
ret_t slide_indicator_set_default_paint(widget_t* widget, indicator_default_paint_t default_paint) {
slide_indicator_t* slide_indicator = SLIDE_INDICATOR(widget);
return_value_if_fail(slide_indicator != NULL, RET_BAD_PARAMS);
slide_indicator->default_paint = default_paint;
widget_invalidate(widget, NULL);
return RET_OK;
}
ret_t slide_indicator_set_auto_hide(widget_t* widget, uint16_t auto_hide) {
slide_indicator_t* slide_indicator = SLIDE_INDICATOR(widget);
return_value_if_fail(slide_indicator != NULL, RET_BAD_PARAMS);
slide_indicator->auto_hide = auto_hide;
if (auto_hide) {
if (slide_indicator->check_hide_idle != TK_INVALID_ID) {
idle_remove(slide_indicator->check_hide_idle);
}
slide_indicator->last_move_point_time = timer_manager()->get_time();
slide_indicator->check_hide_idle = idle_add(slide_indicator_on_idle_chech_hide, widget);
} else {
if (slide_indicator->check_hide_idle != TK_INVALID_ID) {
idle_remove(slide_indicator->check_hide_idle);
}
}
return RET_OK;
}
ret_t slide_indicator_set_margin(widget_t* widget, int32_t margin) {
slide_indicator_t* slide_indicator = SLIDE_INDICATOR(widget);
return_value_if_fail(slide_indicator != NULL, RET_BAD_PARAMS);
slide_indicator->margin = margin;
slide_indicator->reset_icon_rect_list = TRUE;
return widget_invalidate(widget, NULL);
}
ret_t slide_indicator_set_spacing(widget_t* widget, float_t spacing) {
slide_indicator_t* slide_indicator = SLIDE_INDICATOR(widget);
return_value_if_fail(slide_indicator != NULL, RET_BAD_PARAMS);
slide_indicator->spacing = spacing;
slide_indicator->reset_icon_rect_list = TRUE;
return widget_invalidate(widget, NULL);
}
ret_t slide_indicator_set_size(widget_t* widget, uint32_t size) {
slide_indicator_t* slide_indicator = SLIDE_INDICATOR(widget);
return_value_if_fail(slide_indicator != NULL, RET_BAD_PARAMS);
slide_indicator->size = size;
slide_indicator->reset_icon_rect_list = TRUE;
return widget_invalidate(widget, NULL);
}
ret_t slide_indicator_set_anchor(widget_t* widget, const char* anchor_x, const char* anchor_y) {
slide_indicator_t* slide_indicator = SLIDE_INDICATOR(widget);
return_value_if_fail(slide_indicator != NULL, RET_BAD_PARAMS);
slide_indicator_set_anchor_x(widget, anchor_x);
slide_indicator_set_anchor_y(widget, anchor_y);
slide_indicator->reset_icon_rect_list = TRUE;
return widget_invalidate(widget, NULL);
}
ret_t slide_indicator_set_indicated_target(widget_t* widget, const char* target_name) {
slide_indicator_t* slide_indicator = SLIDE_INDICATOR(widget);
return_value_if_fail(slide_indicator != NULL, RET_BAD_PARAMS);
slide_indicator_reset_indicated_widget(widget);
TKMEM_FREE(slide_indicator->indicated_target);
slide_indicator->indicated_target = tk_str_copy(slide_indicator->indicated_target, target_name);
return RET_OK;
}
ret_t slide_indicator_set_transition(widget_t* widget, bool_t transition) {
slide_indicator_t* slide_indicator = SLIDE_INDICATOR(widget);
return_value_if_fail(slide_indicator != NULL, RET_BAD_PARAMS);
slide_indicator->transition = transition;
return RET_OK;
}
widget_t* slide_indicator_cast(widget_t* widget) {
return_value_if_fail(WIDGET_IS_INSTANCE_OF(widget, slide_indicator_linear) ||
WIDGET_IS_INSTANCE_OF(widget, slide_indicator_arc),
NULL);
return widget;
}
|
0 |
repos/awtk/src/ext_widgets
|
repos/awtk/src/ext_widgets/combo_box_ex/combo_box_ex.c
|
/**
* File: combo_box_ex.c
* Author: AWTK Develop Team
* Brief: combo_box_ex
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2019-08-21 Li DaHeng <[email protected]> created
*
*/
#include "base/layout.h"
#include "widgets/popup.h"
#include "base/widget_vtable.h"
#include "widgets/combo_box_item.h"
#include "ext_widgets/scroll_view/list_view.h"
#include "ext_widgets/scroll_view/scroll_view.h"
#include "ext_widgets/scroll_view/scroll_bar.h"
#include "ext_widgets/combo_box_ex/combo_box_ex.h"
#include "ext_widgets/scroll_view/list_item_seperator.h"
#define COMBO_BOX_EX_DEFAULT_MAXNR 5
#define COMBO_BOX_EX_DEFAULT_MARGIN 1
static ret_t combo_box_ex_create_popup_items(combo_box_t* combo_box, widget_t* parent,
int32_t extra_w) {
uint32_t w = 0;
uint32_t max_w = 0;
combo_box_option_t* iter = NULL;
widget_t* win = widget_get_window(parent);
return_value_if_fail(win != NULL, RET_BAD_PARAMS);
return_value_if_fail(combo_box != NULL, RET_BAD_PARAMS);
iter = combo_box->option_items;
while (iter != NULL) {
widget_t* item = NULL;
const char* text = iter->text;
if (tk_str_start_with(text, COMBO_BOX_EX_SEPERATOR_PREFIX)) {
item = list_item_seperator_create(parent, 0, 0, 0, 0);
text += strlen(COMBO_BOX_EX_SEPERATOR_PREFIX);
widget_set_prop_bool(item, WIDGET_PROP_RADIO, FALSE);
widget_set_prop_bool(item, WIDGET_PROP_VALUE, TRUE);
} else {
item = combo_box_item_create(parent, 0, 0, 0, 0);
widget_set_value(item, iter->value);
}
ENSURE(item);
if (combo_box->localize_options) {
widget_set_tr_text(item, text);
} else {
widget_set_text_utf8(item, text);
}
w = widget_measure_text(item, item->text.str);
max_w = tk_max_int(w, max_w);
iter = iter->next;
}
w = tk_max_int(max_w + extra_w, win->w);
widget_resize(win, w, win->h);
return RET_OK;
}
static ret_t combo_box_ex_on_layout_children_for_combobox_popup(widget_t* widget) {
combo_box_t* combo_box = COMBO_BOX(widget);
return_value_if_fail(combo_box != NULL, RET_BAD_PARAMS);
if (combo_box->combobox_popup != NULL && combo_box->open_window == NULL) {
point_t p = {0, 0};
int32_t w = combo_box->combobox_popup->w;
int32_t margin = COMBO_BOX_EX_DEFAULT_MARGIN;
int32_t item_height = combo_box->item_height;
int32_t nr = combo_box_count_options(widget);
int32_t h = nr * item_height + 2 * margin;
if (nr <= COMBO_BOX_EX_DEFAULT_MAXNR) {
h = nr * item_height + 2 * margin;
} else {
h = COMBO_BOX_EX_DEFAULT_MAXNR * item_height + 2 * margin;
}
combo_box_combobox_popup_calc_position(widget, w, h, &p);
widget_move_resize(combo_box->combobox_popup, p.x, p.y, w, h);
}
return RET_OK;
}
static widget_t* combo_box_ex_create_scroll_popup(combo_box_t* combo_box) {
value_t v;
widget_t* win = NULL;
widget_t* list_view = NULL;
widget_t* scroll_bar = NULL;
widget_t* scroll_view = NULL;
widget_t* combo_box_win = NULL;
const char* applet_name = NULL;
widget_t* widget = WIDGET(combo_box);
int32_t margin = COMBO_BOX_EX_DEFAULT_MARGIN;
int32_t item_height = combo_box->item_height;
int32_t nr = combo_box_count_options(widget);
int32_t w = widget->w;
int32_t h = nr * item_height + 2 * margin;
if (nr <= COMBO_BOX_EX_DEFAULT_MAXNR) {
h = nr * item_height + 2 * margin;
} else {
h = COMBO_BOX_EX_DEFAULT_MAXNR * item_height + 2 * margin;
}
// create popup
win = popup_create(NULL, 0, 0, w, h);
combo_box_win = widget_get_window(widget);
applet_name = widget_get_prop_str(combo_box_win, WIDGET_PROP_APPLET_NAME, NULL);
widget_set_prop_str(win, WIDGET_PROP_APPLET_NAME, applet_name);
value_set_bool(&v, TRUE);
widget_set_prop(win, WIDGET_PROP_CLOSE_WHEN_CLICK_OUTSIDE, &v);
widget_set_prop_str(win, WIDGET_PROP_THEME, "combobox_ex_popup");
w -= 2 * margin;
h -= 2 * margin;
// create list view
list_view = list_view_create(win, margin, margin, w, h);
widget_set_prop(list_view, WIDGET_PROP_AUTO_HIDE_SCROLL_BAR, &v);
value_set_int32(&v, item_height);
widget_set_prop(list_view, WIDGET_PROP_ITEM_HEIGHT, &v);
// create scroll view
scroll_view = scroll_view_create(list_view, 0, 0, -12, h);
scroll_bar = scroll_bar_create(list_view, 0, 0, 12, h);
widget_use_style(win, "combobox_popup");
combo_box_ex_create_popup_items(combo_box, scroll_view, item_height + 2 * margin + scroll_bar->w);
w = win->w;
h = win->h;
w -= 2 * margin;
h -= 2 * margin;
widget_move_resize(list_view, margin, margin, w, h);
widget_move_resize(scroll_view, 0, 0, w - scroll_bar->w, h);
widget_move(scroll_bar, w - scroll_bar->w, 0);
widget_layout(win);
combo_box->combobox_popup = win;
widget_on(win, EVT_WINDOW_CLOSE, combo_box_combobox_popup_on_close_func, widget);
return win;
}
static widget_t* custom_open_popup(widget_t* combo_box) {
return combo_box_ex_create_scroll_popup(COMBO_BOX(combo_box));
}
static ret_t combo_box_ex_init(widget_t* widget) {
ret_t ret = widget_vtable_init_by_parent(widget, WIDGET_VTABLE_GET_VTABLE(combo_box_ex));
return_value_if_fail(ret == RET_OK || ret == RET_NOT_IMPL, ret);
return combo_box_set_custom_open_popup(widget, custom_open_popup,
combo_box_ex_on_layout_children_for_combobox_popup);
}
TK_DECL_VTABLE(combo_box_ex) = {.size = sizeof(combo_box_t),
.inputable = TRUE,
.type = WIDGET_TYPE_COMBO_BOX_EX,
.focusable = TRUE,
.space_key_to_activate = TRUE,
.return_key_to_activate = TRUE,
.get_parent_vt = TK_GET_PARENT_VTABLE(combo_box),
.init = combo_box_ex_init,
.create = combo_box_ex_create};
widget_t* combo_box_ex_create(widget_t* parent, xy_t x, xy_t y, wh_t w, wh_t h) {
widget_t* widget = widget_create(parent, TK_REF_VTABLE(combo_box_ex), x, y, w, h);
return_value_if_fail(widget != NULL, NULL);
combo_box_ex_init(widget);
return widget;
}
|
0 |
repos/awtk/src/ext_widgets
|
repos/awtk/src/ext_widgets/combo_box_ex/combo_box_ex.h
|
/**
* File: combo_box_ex.h
* Author: AWTK Develop Team
* Brief: combo_box_ex
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2019-08-21 Li DaHeng <[email protected]> created
*
*/
#ifndef TK_COMBO_BOX_EX_H
#define TK_COMBO_BOX_EX_H
#include "widgets/combo_box.h"
BEGIN_C_DECLS
/**
* @class combo_box_ex_t
* @parent combo_box_t
* @annotation ["scriptable","design","widget"]
* 扩展combo_box控件。支持以下功能：
* * 支持滚动。项目比较多时显示滚动条。
* * 自动调整弹出窗口的宽度。根据最长文本自动调整弹出窗口的宽度。
* * 支持分组显示。如果item的文本以"seperator."开头，视为一个分组开始，其后的文本为分组的标题。比如: "seperator.basic"，会创建一个basic为标题的分组。
*/
typedef struct _combo_box_ex_t {
combo_box_t combo_box;
} combo_box_ex_t;
/**
* @method combo_box_ex_create
* 创建combo_box_ex对象
* @annotation ["constructor", "scriptable"]
* @param {widget_t*} parent 父控件
* @param {xy_t} x x坐标
* @param {xy_t} y y坐标
* @param {wh_t} w 宽度
* @param {wh_t} h 高度
*
* @return {widget_t*} 对象。
*/
widget_t* combo_box_ex_create(widget_t* parent, xy_t x, xy_t y, wh_t w, wh_t h);
#define WIDGET_TYPE_COMBO_BOX_EX "combo_box_ex"
#define COMBO_BOX_EX_SEPERATOR_PREFIX "seperator."
#define COMBO_BOX_EX(widget) ((combo_box_ex_t*)(combo_box_cast(WIDGET(widget))))
/*public for subclass and runtime type check*/
TK_EXTERN_VTABLE(combo_box_ex);
END_C_DECLS
#endif
|
0 |
repos/awtk/src/ext_widgets
|
repos/awtk/src/ext_widgets/scroll_label/hscroll_label.c
|
/**
* File: hscroll_label.h
* Author: AWTK Develop Team
* Brief: hscroll_label
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2019-07-05 Li XianJing <[email protected]> created
*
*/
#include "tkc/mem.h"
#include "tkc/utils.h"
#include "tkc/time_now.h"
#include "base/widget_vtable.h"
#include "scroll_label/hscroll_label.h"
static ret_t hscroll_label_remove_timer(widget_t* widget);
static ret_t hscroll_label_check_and_start(widget_t* widget);
static int32_t hscroll_label_get_range(widget_t* widget, bool_t stop_at_begin);
static bool_t hscroll_label_is_running(widget_t* widget) {
hscroll_label_t* hscroll_label = HSCROLL_LABEL(widget);
return_value_if_fail(hscroll_label != NULL, RET_BAD_PARAMS);
return hscroll_label->timer_id != TK_INVALID_ID;
}
static uint32_t hscroll_label_get_loop_end_and_begin_distance(widget_t* widget) {
int32_t w, left_margin, right_margin;
hscroll_label_t* hscroll_label = HSCROLL_LABEL(widget);
return_value_if_fail(hscroll_label != NULL, 0);
if (hscroll_label->loop_interval_distance >= 0) {
return hscroll_label->loop_interval_distance;
} else {
left_margin = style_get_int(widget->astyle, STYLE_ID_MARGIN_LEFT, 2);
right_margin = style_get_int(widget->astyle, STYLE_ID_MARGIN_RIGHT, 2);
w = widget->w - left_margin - right_margin;
return w;
}
}
static ret_t hscroll_label_do_paint_self(widget_t* widget, canvas_t* c, uint32_t left_margin,
uint32_t right_margin) {
rect_t r = {0, 0, 0, 0};
wstr_t* text = &(widget->text);
uint32_t w = widget->w - left_margin - right_margin;
hscroll_label_t* hscroll_label = HSCROLL_LABEL(widget);
ENSURE(hscroll_label);
hscroll_label->text_w = canvas_measure_text(c, text->str, text->size);
if (hscroll_label->text_w != hscroll_label->old_text_w) {
if (tk_str_eq(widget->state, WIDGET_STATE_FOCUSED)) {
hscroll_label_start(widget);
} else {
hscroll_label_check_and_start(widget);
}
hscroll_label->old_text_w = hscroll_label->text_w;
}
if (w < hscroll_label->text_w && hscroll_label->ellipses && !hscroll_label->yoyo &&
!hscroll_label_is_running(widget)) {
r = rect_init(left_margin, 0, w, widget->h);
return widget_draw_text_in_rect(widget, c, text->str, text->size, &r, TRUE);
}
if (w > hscroll_label->text_w) {
int32_t align_v = style_get_int(widget->astyle, STYLE_ID_TEXT_ALIGN_V, ALIGN_V_MIDDLE);
int32_t align_h = style_get_int(widget->astyle, STYLE_ID_TEXT_ALIGN_H, ALIGN_H_LEFT);
canvas_set_text_align(c, (align_h_t)align_h, (align_v_t)align_v);
} else {
canvas_set_text_align(c, ALIGN_H_LEFT, ALIGN_V_MIDDLE);
}
r = rect_init(left_margin - hscroll_label->xoffset, 0, w, widget->h);
widget_draw_text_in_rect(widget, c, text->str, text->size, &r, FALSE);
if (hscroll_label->stop_at_begin) {
int32_t range = hscroll_label_get_range(widget, FALSE);
int32_t offset = hscroll_label->xoffset - range - hscroll_label_get_loop_end_and_begin_distance(widget);
if (offset > 0) {
r = rect_init(w - offset + left_margin, 0, w, widget->h);
widget_draw_text_in_rect(widget, c, text->str, text->size, &r, FALSE);
}
}
return RET_OK;
}
static ret_t hscroll_label_on_paint_self(widget_t* widget, canvas_t* c) {
rect_t save_r = {0, 0, 0, 0};
rect_t clip_r = {0, 0, 0, 0};
rect_t widget_r = {0, 0, 0, 0};
if (widget->text.size > 0) {
style_t* style = widget->astyle;
color_t black = color_init(0, 0, 0, 0xff);
const char* font = style_get_str(style, STYLE_ID_FONT_NAME, NULL);
int32_t left_margin = style_get_int(style, STYLE_ID_MARGIN_LEFT, 2);
int32_t right_margin = style_get_int(style, STYLE_ID_MARGIN_RIGHT, 2);
int32_t font_size = style_get_int(style, STYLE_ID_FONT_SIZE, TK_DEFAULT_FONT_SIZE);
color_t text_color = style_get_color(style, STYLE_ID_TEXT_COLOR, black);
int32_t w = widget->w - left_margin - right_margin;
canvas_get_clip_rect(c, &save_r);
widget_r = rect_init(c->ox + left_margin, c->oy, w, widget->h);
clip_r = rect_intersect(&save_r, &widget_r);
canvas_set_clip_rect(c, &clip_r);
canvas_set_font(c, font, font_size);
canvas_set_text_color(c, text_color);
// canvas_set_text_align(c, ALIGN_H_LEFT, ALIGN_V_MIDDLE);
hscroll_label_do_paint_self(widget, c, left_margin, right_margin);
canvas_set_clip_rect(c, &save_r);
}
return RET_OK;
}
ret_t hscroll_label_set_xoffset(widget_t* widget, int32_t xoffset) {
hscroll_label_t* hscroll_label = HSCROLL_LABEL(widget);
return_value_if_fail(hscroll_label != NULL, RET_BAD_PARAMS);
hscroll_label->xoffset = xoffset;
return widget_invalidate_force(widget, NULL);
}
ret_t hscroll_label_set_lull(widget_t* widget, int32_t lull) {
hscroll_label_t* hscroll_label = HSCROLL_LABEL(widget);
return_value_if_fail(hscroll_label != NULL, RET_BAD_PARAMS);
hscroll_label->lull = lull;
return RET_OK;
}
ret_t hscroll_label_set_duration(widget_t* widget, int32_t duration) {
hscroll_label_t* hscroll_label = HSCROLL_LABEL(widget);
return_value_if_fail(hscroll_label != NULL, RET_BAD_PARAMS);
hscroll_label->duration = duration;
return RET_OK;
}
ret_t hscroll_label_set_delay(widget_t* widget, uint32_t delay) {
hscroll_label_t* hscroll_label = HSCROLL_LABEL(widget);
return_value_if_fail(hscroll_label != NULL, RET_BAD_PARAMS);
hscroll_label->delay = delay;
return RET_OK;
}
ret_t hscroll_label_set_loop_interval_distance(widget_t* widget, int32_t loop_interval_distance) {
hscroll_label_t* hscroll_label = HSCROLL_LABEL(widget);
return_value_if_fail(hscroll_label != NULL, RET_BAD_PARAMS);
hscroll_label->loop_interval_distance = loop_interval_distance;
return RET_OK;
}
ret_t hscroll_label_set_speed(widget_t* widget, float_t speed) {
hscroll_label_t* hscroll_label = HSCROLL_LABEL(widget);
return_value_if_fail(hscroll_label != NULL, RET_BAD_PARAMS);
return_value_if_fail(speed >= 0, RET_BAD_PARAMS);
hscroll_label->speed = speed;
return RET_OK;
}
ret_t hscroll_label_set_loop(widget_t* widget, bool_t loop) {
hscroll_label_t* hscroll_label = HSCROLL_LABEL(widget);
return_value_if_fail(hscroll_label != NULL, RET_BAD_PARAMS);
hscroll_label->loop = loop;
return RET_OK;
}
ret_t hscroll_label_set_only_focus(widget_t* widget, bool_t only_focus) {
hscroll_label_t* hscroll_label = HSCROLL_LABEL(widget);
return_value_if_fail(hscroll_label != NULL, RET_BAD_PARAMS);
hscroll_label->only_focus = only_focus;
return RET_OK;
}
ret_t hscroll_label_set_only_parent_focus(widget_t* widget, bool_t only_parent_focus) {
hscroll_label_t* hscroll_label = HSCROLL_LABEL(widget);
return_value_if_fail(hscroll_label != NULL, RET_BAD_PARAMS);
hscroll_label->only_parent_focus = only_parent_focus;
return RET_OK;
}
ret_t hscroll_label_set_yoyo(widget_t* widget, bool_t yoyo) {
hscroll_label_t* hscroll_label = HSCROLL_LABEL(widget);
return_value_if_fail(hscroll_label != NULL, RET_BAD_PARAMS);
hscroll_label->yoyo = yoyo;
return RET_OK;
}
ret_t hscroll_label_set_ellipses(widget_t* widget, bool_t ellipses) {
hscroll_label_t* hscroll_label = HSCROLL_LABEL(widget);
return_value_if_fail(hscroll_label != NULL, RET_BAD_PARAMS);
hscroll_label->ellipses = ellipses;
return RET_OK;
}
ret_t hscroll_label_set_stop_at_begin(widget_t* widget, bool_t stop_at_begin) {
hscroll_label_t* hscroll_label = HSCROLL_LABEL(widget);
return_value_if_fail(hscroll_label != NULL, RET_BAD_PARAMS);
hscroll_label->stop_at_begin = stop_at_begin;
return RET_OK;
}
static ret_t hscroll_label_get_prop(widget_t* widget, const char* name, value_t* v) {
hscroll_label_t* hscroll_label = HSCROLL_LABEL(widget);
return_value_if_fail(hscroll_label != NULL && name != NULL && v != NULL, RET_BAD_PARAMS);
if (tk_str_eq(name, HSCROLL_LABEL_PROP_LOOP)) {
value_set_bool(v, hscroll_label->loop);
return RET_OK;
} else if (tk_str_eq(name, HSCROLL_LABEL_PROP_LULL)) {
value_set_int(v, hscroll_label->lull);
return RET_OK;
} else if (tk_str_eq(name, HSCROLL_LABEL_PROP_DURATION)) {
value_set_int(v, hscroll_label->duration);
return RET_OK;
} else if (tk_str_eq(name, HSCROLL_LABEL_PROP_SPEED)) {
value_set_float32(v, hscroll_label->speed);
return RET_OK;
} else if (tk_str_eq(name, HSCROLL_LABEL_PROP_XOFFSET)) {
value_set_int(v, hscroll_label->xoffset);
return RET_OK;
} else if (tk_str_eq(name, HSCROLL_LABEL_PROP_YOYO)) {
value_set_bool(v, hscroll_label->yoyo);
return RET_OK;
} else if (tk_str_eq(name, HSCROLL_LABEL_PROP_ELLIPSES)) {
value_set_bool(v, hscroll_label->ellipses);
return RET_OK;
} else if (tk_str_eq(name, HSCROLL_LABEL_PROP_ONLY_FOCUS)) {
value_set_bool(v, hscroll_label->only_focus);
return RET_OK;
} else if (tk_str_eq(name, HSCROLL_LABEL_PROP_ONLY_PARENT_FOCUS)) {
value_set_bool(v, hscroll_label->only_parent_focus);
return RET_OK;
} else if (tk_str_eq(name, HSCROLL_LABEL_PROP_STOP_AT_BEGIN)) {
value_set_bool(v, hscroll_label->stop_at_begin);
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_DELAY)) {
value_set_uint32(v, hscroll_label->delay);
return RET_OK;
} else if (tk_str_eq(name, HSCROLL_LABEL_PROP_LOOP_INTERVAL_DISTANCE)) {
value_set_int32(v, hscroll_label->loop_interval_distance);
return RET_OK;
}
return RET_NOT_FOUND;
}
static ret_t hscroll_label_set_prop(widget_t* widget, const char* name, const value_t* v) {
hscroll_label_t* hscroll_label = HSCROLL_LABEL(widget);
ENSURE(hscroll_label);
return_value_if_fail(widget != NULL && name != NULL && v != NULL, RET_BAD_PARAMS);
if (tk_str_eq(name, HSCROLL_LABEL_PROP_LOOP)) {
return hscroll_label_set_loop(widget, value_bool(v));
} else if (tk_str_eq(name, HSCROLL_LABEL_PROP_LULL)) {
return hscroll_label_set_lull(widget, value_int(v));
} else if (tk_str_eq(name, HSCROLL_LABEL_PROP_DURATION)) {
return hscroll_label_set_duration(widget, value_int(v));
} else if (tk_str_eq(name, HSCROLL_LABEL_PROP_SPEED)) {
return hscroll_label_set_speed(widget, value_float32(v));
} else if (tk_str_eq(name, HSCROLL_LABEL_PROP_XOFFSET)) {
return hscroll_label_set_xoffset(widget, value_int(v));
} else if (tk_str_eq(name, HSCROLL_LABEL_PROP_YOYO)) {
return hscroll_label_set_yoyo(widget, value_bool(v));
} else if (tk_str_eq(name, HSCROLL_LABEL_PROP_ELLIPSES)) {
return hscroll_label_set_ellipses(widget, value_bool(v));
} else if (tk_str_eq(name, HSCROLL_LABEL_PROP_ONLY_FOCUS)) {
return hscroll_label_set_only_focus(widget, value_bool(v));
} else if (tk_str_eq(name, HSCROLL_LABEL_PROP_ONLY_PARENT_FOCUS)) {
return hscroll_label_set_only_parent_focus(widget, value_bool(v));
} else if (tk_str_eq(name, WIDGET_PROP_TEXT)) {
if (hscroll_label->timer_id != TK_INVALID_ID) {
hscroll_label->elapsed = 0;
}
return RET_NOT_FOUND;
} else if (tk_str_eq(name, HSCROLL_LABEL_PROP_STOP_AT_BEGIN)) {
return hscroll_label_set_stop_at_begin(widget, value_bool(v));
} else if (tk_str_eq(name, WIDGET_PROP_DELAY)) {
return hscroll_label_set_delay(widget, value_uint32(v));
} else if (tk_str_eq(name, HSCROLL_LABEL_PROP_LOOP_INTERVAL_DISTANCE)) {
return hscroll_label_set_loop_interval_distance(widget, value_int32(v));
}
return RET_NOT_FOUND;
}
static int32_t hscroll_label_get_range(widget_t* widget, bool_t stop_at_begin) {
hscroll_label_t* hscroll_label = HSCROLL_LABEL(widget);
ENSURE(hscroll_label);
int32_t left_margin = style_get_int(widget->astyle, STYLE_ID_MARGIN_LEFT, 2);
int32_t right_margin = style_get_int(widget->astyle, STYLE_ID_MARGIN_RIGHT, 2);
int32_t w = widget->w - left_margin - right_margin;
if (stop_at_begin) {
return hscroll_label->text_w + hscroll_label_get_loop_end_and_begin_distance(widget);
} else {
return hscroll_label->text_w - w;
}
}
ret_t hscroll_label_step(widget_t* widget) {
ret_t ret = RET_REPEAT;
hscroll_label_t* hscroll_label = HSCROLL_LABEL(widget);
ENSURE(hscroll_label);
float_t percent = 0;
uint32_t duration = 0;
int32_t range = hscroll_label_get_range(widget, hscroll_label->stop_at_begin);
if (range < 0) {
range = 0;
ret = RET_REMOVE;
}
duration = (hscroll_label->speed > 0 && range > 0) ? (range / hscroll_label->speed)
: hscroll_label->duration;
if (hscroll_label->elapsed >= duration) {
hscroll_label->elapsed = duration;
}
percent = (float_t)hscroll_label->elapsed / (float_t)(duration);
if (hscroll_label->reversed) {
percent = 1 - percent;
}
hscroll_label->xoffset = range * percent;
if (hscroll_label->xoffset > range) {
ret = RET_REMOVE;
}
widget_invalidate_force(widget, NULL);
if (ret == RET_REMOVE) {
hscroll_label_remove_timer(widget);
}
return ret;
}
static ret_t hscroll_label_check_and_start(widget_t* widget) {
hscroll_label_t* hscroll_label = HSCROLL_LABEL(widget);
return_value_if_fail(widget != NULL && hscroll_label != NULL, RET_BAD_PARAMS);
if (hscroll_label->only_focus) {
if (widget->focused) {
hscroll_label_start(widget);
}
} else if (hscroll_label->only_parent_focus) {
if (widget->parent->focused) {
hscroll_label_start(widget);
}
} else {
hscroll_label_start(widget);
}
return RET_OK;
}
static ret_t hscroll_label_on_timer_start(const timer_info_t* info) {
widget_t* widget = WIDGET(info->ctx);
hscroll_label_t* hscroll_label = HSCROLL_LABEL(widget);
return_value_if_fail(hscroll_label != NULL, RET_BAD_PARAMS);
hscroll_label->timer_id = TK_INVALID_ID;
hscroll_label_check_and_start(widget);
widget_invalidate_force(widget, NULL);
return RET_REMOVE;
}
static ret_t hscroll_label_on_timer_stop(const timer_info_t* info) {
widget_t* widget = WIDGET(info->ctx);
hscroll_label_t* hscroll_label = HSCROLL_LABEL(widget);
return_value_if_fail(hscroll_label != NULL, RET_BAD_PARAMS);
hscroll_label_stop(widget);
return RET_REMOVE;
}
static ret_t hscroll_label_on_timer(const timer_info_t* info) {
ret_t ret = RET_OK;
widget_t* widget = WIDGET(info->ctx);
hscroll_label_t* hscroll_label = HSCROLL_LABEL(widget);
uint32_t duration = 0;
return_value_if_fail(hscroll_label != NULL, RET_BAD_PARAMS);
if (!hscroll_label->paused) {
hscroll_label->elapsed += info->duration;
} else {
return RET_REPEAT;
}
if (hscroll_label->only_focus) {
if (!widget->focusable || !widget->focused) {
hscroll_label_stop(widget);
return RET_REMOVE;
}
} else if (hscroll_label->only_parent_focus) {
if (!widget->parent->focused) {
hscroll_label_stop(widget);
return RET_REMOVE;
}
}
ret = hscroll_label_step(widget);
if (hscroll_label->speed > 0) {
int32_t range = hscroll_label_get_range(widget, hscroll_label->stop_at_begin);
if (range > 0) {
duration = range / hscroll_label->speed;
}
} else {
duration = hscroll_label->duration;
}
if (hscroll_label->elapsed >= duration) {
uint32_t lull = hscroll_label->lull;
hscroll_label->elapsed = 0;
if (!hscroll_label->loop) {
ret = RET_REMOVE;
hscroll_label_remove_timer(widget);
} else {
if (hscroll_label->lull > 0) {
ret = RET_REMOVE;
hscroll_label_remove_timer(widget);
hscroll_label->timer_id = widget_add_timer(widget, hscroll_label_on_timer_start, lull);
}
}
if (hscroll_label->yoyo) {
hscroll_label->reversed = !hscroll_label->reversed;
}
}
return ret;
}
static ret_t hscroll_label_delay_on_timer(const timer_info_t* info) {
hscroll_label_t* hscroll_label = HSCROLL_LABEL(info->ctx);
return_value_if_fail(hscroll_label != NULL, RET_BAD_PARAMS);
hscroll_label->timer_id = widget_add_timer(WIDGET(hscroll_label), hscroll_label_on_timer, 16);
return RET_OK;
}
ret_t hscroll_label_start(widget_t* widget) {
hscroll_label_t* hscroll_label = HSCROLL_LABEL(widget);
return_value_if_fail(hscroll_label != NULL, RET_BAD_PARAMS);
if (hscroll_label->timer_id == TK_INVALID_ID) {
hscroll_label->elapsed = 0;
if (hscroll_label->delay == 0) {
hscroll_label->timer_id = widget_add_timer(widget, hscroll_label_on_timer, 16);
} else {
hscroll_label->timer_id = widget_add_timer(widget, hscroll_label_delay_on_timer, hscroll_label->delay);
}
}
return RET_OK;
}
static ret_t hscroll_label_remove_timer(widget_t* widget) {
hscroll_label_t* hscroll_label = HSCROLL_LABEL(widget);
return_value_if_fail(hscroll_label != NULL, RET_BAD_PARAMS);
if (hscroll_label->timer_id != TK_INVALID_ID) {
timer_remove(hscroll_label->timer_id);
hscroll_label->timer_id = TK_INVALID_ID;
}
return RET_OK;
}
ret_t hscroll_label_stop(widget_t* widget) {
hscroll_label_t* hscroll_label = HSCROLL_LABEL(widget);
return_value_if_fail(hscroll_label != NULL, RET_BAD_PARAMS);
hscroll_label->xoffset = 0;
hscroll_label->reversed = FALSE;
widget_invalidate(widget, NULL);
return hscroll_label_remove_timer(widget);
}
static ret_t hscroll_label_on_destroy(widget_t* widget) {
if (hscroll_label_is_running(widget)) {
hscroll_label_stop(widget);
}
return RET_OK;
}
static ret_t hscroll_label_on_event(widget_t* widget, event_t* e) {
uint16_t type = e->type;
hscroll_label_t* hscroll_label = HSCROLL_LABEL(widget);
return_value_if_fail(hscroll_label != NULL && widget != NULL, RET_BAD_PARAMS);
switch (type) {
#ifdef WITH_STATE_ACTIVATED
case EVT_ACTIVATED: {
#else
case EVT_FOCUS: {
#endif
if (!hscroll_label_is_running(widget)) {
hscroll_label_start(widget);
}
break;
}
#ifdef WITH_STATE_ACTIVATED
case EVT_UNACTIVATED:
#else
case EVT_BLUR:
#endif
if (!hscroll_label->only_focus) {
break;
}
case EVT_POINTER_DOWN_ABORT: {
if (hscroll_label_is_running(widget)) {
hscroll_label_stop(widget);
}
break;
}
case EVT_POINTER_ENTER: {
if (!hscroll_label->only_focus && !hscroll_label->only_parent_focus) {
hscroll_label->paused = TRUE;
}
break;
}
case EVT_POINTER_UP: {
hscroll_label->paused = FALSE;
break;
}
case EVT_POINTER_LEAVE: {
if (!hscroll_label->only_focus && !hscroll_label->only_parent_focus) {
hscroll_label->paused = FALSE;
}
break;
}
default:
break;
}
return RET_OK;
}
static ret_t hscroll_label_on_parent_focus_changed(void* ctx, event_t* e) {
widget_t* widget = WIDGET(ctx);
hscroll_label_t* hscroll_label = HSCROLL_LABEL(widget);
return_value_if_fail(hscroll_label != NULL, RET_BAD_PARAMS);
if (hscroll_label->only_parent_focus) {
if (e->type == EVT_FOCUS) {
hscroll_label_start(widget);
widget_set_state(widget, WIDGET_STATE_FOCUSED);
} else {
hscroll_label_stop(widget);
widget_set_state(widget, WIDGET_STATE_NORMAL);
}
}
return RET_OK;
}
static ret_t hscroll_label_on_attach_parent(widget_t* widget, widget_t* parent) {
widget_on_with_tag(parent, EVT_FOCUS, hscroll_label_on_parent_focus_changed, widget,
tk_pointer_to_int(widget));
widget_on_with_tag(parent, EVT_BLUR, hscroll_label_on_parent_focus_changed, widget,
tk_pointer_to_int(widget));
return RET_OK;
}
static ret_t hscroll_label_on_detach_parent(widget_t* widget, widget_t* parent) {
widget_off_by_tag(parent, tk_pointer_to_int(widget));
return RET_OK;
}
static ret_t hscroll_label_init(widget_t* widget) {
hscroll_label_t* hscroll_label = HSCROLL_LABEL(widget);
return_value_if_fail(hscroll_label != NULL, RET_BAD_PARAMS);
hscroll_label->xoffset = 0;
hscroll_label->lull = 3000;
hscroll_label->duration = 5000;
hscroll_label->loop = FALSE;
hscroll_label->yoyo = FALSE;
hscroll_label->ellipses = FALSE;
hscroll_label->only_focus = FALSE;
hscroll_label->stop_at_begin = FALSE;
hscroll_label->paused = FALSE;
hscroll_label->timer_id = TK_INVALID_ID;
hscroll_label->loop_interval_distance = -1;
return RET_OK;
}
static const char* const s_hscroll_label_properties[] = {HSCROLL_LABEL_PROP_YOYO,
HSCROLL_LABEL_PROP_LOOP,
HSCROLL_LABEL_PROP_LULL,
HSCROLL_LABEL_PROP_DURATION,
HSCROLL_LABEL_PROP_SPEED,
HSCROLL_LABEL_PROP_ELLIPSES,
HSCROLL_LABEL_PROP_ONLY_FOCUS,
HSCROLL_LABEL_PROP_ONLY_PARENT_FOCUS,
NULL};
TK_DECL_VTABLE(hscroll_label) = {.size = sizeof(hscroll_label_t),
.type = WIDGET_TYPE_HSCROLL_LABEL,
.clone_properties = s_hscroll_label_properties,
.get_parent_vt = TK_GET_PARENT_VTABLE(widget),
.create = hscroll_label_create,
.init = hscroll_label_init,
.on_destroy = hscroll_label_on_destroy,
.on_attach_parent = hscroll_label_on_attach_parent,
.on_detach_parent = hscroll_label_on_detach_parent,
.set_prop = hscroll_label_set_prop,
.get_prop = hscroll_label_get_prop,
.on_event = hscroll_label_on_event,
.on_paint_self = hscroll_label_on_paint_self};
widget_t* hscroll_label_create(widget_t* parent, xy_t x, xy_t y, wh_t w, wh_t h) {
widget_t* widget = widget_create(parent, TK_REF_VTABLE(hscroll_label), x, y, w, h);
return_value_if_fail(hscroll_label_init(widget) == RET_OK, NULL);
return widget;
}
widget_t* hscroll_label_cast(widget_t* widget) {
return_value_if_fail(WIDGET_IS_INSTANCE_OF(widget, hscroll_label), NULL);
return widget;
}
|
0 |
repos/awtk/src/ext_widgets
|
repos/awtk/src/ext_widgets/scroll_label/hscroll_label.h
|
/**
* File: hscroll_label.h
* Author: AWTK Develop Team
* Brief: hscroll_label
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2019-07-05 Li XianJing <[email protected]> created
*
*/
#ifndef TK_HSCROLL_LABEL_H
#define TK_HSCROLL_LABEL_H
#include "base/widget.h"
BEGIN_C_DECLS
/**
* @class hscroll_label_t
* @parent widget_t
* @annotation ["scriptable","design","widget"]
*
* 可水平滚动的文本控件，方便实现长文本滚动。
*
*
hscroll\_label\_t是[widget\_t](widget_t.md)的子类控件，widget\_t的函数均适用于hscroll\_label\_t控件。
*
* > 更多用法请参考：[hscroll_label.xml](
*https://github.com/zlgopen/awtk/blob/master/design/default/ui/hscroll_label.xml)
*
* 可用通过style来设置控件的显示风格，如字体的大小和颜色等等。如：
*
* ```xml
<style name="default" text_color="black">
<normal />
<focused />
</style>
* ```
*
* > 更多用法请参考：
* [theme default](
*https://github.com/zlgopen/awtk/blob/master/design/default/styles/default.xml)
*
*/
typedef struct _hscroll_label_t {
widget_t widget;
/**
* @property {bool_t} only_focus
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 只有处于focus时才滚动(缺省否)。
*/
bool_t only_focus;
/**
* @property {bool_t} only_parent_focus
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 只有父控件处于focus时才滚动(缺省否)。
*/
bool_t only_parent_focus;
/**
* @property {bool_t} loop
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* loop是否循环滚动(缺省FALSE)。
*/
bool_t loop;
/**
* @property {bool_t} yoyo
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 是否往返滚动(缺省FALSE)。
*/
bool_t yoyo;
/**
* @property {bool_t} ellipses
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 文本显示不下时，在行尾显示省略号(缺省FALSE)。
*/
bool_t ellipses;
/**
* @property {int32_t} lull
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 滚动之间的间歇时间(毫秒)，缺省3000ms。
*/
int32_t lull;
/**
* @property {int32_t} duration
* @annotation ["set_prop","get_prop","readable","scriptable"]
* 滚动一次需要的时间(毫秒)，缺省5000ms。
*/
int32_t duration;
/**
* @property {uint32_t} delay
* @annotation ["set_prop","get_prop","readable","scriptable"]
* 延迟多久才开始滚动，缺省0ms。
*/
uint32_t delay;
/**
* @property {float_t} speed
* @annotation ["set_prop","get_prop","readable","scriptable"]
* 滚动速度(px/ms)（设置后 duration 不生效）。
*/
float_t speed;
/**
* @property {int32_t} xoffset
* @annotation ["set_prop","get_prop","readable","scriptable"]
* 偏移量。
*/
int32_t xoffset;
/**
* @property {int32_t} text_w
* @annotation ["set_prop","get_prop","readable","scriptable"]
* 文本的宽度。
*/
int32_t text_w;
/**
* @property {bool_t} stop_at_begin
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 滚动完毕后停在文本开头(缺省FALSE)。
* > 注：yoyo 为 TRUE 时，该功能失效。
*/
bool_t stop_at_begin;
/**
* @property {int32_t} loop_interval_distance
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 滚动文本结尾和文本开头间隔距离(缺省值为 -1，小于 0 视为使用控件宽度作为间隔距离)。
*/
int32_t loop_interval_distance;
/*private*/
int32_t old_text_w;
uint32_t timer_id;
uint32_t elapsed;
bool_t paused;
bool_t pressed;
bool_t reversed;
} hscroll_label_t;
/**
* @method hscroll_label_create
* @annotation ["constructor", "scriptable"]
* 创建hscroll_label对象
* @param {widget_t*} parent 父控件
* @param {xy_t} x x坐标
* @param {xy_t} y y坐标
* @param {wh_t} w 宽度
* @param {wh_t} h 高度
*
* @return {widget_t*} 对象。
*/
widget_t* hscroll_label_create(widget_t* parent, xy_t x, xy_t y, wh_t w, wh_t h);
/**
* @method hscroll_label_set_lull
* 设置lull。
* @annotation ["scriptable"]
* @param {widget_t*} widget 控件对象。
* @param {int32_t} lull 间歇时间(毫秒)。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t hscroll_label_set_lull(widget_t* widget, int32_t lull);
/**
* @method hscroll_label_set_duration
* 设置duration。
* @annotation ["scriptable"]
* @param {widget_t*} widget 控件对象。
* @param {int32_t} duration 滚动时间(毫秒)。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t hscroll_label_set_duration(widget_t* widget, int32_t duration);
/**
* @method hscroll_label_set_speed
* 设置speed（设置后 duration 不生效）。
* @annotation ["scriptable"]
* @param {widget_t*} widget 控件对象。
* @param {float_t} speed 滚动速度(px/ms)。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t hscroll_label_set_speed(widget_t* widget, float_t speed);
/**
* @method hscroll_label_set_only_focus
* 设置only_focus。
* @annotation ["scriptable"]
* @param {widget_t*} widget 控件对象。
* @param {bool_t} only_focus 是否只有处于focus时才滚动。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t hscroll_label_set_only_focus(widget_t* widget, bool_t only_focus);
/**
* @method hscroll_label_set_only_parent_focus
* 设置only_parent_focus。
* @annotation ["scriptable"]
* @param {widget_t*} widget 控件对象。
* @param {bool_t} only_parent_focus 是否只有处于focus时才滚动。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t hscroll_label_set_only_parent_focus(widget_t* widget, bool_t only_parent_focus);
/**
* @method hscroll_label_set_loop
* 设置loop。
* @annotation ["scriptable"]
* @param {widget_t*} widget 控件对象。
* @param {bool_t} loop 是否循环滚动。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t hscroll_label_set_loop(widget_t* widget, bool_t loop);
/**
* @method hscroll_label_set_yoyo
* 设置yoyo。
* @annotation ["scriptable"]
* @param {widget_t*} widget 控件对象。
* @param {bool_t} yoyo 是否往返滚动。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t hscroll_label_set_yoyo(widget_t* widget, bool_t yoyo);
/**
* @method hscroll_label_set_ellipses
* 设置ellipses。
* @annotation ["scriptable"]
* @param {widget_t*} widget 控件对象。
* @param {bool_t} ellipses 是否在文本超长时在行尾显示"..."。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t hscroll_label_set_ellipses(widget_t* widget, bool_t ellipses);
/**
* @method hscroll_label_set_stop_at_begin
* 设置stop_at_begin。
* @annotation ["scriptable"]
* @param {widget_t*} widget 控件对象。
* @param {bool_t} stop_at_begin 是否在滚动完毕后停在文本结尾。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t hscroll_label_set_stop_at_begin(widget_t* widget, bool_t stop_at_begin);
/**
* @method hscroll_label_set_delay
* 设置开始延迟时间。
* @annotation ["scriptable"]
* @param {widget_t*} widget 控件对象。
* @param {uint32_t} delay 开始延迟时间。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t hscroll_label_set_delay(widget_t* widget, uint32_t delay);
/**
* @method hscroll_label_set_loop_interval_distance
* 设置滚动文本结尾和文本开头间隔距离
* @annotation ["scriptable"]
* @param {widget_t*} widget 控件对象。
* @param {int32_t} loop_interval_distance 间隔距离。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t hscroll_label_set_loop_interval_distance(widget_t* widget, int32_t loop_interval_distance);
/**
* @method hscroll_label_set_xoffset
* 设置x偏移(一般无需用户调用)。。
* @annotation ["scriptable"]
* @param {widget_t*} widget 控件对象。
* @param {int32_t} xoffset x偏移。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t hscroll_label_set_xoffset(widget_t* widget, int32_t xoffset);
/**
* @method hscroll_label_start
* 启动(一般无需用户调用)。
* @annotation ["scriptable"]
* @param {widget_t*} widget 控件对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t hscroll_label_start(widget_t* widget);
/**
* @method hscroll_label_stop
* 停止(一般无需用户调用)。
* @annotation ["scriptable"]
* @param {widget_t*} widget 控件对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t hscroll_label_stop(widget_t* widget);
/**
* @method hscroll_label_cast
* 转换为hscroll_label对象(供脚本语言使用)。
* @annotation ["cast", "scriptable"]
* @param {widget_t*} widget hscroll_label对象。
*
* @return {widget_t*} hscroll_label对象。
*/
widget_t* hscroll_label_cast(widget_t* widget);
#define HSCROLL_LABEL_PROP_YOYO "yoyo"
#define HSCROLL_LABEL_PROP_LOOP "loop"
#define HSCROLL_LABEL_PROP_LULL "lull"
#define HSCROLL_LABEL_PROP_XOFFSET "xoffset"
#define HSCROLL_LABEL_PROP_DURATION "duration"
#define HSCROLL_LABEL_PROP_SPEED "speed"
#define HSCROLL_LABEL_PROP_ELLIPSES "ellipses"
#define HSCROLL_LABEL_PROP_ONLY_FOCUS "only_focus"
#define HSCROLL_LABEL_PROP_ONLY_PARENT_FOCUS "only_parent_focus"
#define HSCROLL_LABEL_PROP_STOP_AT_BEGIN "stop_at_begin"
#define HSCROLL_LABEL_PROP_LOOP_INTERVAL_DISTANCE "loop_interval_distance"
#define WIDGET_TYPE_HSCROLL_LABEL "hscroll_label"
#define HSCROLL_LABEL(widget) ((hscroll_label_t*)(hscroll_label_cast(WIDGET(widget))))
/*public for subclass and runtime type check*/
TK_EXTERN_VTABLE(hscroll_label);
END_C_DECLS
#endif /*TK_HSCROLL_LABEL_H*/
|
0 |
repos/awtk/src/ext_widgets
|
repos/awtk/src/ext_widgets/progress_circle/progress_circle.h
|
/**
* File: progress_circle.h
* Author: AWTK Develop Team
* Brief: progress_circle
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-11-10 Li XianJing <[email protected]> created
*
*/
#ifndef TK_PROGRESS_CIRCLE_H
#define TK_PROGRESS_CIRCLE_H
#include "base/widget.h"
BEGIN_C_DECLS
/**
* @class progress_circle_t
* @parent widget_t
* @annotation ["scriptable","design","widget"]
* 进度圆环控件。
*
* progress\_circle\_t是[widget\_t](widget_t.md)的子类控件，widget\_t的函数均适用于progress\_circle\_t控件。
*
* 在xml中使用"progress\_circle"标签创建进度圆环控件。如：
*
* ```xml
* <progress_circle max="360" show_text="true" start_angle="90" />
* ```
*
* > 更多用法请参考：
* [progress_circle.xml](https://github.com/zlgopen/awtk/blob/master/design/default/ui/progress_circle.xml)
*
* 在c代码中使用函数progress\_circle\_create创建进度圆环控件。如：
*
* ```c
* progress_circle = progress_circle_create(win, 10, 10, 200, 200);
* progress_circle_set_max(progress_circle, 360);
* widget_set_value(progress_circle, 128);
* ```
*
* > 完整示例请参考：
* [progress_circle
* demo](https://github.com/zlgopen/awtk-c-demos/blob/master/demos/progress_circle.c)
*
* 可用通过style来设置控件的显示风格，如字体的大小和颜色等等。如：
*
* ```xml
* <style name="default">
* <normal text_color="green" fg_color="black" />
* </style>
* ```
*
* > 更多用法请参考：
* [theme
* default](https://github.com/zlgopen/awtk/blob/master/design/default/styles/default.xml#L467)
*
*/
typedef struct _progress_circle_t {
widget_t widget;
/**
* @property {float_t} value
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 值(缺省为0)。
*/
float_t value;
/**
* @property {float_t} max
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 最大值(缺省为100)。
*/
float_t max;
/**
* @property {char*} format
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 数值到字符串转换时的格式，缺省为"%d"。
*/
char* format;
/**
* @property {int32_t} start_angle
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 起始角度(单位为度，缺省-90)。
*/
int32_t start_angle;
/**
* @property {uint32_t} line_width
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 环线的厚度(缺省为8)，line_width > r/2时，使用扇形绘制。
*/
uint32_t line_width;
/**
* @property {char*} line_cap
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 线帽类型(round:圆头，square:方头，butt:平头)。
*/
char* line_cap;
/**
* @property {bool_t} counter_clock_wise
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 是否为逆时针方向(缺省为FALSE)。
*/
bool_t counter_clock_wise;
/**
* @property {bool_t} show_text
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 是否显示文本(缺省为TRUE)。
*/
bool_t show_text;
/* private */
bool_t is_redraw;
rect_t dirty_rect;
rect_t last_dirty_rect;
} progress_circle_t;
/**
* @event {value_change_event_t} EVT_VALUE_WILL_CHANGE
* 值即将改变事件。
*/
/**
* @event {value_change_event_t} EVT_VALUE_CHANGED
* 值改变事件。
*/
/**
* @method progress_circle_create
* @annotation ["constructor", "scriptable"]
* 创建progress_circle对象
*
* @param {widget_t*} parent 父控件
* @param {xy_t} x x坐标
* @param {xy_t} y y坐标
* @param {wh_t} w 宽度
* @param {wh_t} h 高度
*
* @return {widget_t*} 对象。
*/
widget_t* progress_circle_create(widget_t* parent, xy_t x, xy_t y, wh_t w, wh_t h);
/**
* @method progress_circle_cast
* 转换为progress_circle对象(供脚本语言使用)。
*
* @annotation ["cast", "scriptable"]
* @param {widget_t*} widget progress_circle对象。
*
* @return {widget_t*} progress_circle对象。
*/
widget_t* progress_circle_cast(widget_t* widget);
/**
* @method progress_circle_set_value
* 设置值。
*
* @annotation ["scriptable"]
* @param {widget_t*} widget 控件对象。
* @param {float_t} value 值。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t progress_circle_set_value(widget_t* widget, float_t value);
/**
* @method progress_circle_set_max
* 设置最大值。
*
* @annotation ["scriptable"]
* @param {widget_t*} widget 控件对象。
* @param {uint32_t} max 最大值。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t progress_circle_set_max(widget_t* widget, uint32_t max);
/**
* @method progress_circle_set_format
* 设置格式。
* @annotation ["scriptable"]
* @param {widget_t*} widget progress_circle对象。
* @param {const char*} format 格式。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t progress_circle_set_format(widget_t* widget, const char* format);
/**
* @method progress_circle_set_line_width
* 设置环线的厚度。
*
* @annotation ["scriptable"]
* @param {widget_t*} widget 控件对象。
* @param {uint32_t} line_width 环线的厚度。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t progress_circle_set_line_width(widget_t* widget, uint32_t line_width);
/**
* @method progress_circle_set_start_angle
* 设置起始角度。
*
* @annotation ["scriptable"]
* @param {widget_t*} widget 控件对象。
* @param {int32_t} start_angle 起始角度。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t progress_circle_set_start_angle(widget_t* widget, int32_t start_angle);
/**
* @method progress_circle_set_line_cap
* 设置线帽类型。
*
* @annotation ["scriptable"]
* @param {widget_t*} widget 控件对象。
* @param {const char*} line_cap 线帽类型(round:圆头，square:方头)。。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t progress_circle_set_line_cap(widget_t* widget, const char* line_cap);
/**
* @method progress_circle_set_show_text
* 设置是否显示文本。
*
* @annotation ["scriptable"]
* @param {widget_t*} widget 控件对象。
* @param {bool_t} show_text 是否显示文本。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t progress_circle_set_show_text(widget_t* widget, bool_t show_text);
/**
* @method progress_circle_set_counter_clock_wise
* 设置是否为逆时针方向。
*
* @annotation ["scriptable"]
* @param {widget_t*} widget 控件对象。
* @param {bool_t} counter_clock_wise 是否为逆时针方向。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t progress_circle_set_counter_clock_wise(widget_t* widget, bool_t counter_clock_wise);
#define PROGRESS_CIRCLE_PROP_UNIT "unit"
#define PROGRESS_CIRCLE_PROP_LINE_CAP "line_cap"
#define PROGRESS_CIRCLE_PROP_LINE_WIDTH "line_width"
#define PROGRESS_CIRCLE_PROP_START_ANGLE "start_angle"
#define PROGRESS_CIRCLE_PROP_COUNTER_CLOCK_WISE "counter_clock_wise"
#define WIDGET_TYPE_PROGRESS_CIRCLE "progress_circle"
#define PROGRESS_CIRCLE(widget) ((progress_circle_t*)(progress_circle_cast(WIDGET(widget))))
/*public for subclass and runtime type check*/
TK_EXTERN_VTABLE(progress_circle);
/*public for tests*/
/**
* @method progress_circle_calc_line_dirty_rect
* 获取progress_circle的新值和旧值之间的绘制脏矩形。
* @param {widget_t*} widget progress_circle控件对象。
* @param {float_t} old_value 旧值。
* @param {float_t} new_value 新值。
*
* @return {rect_t} 返回脏矩形。
*/
rect_t progress_circle_calc_line_dirty_rect(widget_t* widget, float_t old_value, float_t new_value);
END_C_DECLS
#endif /*TK_PROGRESS_CIRCLE_H*/
|
0 |
repos/awtk/src/ext_widgets
|
repos/awtk/src/ext_widgets/progress_circle/progress_circle.c
|
/**
* File: progress_circle.c
* Author: AWTK Develop Team
* Brief: progress_circle
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-11-10 Li XianJing <[email protected]> created
*
*/
#include "tkc/mem.h"
#include "tkc/utils.h"
#include "base/widget_vtable.h"
#include "base/image_manager.h"
#include "progress_circle/progress_circle.h"
static float_t progress_circle_get_radius(widget_t* widget);
static ret_t progress_circle_on_paint_background(widget_t* widget, canvas_t* c) {
float_t r = 0;
progress_circle_t* progress_circle = PROGRESS_CIRCLE(widget);
return_value_if_fail(progress_circle != NULL, RET_BAD_PARAMS);
r = progress_circle_get_radius(widget);
return widget_draw_arc_at_center(widget, c, TRUE, progress_circle->line_width, 0, M_PI * 2,
progress_circle->counter_clock_wise, progress_circle->line_cap,
r);
}
static ret_t progress_circle_update_text(widget_t* widget) {
const char* unit = NULL;
const char* format = NULL;
progress_circle_t* progress_circle = PROGRESS_CIRCLE(widget);
return_value_if_fail(progress_circle != NULL, RET_BAD_PARAMS);
unit = widget_get_prop_str(widget, PROGRESS_CIRCLE_PROP_UNIT, NULL);
format = progress_circle->format ? progress_circle->format : "%d";
widget_set_text_with_double(widget, format, progress_circle->value);
if (unit != NULL) {
wstr_append_utf8(&(widget->text), unit);
}
return RET_OK;
}
static float_t progress_circle_value_to_angle(widget_t* widget, float_t value) {
progress_circle_t* progress_circle = PROGRESS_CIRCLE(widget);
return_value_if_fail(progress_circle != NULL, 0);
return tk_value_to_angle(value, 0, progress_circle->max, progress_circle->start_angle,
progress_circle->start_angle + 360, progress_circle->counter_clock_wise);
}
static float_t progress_circle_get_radius(widget_t* widget) {
xy_t cx = widget->w / 2;
xy_t cy = widget->h / 2;
progress_circle_t* progress_circle = PROGRESS_CIRCLE(widget);
ENSURE(progress_circle);
return tk_min(cx, cy) - progress_circle->line_width / 2;
}
rect_t progress_circle_calc_text_dirty_rect(widget_t* widget) {
rect_t r = {0, 0, 0, 0};
canvas_t* c = widget_get_canvas(widget);
progress_circle_t* progress_circle = PROGRESS_CIRCLE(widget);
ENSURE(progress_circle);
if (widget->w < 1 || widget->h < 1) {
return r;
}
if (c != NULL && progress_circle->show_text) {
wstr_t* text = &(widget->text);
widget_prepare_text_style(widget, c);
progress_circle_update_text(widget);
r.w = canvas_measure_text(c, text->str, text->size) + 10;
r.h = c->font_size + 4;
r.x = (widget->w - r.w) / 2;
r.y = (widget->h - r.h) / 2;
}
return r;
}
rect_t progress_circle_calc_line_dirty_rect(widget_t* widget, float_t old_value,
float_t new_value) {
int32_t min_x = 0;
int32_t min_y = 0;
int32_t max_x = 0;
int32_t max_y = 0;
float_t start_angle = 0;
float_t end_angle = 0;
rect_t rect = {0, 0, 0, 0};
point_t start_p = {0, 0};
point_t end_p = {0, 0};
progress_circle_t* progress_circle = PROGRESS_CIRCLE(widget);
ENSURE(progress_circle);
float_t line_width = progress_circle->line_width;
start_angle = progress_circle_value_to_angle(widget, old_value);
end_angle = progress_circle_value_to_angle(widget, new_value);
if (widget->w < 1 || widget->h < 1) {
return rect;
}
if (start_angle > end_angle) {
float_t t = start_angle;
start_angle = end_angle;
end_angle = t;
}
if (!progress_circle->is_redraw && (end_angle - start_angle) < (M_PI / 2)) {
xy_t cx = widget->w / 2;
xy_t cy = widget->h / 2;
float_t r = progress_circle_get_radius(widget);
start_p.y = round(r * sin(start_angle));
start_p.x = round(r * cos(start_angle));
end_p.y = round(r * sin(end_angle));
end_p.x = round(r * cos(end_angle));
min_x = tk_min(start_p.x, end_p.x) - line_width;
max_x = tk_max(start_p.x, end_p.x) + line_width;
min_y = tk_min(start_p.y, end_p.y) - line_width;
max_y = tk_max(start_p.y, end_p.y) + line_width;
if (start_p.x > 0 && end_p.x < 0) {
/*跨越第1和2象限*/
max_y = tk_max_int(r, max_y);
} else if (start_p.y > 0 && end_p.y < 0) {
/*跨越第2和3象限*/
min_x = tk_min_int(-r, min_x);
} else if (start_p.x < 0 && end_p.x > 0) {
/*跨越第3和4象限*/
min_y = tk_min_int(-r, min_y);
} else if (start_p.y < 0 && end_p.y > 0) {
/*跨越第4和1象限*/
max_x = tk_max_int(r, max_x);
}
assert(min_x <= max_x);
assert(min_y <= max_y);
rect = rect_init(min_x, min_y, max_x - min_x, max_y - min_y);
rect.x += cx;
rect.y += cy;
} else {
progress_circle->is_redraw = FALSE;
rect = rect_init(0, 0, widget->w, widget->h);
}
return rect;
}
static ret_t progress_circle_on_paint_self(widget_t* widget, canvas_t* c) {
bitmap_t img;
style_t* style = widget->astyle;
color_t trans = color_init(0, 0, 0, 0);
vgcanvas_t* vg = canvas_get_vgcanvas(c);
progress_circle_t* progress_circle = PROGRESS_CIRCLE(widget);
color_t color = style_get_color(style, STYLE_ID_FG_COLOR, trans);
const char* image_name = style_get_str(style, STYLE_ID_FG_IMAGE, NULL);
bool_t has_image = image_name && widget_load_image(widget, image_name, &img) == RET_OK;
if (progress_circle->value > progress_circle->max) {
progress_circle->value = progress_circle->max;
}
if (vg != NULL && (has_image || color.rgba.a)) {
xy_t cx = widget->w / 2;
xy_t cy = widget->h / 2;
float_t end_angle = 0.0f;
float_t r = progress_circle_get_radius(widget);
bool_t ccw = progress_circle->counter_clock_wise;
float_t start_angle = TK_D2R(progress_circle->start_angle);
if (tk_fequal(progress_circle->value, 0)) {
end_angle = start_angle;
} else {
end_angle = progress_circle_value_to_angle(widget, progress_circle->value);
if (progress_circle->value == progress_circle->max) {
end_angle = start_angle + M_PI * 2;
}
}
vgcanvas_save(vg);
vgcanvas_translate(vg, c->ox, c->oy);
vgcanvas_set_stroke_color(vg, color);
vgcanvas_set_line_width(vg, progress_circle->line_width);
if (tk_str_eq(progress_circle->line_cap, VGCANVAS_LINE_CAP_ROUND)) {
vgcanvas_set_line_cap(vg, VGCANVAS_LINE_CAP_ROUND);
} else if (tk_str_eq(progress_circle->line_cap, VGCANVAS_LINE_CAP_SQUARE)) {
vgcanvas_set_line_cap(vg, VGCANVAS_LINE_CAP_SQUARE);
} else {
vgcanvas_set_line_cap(vg, VGCANVAS_LINE_CAP_BUTT);
}
vgcanvas_begin_path(vg);
if (end_angle > start_angle) {
float max_r = tk_min(widget->w, widget->h) / 2;
if (progress_circle->line_width > max_r / 2) {
//画扇形
vgcanvas_set_fill_color(vg, color);
vgcanvas_move_to(vg, cx, cy);
vgcanvas_line_to(vg, cx + max_r * cos(start_angle), cy + max_r * sin(start_angle));
vgcanvas_arc(vg, cx, cy, max_r, start_angle, end_angle, ccw);
vgcanvas_close_path(vg);
if (has_image) {
vgcanvas_paint(vg, FALSE, &img);
} else {
vgcanvas_fill(vg);
}
} else {
vgcanvas_arc(vg, cx, cy, r, start_angle, end_angle, ccw);
if (has_image) {
vgcanvas_paint(vg, TRUE, &img);
} else {
vgcanvas_stroke(vg);
}
}
}
vgcanvas_restore(vg);
progress_circle->last_dirty_rect =
rect_init(progress_circle->dirty_rect.x, progress_circle->dirty_rect.y,
progress_circle->dirty_rect.w, progress_circle->dirty_rect.h);
progress_circle->dirty_rect = rect_init(0, 0, 0, 0);
}
color = style_get_color(style, STYLE_ID_TEXT_COLOR, trans);
if (progress_circle->show_text && color.rgba.a) {
progress_circle_update_text(widget);
widget_paint_helper(widget, c, NULL, NULL);
}
return RET_OK;
}
ret_t progress_circle_set_value(widget_t* widget, float_t value) {
progress_circle_t* progress_circle = PROGRESS_CIRCLE(widget);
return_value_if_fail(progress_circle != NULL, RET_BAD_PARAMS);
if (progress_circle->value != value) {
float_t old_value = progress_circle->value;
value_change_event_t evt;
value_change_event_init(&evt, EVT_VALUE_WILL_CHANGE, widget);
value_set_float(&(evt.old_value), progress_circle->value);
value_set_float(&(evt.new_value), value);
if (widget_dispatch(widget, (event_t*)&evt) != RET_STOP) {
rect_t r = progress_circle_calc_line_dirty_rect(widget, old_value, value);
rect_merge(&progress_circle->dirty_rect, &r);
rect_merge(&r, &progress_circle->last_dirty_rect);
widget_invalidate_force(widget, &r);
progress_circle->value = value;
evt.e.type = EVT_VALUE_CHANGED;
widget_dispatch(widget, (event_t*)&evt);
if (progress_circle->show_text) {
r = progress_circle_calc_text_dirty_rect(widget);
widget_invalidate_force(widget, &r);
}
}
}
return RET_OK;
}
ret_t progress_circle_set_max(widget_t* widget, uint32_t max) {
progress_circle_t* progress_circle = PROGRESS_CIRCLE(widget);
return_value_if_fail(progress_circle != NULL, RET_BAD_PARAMS);
progress_circle->max = max;
return widget_invalidate(widget, NULL);
}
ret_t progress_circle_set_line_width(widget_t* widget, uint32_t line_width) {
progress_circle_t* progress_circle = PROGRESS_CIRCLE(widget);
return_value_if_fail(progress_circle != NULL, RET_BAD_PARAMS);
progress_circle->line_width = line_width;
return widget_invalidate(widget, NULL);
}
ret_t progress_circle_set_start_angle(widget_t* widget, int32_t start_angle) {
progress_circle_t* progress_circle = PROGRESS_CIRCLE(widget);
return_value_if_fail(progress_circle != NULL, RET_BAD_PARAMS);
progress_circle->start_angle = start_angle;
return widget_invalidate(widget, NULL);
}
ret_t progress_circle_set_line_cap(widget_t* widget, const char* line_cap) {
progress_circle_t* progress_circle = PROGRESS_CIRCLE(widget);
return_value_if_fail(progress_circle != NULL, RET_BAD_PARAMS);
progress_circle->line_cap = tk_str_copy(progress_circle->line_cap, line_cap);
return widget_invalidate(widget, NULL);
}
ret_t progress_circle_set_show_text(widget_t* widget, bool_t show_text) {
progress_circle_t* progress_circle = PROGRESS_CIRCLE(widget);
return_value_if_fail(progress_circle != NULL, RET_BAD_PARAMS);
progress_circle->show_text = show_text;
return widget_invalidate(widget, NULL);
}
ret_t progress_circle_set_counter_clock_wise(widget_t* widget, bool_t counter_clock_wise) {
progress_circle_t* progress_circle = PROGRESS_CIRCLE(widget);
return_value_if_fail(progress_circle != NULL, RET_BAD_PARAMS);
progress_circle->counter_clock_wise = counter_clock_wise;
return widget_invalidate(widget, NULL);
}
static ret_t progress_circle_on_destroy(widget_t* widget) {
progress_circle_t* progress_circle = PROGRESS_CIRCLE(widget);
return_value_if_fail(widget != NULL && progress_circle != NULL, RET_BAD_PARAMS);
TKMEM_FREE(progress_circle->format);
TKMEM_FREE(progress_circle->line_cap);
return RET_OK;
}
static ret_t progress_circle_get_prop(widget_t* widget, const char* name, value_t* v) {
progress_circle_t* progress_circle = PROGRESS_CIRCLE(widget);
return_value_if_fail(progress_circle != NULL && name != NULL && v != NULL, RET_BAD_PARAMS);
if (tk_str_eq(name, WIDGET_PROP_VALUE)) {
value_set_float(v, progress_circle->value);
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_MAX)) {
value_set_uint32(v, progress_circle->max);
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_FORMAT)) {
value_set_str(v, progress_circle->format);
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_SHOW_TEXT)) {
value_set_bool(v, progress_circle->show_text);
return RET_OK;
} else if (tk_str_eq(name, PROGRESS_CIRCLE_PROP_LINE_CAP)) {
value_set_str(v, progress_circle->line_cap);
return RET_OK;
} else if (tk_str_eq(name, PROGRESS_CIRCLE_PROP_LINE_WIDTH)) {
value_set_uint32(v, progress_circle->line_width);
return RET_OK;
} else if (tk_str_eq(name, PROGRESS_CIRCLE_PROP_START_ANGLE)) {
value_set_int(v, progress_circle->start_angle);
return RET_OK;
} else if (tk_str_eq(name, PROGRESS_CIRCLE_PROP_COUNTER_CLOCK_WISE)) {
value_set_bool(v, progress_circle->counter_clock_wise);
return RET_OK;
}
return RET_NOT_FOUND;
}
static ret_t progress_circle_set_prop(widget_t* widget, const char* name, const value_t* v) {
progress_circle_t* progress_circle = PROGRESS_CIRCLE(widget);
return_value_if_fail(progress_circle != NULL && name != NULL && v != NULL, RET_BAD_PARAMS);
if (tk_str_eq(name, WIDGET_PROP_VALUE)) {
return progress_circle_set_value(widget, value_float(v));
} else if (tk_str_eq(name, WIDGET_PROP_MAX)) {
progress_circle->is_redraw = TRUE;
return progress_circle_set_max(widget, value_int(v));
} else if (tk_str_eq(name, WIDGET_PROP_FORMAT)) {
return progress_circle_set_format(widget, value_str(v));
} else if (tk_str_eq(name, WIDGET_PROP_SHOW_TEXT)) {
return progress_circle_set_show_text(widget, value_bool(v));
} else if (tk_str_eq(name, PROGRESS_CIRCLE_PROP_COUNTER_CLOCK_WISE)) {
progress_circle->is_redraw = TRUE;
return progress_circle_set_counter_clock_wise(widget, value_bool(v));
} else if (tk_str_eq(name, PROGRESS_CIRCLE_PROP_LINE_WIDTH)) {
progress_circle->is_redraw = TRUE;
return progress_circle_set_line_width(widget, value_int(v));
} else if (tk_str_eq(name, PROGRESS_CIRCLE_PROP_START_ANGLE)) {
progress_circle->is_redraw = TRUE;
return progress_circle_set_start_angle(widget, value_int(v));
} else if (tk_str_eq(name, PROGRESS_CIRCLE_PROP_LINE_CAP)) {
progress_circle->is_redraw = TRUE;
return progress_circle_set_line_cap(widget, value_str(v));
} else if (tk_str_eq(name, WIDGET_PROP_W)) {
progress_circle->is_redraw = TRUE;
progress_circle->dirty_rect = rect_init(0, 0, value_int(v), widget->h);
} else if (tk_str_eq(name, WIDGET_PROP_H)) {
progress_circle->is_redraw = TRUE;
progress_circle->dirty_rect = rect_init(0, 0, widget->w, value_int(v));
}
return RET_NOT_FOUND;
}
static ret_t progress_circle_init(widget_t* widget) {
progress_circle_t* progress_circle = PROGRESS_CIRCLE(widget);
return_value_if_fail(progress_circle != NULL, RET_BAD_PARAMS);
progress_circle->max = 100;
progress_circle->line_width = 8;
progress_circle->start_angle = -90;
progress_circle->show_text = TRUE;
progress_circle->counter_clock_wise = FALSE;
progress_circle->dirty_rect = rect_init(0, 0, widget->w, widget->h);
progress_circle_set_line_cap(widget, VGCANVAS_LINE_CAP_ROUND);
return RET_OK;
}
static const char* s_progress_circle_clone_properties[] = {WIDGET_PROP_VALUE,
WIDGET_PROP_MAX,
WIDGET_PROP_FORMAT,
PROGRESS_CIRCLE_PROP_COUNTER_CLOCK_WISE,
PROGRESS_CIRCLE_PROP_LINE_WIDTH,
PROGRESS_CIRCLE_PROP_START_ANGLE,
WIDGET_PROP_SHOW_TEXT,
NULL};
TK_DECL_VTABLE(progress_circle) = {.size = sizeof(progress_circle_t),
.type = WIDGET_TYPE_PROGRESS_CIRCLE,
.clone_properties = s_progress_circle_clone_properties,
.get_parent_vt = TK_GET_PARENT_VTABLE(widget),
.create = progress_circle_create,
.init = progress_circle_init,
.on_paint_self = progress_circle_on_paint_self,
.on_paint_background = progress_circle_on_paint_background,
.on_destroy = progress_circle_on_destroy,
.get_prop = progress_circle_get_prop,
.set_prop = progress_circle_set_prop};
widget_t* progress_circle_create(widget_t* parent, xy_t x, xy_t y, wh_t w, wh_t h) {
widget_t* widget = widget_create(parent, TK_REF_VTABLE(progress_circle), x, y, w, h);
return_value_if_fail(progress_circle_init(widget) == RET_OK, NULL);
return widget;
}
widget_t* progress_circle_cast(widget_t* widget) {
return_value_if_fail(WIDGET_IS_INSTANCE_OF(widget, progress_circle), NULL);
return widget;
}
ret_t progress_circle_set_format(widget_t* widget, const char* format) {
progress_circle_t* progress_circle = PROGRESS_CIRCLE(widget);
return_value_if_fail(progress_circle != NULL && format != NULL, RET_BAD_PARAMS);
progress_circle->format = tk_str_copy(progress_circle->format, format);
return widget_invalidate(widget, NULL);
}
|
0 |
repos/awtk/src/ext_widgets
|
repos/awtk/src/ext_widgets/canvas_widget/canvas_widget.h
|
/**
* File: canvas_widget.h
* Author: AWTK Develop Team
* Brief: canvas_widget
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-12-01 Li XianJing <[email protected]> created
*
*/
#ifndef TK_CANVAS_WIDGET_H
#define TK_CANVAS_WIDGET_H
#include "base/widget.h"
BEGIN_C_DECLS
/**
* @class canvas_widget_t
* @parent widget_t
* @annotation ["scriptable","design","widget"]
* 画布控件。
*
* 画布控件让开发者可以自己在控件上绘制需要的内容。
*
* canvas\_widget\_t是[widget\_t](widget_t.md)的子类控件，widget\_t的函数均适用于canvas\_widget\_t控件。
*
* 在xml中使用"canvas"标签创建画布控件。如：
*
* ```xml
* <canvas name="paint_vgcanvas" x="0" y="0" w="100%" h="100%" />
* ```
*
* > 更多用法请参考：
* [canvas_widget.xml](https://github.com/zlgopen/awtk/blob/master/design/default/ui/vgcanvas.xml)
*
* 在c代码中使用函数canvas\_widget\_create创建画布控件。如：
*
* ```c
* widget_t* canvas = canvas_widget_create(win, 0, 0, win->w, win->h);
* ```
*
* > 创建之后，需要用widget\_on注册EVT\_PAINT事件，并在EVT\_PAINT事件处理函数中绘制。
*
* ```c
* widget_on(canvas, EVT_PAINT, on_paint_event, canvas);
* ```
*
* 绘制时，可以通过canvas接口去绘制，也可以通过vgcanvas接口去绘制。
* 先从evt获取canvas对象，再通过canvas\_get\_vgcanvas从canvas中获取vgcanvas对象。
*
* ```c
*
* static ret_t on_paint_event(void* ctx, event_t* evt) {
* widget_t* canvas_widget = WIDGET(ctx);
* canvas_t* c = paint_event_cast(evt)->c;
* vgcanvas_t* vg = canvas_get_vgcanvas(c);
* color_t bg = color_init(0xe0, 0xe0, 0xe0, 0xff);
* color_t tc = color_init(0, 0, 0, 0xff);
* rect_t r = rect_init(canvas_widget->x, canvas_widget->y, canvas_widget->w, canvas_widget->h);
*
* vgcanvas_save(vg);
* vgcanvas_clip_rect(vg, r.x, r.y, r.w, r.h);
* vgcanvas_translate(vg, r.x, r.y);
*
* ...
*
* vgcanvas_restore(vg);
*
* return RET_OK;
* }
* ```
*
* > 完整示例请参考：
* [canvas demo](https://github.com/zlgopen/awtk-c-demos/blob/master/demos/canvas.c)
*
* 参考：
*
* * [canvas接口描述](canvas_t.md)
* * [vgcanvas接口描述](vgcanvas_t.md)
*
*/
typedef struct _canvas_widget_t {
widget_t widget;
} canvas_widget_t;
/**
* @method canvas_widget_create
* 创建canvas_widget对象
* @annotation ["constructor", "scriptable"]
* @param {widget_t*} parent 父控件
* @param {xy_t} x x坐标
* @param {xy_t} y y坐标
* @param {wh_t} w 宽度
* @param {wh_t} h 高度
*
* @return {widget_t*} 对象。
*/
widget_t* canvas_widget_create(widget_t* parent, xy_t x, xy_t y, wh_t w, wh_t h);
/**
* @method canvas_widget_cast
* 转换为canvas_widget对象(供脚本语言使用)。
* @annotation ["cast", "scriptable"]
* @param {widget_t*} widget canvas_widget对象。
*
* @return {widget_t*} canvas_widget对象。
*/
widget_t* canvas_widget_cast(widget_t* widget);
#define WIDGET_TYPE_CANVAS_WIDGET "canvas"
#define CANVAS_WIDGET(widget) ((canvas_widget_t*)(canvas_widget_cast(WIDGET(widget))))
/*public for subclass and runtime type check*/
TK_EXTERN_VTABLE(canvas_widget);
END_C_DECLS
#endif /*TK_CANVAS_WIDGET_H*/
|
0 |
repos/awtk/src/ext_widgets
|
repos/awtk/src/ext_widgets/canvas_widget/canvas_widget.c
|
/**
* File: canvas_widget.h
* Author: AWTK Develop Team
* Brief: canvas_widget
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-12-01 Li XianJing <[email protected]> created
*
*/
#include "tkc/mem.h"
#include "canvas_widget/canvas_widget.h"
TK_DECL_VTABLE(canvas_widget) = {.size = sizeof(canvas_widget_t),
.type = WIDGET_TYPE_CANVAS_WIDGET,
.get_parent_vt = TK_GET_PARENT_VTABLE(widget),
.create = canvas_widget_create};
widget_t* canvas_widget_create(widget_t* parent, xy_t x, xy_t y, wh_t w, wh_t h) {
return widget_create(parent, TK_REF_VTABLE(canvas_widget), x, y, w, h);
}
widget_t* canvas_widget_cast(widget_t* widget) {
return_value_if_fail(WIDGET_IS_INSTANCE_OF(widget, canvas_widget), NULL);
return widget;
}
|
0 |
repos/awtk/src/ext_widgets
|
repos/awtk/src/ext_widgets/image_animation/image_animation.h
|
/**
* File: image_animation.h
* Author: AWTK Develop Team
* Brief: image_animation
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-09-28 Li XianJing <[email protected]> created
*
*/
#ifndef TK_IMAGE_ANIMATION_H
#define TK_IMAGE_ANIMATION_H
#include "base/widget.h"
BEGIN_C_DECLS
/**
* @class image_animation_t
* @parent widget_t
* @annotation ["scriptable","design","widget"]
* 图片动画控件，指定一个图片前缀，依次显示指定序列的图片，从而形成动画效果。
*
* 图片序列可以用sequence指定，也可以用start\_index和end\_index指定一个范围。
*
* image\_animation\_t是[widget\_t](widget_t.md)的子类控件，widget\_t的函数均适用于image\_animation\_t控件。
*
* 在xml中使用"image\_animation"标签创建图片动画控件。如：
*
* ```xml
* <image_animation image="ani" start_index="1" end_index="9" auto_play="true" interval="50"
* delay="100"/>
* ```
*
* > 更多用法请参考：
* [image_animation.xml](https://github.com/zlgopen/awtk/blob/master/design/default/ui/image_animation.xml)
*
* 在c代码中使用函数image\_animation\_create创建图片动画控件。如：
*
* ```c
* image_animation = image_animation_create(win, 10, 10, 200, 200);
* image_animation_set_image(image_animation, "ani");
* image_animation_set_interval(image_animation, 50);
* image_animation_set_range_sequence(image_animation, 1, 9);
* image_animation_play(image_animation);
* ```
*
* > 完整示例请参考：
* [image_animation
* demo](https://github.com/zlgopen/awtk-c-demos/blob/master/demos/image_animation.c)
*
* 可用通过style来设置控件的显示风格，如背景颜色和边框等等，不过一般情况并不需要。
*
*/
typedef struct _image_animation_t {
widget_t widget;
/**
* @property {char*} image
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 图片名称的前缀。
*/
char* image;
/**
* @property {char*} sequence
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 播放的序列，字符可选值为数字和英文大小写字母，字符可以重复。如：0123456789或者123123abcd。
*
*/
char* sequence;
/**
* @property {uint32_t} start_index
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 图片起始序数。
*/
uint32_t start_index;
/**
* @property {uint32_t} end_index
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 图片结束序数。
*/
uint32_t end_index;
/**
* @property {bool_t} reverse
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 是否倒序播放。
*/
bool_t reverse;
/**
* @property {bool_t} loop
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 是否循环播放。
*/
bool_t loop;
/**
* @property {bool_t} auto_play
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 是否自动播放。
*/
bool_t auto_play;
/**
* @property {bool_t} unload_after_paint
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 绘制完成后unload图片，以释放内存空间。
*/
bool_t unload_after_paint;
/**
* @property {char*} format
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 索引到图片名转换时的格式，缺省为"%s%d"。
*/
char* format;
/**
* @property {uint32_t} interval
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 每张图片播放的时间(毫秒)。
*/
uint32_t interval;
/**
* @property {uint32_t} delay
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 自动播放时延迟播放的时间(毫秒)。
*/
uint32_t delay;
/**
* @property {bool_t} show_when_done
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 结束后是否继续显示最后一帧。
*/
bool_t show_when_done;
/*private*/
bool_t inited;
bool_t playing;
int32_t index;
uint32_t timer_id;
void* image_buffer;
} image_animation_t;
/**
* @event {event_t} EVT_ANIM_ONCE
* 使能循环播放时，控件动画完成一次事件。
*/
/**
* @event {event_t} EVT_ANIM_END
* 控件动画完成事件。
*/
/**
* @method image_animation_create
* @annotation ["constructor", "scriptable"]
* 创建image_animation对象
* @param {widget_t*} parent 父控件
* @param {xy_t} x x坐标
* @param {xy_t} y y坐标
* @param {wh_t} w 宽度
* @param {wh_t} h 高度
*
* @return {widget_t*} 对象。
*/
widget_t* image_animation_create(widget_t* parent, xy_t x, xy_t y, wh_t w, wh_t h);
/**
* @method image_animation_set_loop
* 设置是否循环播放。
* @annotation ["scriptable"]
* @param {widget_t*} widget image_animation对象。
* @param {bool_t} loop 是否循环播放。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t image_animation_set_loop(widget_t* widget, bool_t loop);
/**
* @method image_animation_set_image
* 设置图片前缀。
* @annotation ["scriptable"]
* @param {widget_t*} widget image_animation对象。
* @param {const char*} image 图片前缀。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t image_animation_set_image(widget_t* widget, const char* image);
/**
* @method image_animation_set_interval
* 设置播放间隔时间(毫秒)。
* @annotation ["scriptable"]
* @param {widget_t*} widget image_animation对象。
* @param {uint32_t} interval 间隔时间(毫秒)。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t image_animation_set_interval(widget_t* widget, uint32_t interval);
/**
* @method image_animation_set_delay
* 设置延迟播放时间(仅适用于自动播放)。
* @annotation ["scriptable"]
* @param {widget_t*} widget image_animation对象。
* @param {uint32_t} delay 延迟播放时间(毫秒)。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t image_animation_set_delay(widget_t* widget, uint32_t delay);
/**
* @method image_animation_set_auto_play
* 设置是否自动播放。
* @annotation ["scriptable"]
* @param {widget_t*} widget image_animation对象。
* @param {bool_t} auto_play 是否自动播放。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t image_animation_set_auto_play(widget_t* widget, bool_t auto_play);
/**
* @method image_animation_set_sequence
* 设置播放序列。比如image为"fire"，sequence为"12223", 将依次播放"fire1", "fire2", "fire2", "fire2",
* "fire3"。
* @annotation ["scriptable"]
* @param {widget_t*} widget image_animation对象。
* @param {const char*} sequence 播放序列。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t image_animation_set_sequence(widget_t* widget, const char* sequence);
/**
* @method image_animation_set_range_sequence
* 设置播放序列。比如image为"fire"，start_index为0, end_index为99, 将依次播放"fire0", ...,
* "fire99"。
*
*若指定的图片不存在，则重复上一张图片。
*
* @annotation ["scriptable"]
* @param {widget_t*} widget image_animation对象。
* @param {uint32_t} start_index 图片起始序数。
* @param {uint32_t} end_index 图片结束序数。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t image_animation_set_range_sequence(widget_t* widget, uint32_t start_index,
uint32_t end_index);
/**
* @method image_animation_play
* 播放。
* @annotation ["scriptable"]
* @param {widget_t*} widget image_animation对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t image_animation_play(widget_t* widget);
/**
* @method image_animation_stop
* 停止(并重置index为-1)。
* @annotation ["scriptable"]
* @param {widget_t*} widget image_animation对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t image_animation_stop(widget_t* widget);
/**
* @method image_animation_pause
* 暂停。
* @annotation ["scriptable"]
* @param {widget_t*} widget image_animation对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t image_animation_pause(widget_t* widget);
/**
* @method image_animation_next
* 手动切换到下一张图片。
* @annotation ["scriptable"]
* @param {widget_t*} widget image_animation对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t image_animation_next(widget_t* widget);
/**
* @method image_animation_set_format
* 设置生成图片名的格式。
*
* XXX:生成图片名时，第一个参数是图片名前缀，第二个是序数，只能在此前提下设置格式。
*
* ```
* const char* format = image_animation->format ? image_animation->format : "%s%d";
* tk_snprintf(name, TK_NAME_LEN, format, image_animation->image, image_animation->index);
* ```
*
* @annotation ["scriptable"]
* @param {widget_t*} widget image_animation对象。
* @param {const char*} format 格式。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t image_animation_set_format(widget_t* widget, const char* format);
/**
* @method image_animation_set_unload_after_paint
* 设置绘制完成后unload图片，以释放内存空间。
* @annotation ["scriptable"]
* @param {widget_t*} widget image_animation对象。
* @param {bool_t} unload_after_paint 是否绘制完成后unload图片。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t image_animation_set_unload_after_paint(widget_t* widget, bool_t unload_after_paint);
/**
* @method image_animation_set_reverse
* 设置是否倒序播放。
* @annotation ["scriptable"]
* @param {widget_t*} widget image_animation对象。
* @param {bool_t} reverse 是否倒序播放。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t image_animation_set_reverse(widget_t* widget, bool_t reverse);
/**
* @method image_animation_set_show_when_done
* 设置结束播放后是否保持显示最后一帧。
* @annotation ["scriptable"]
* @param {widget_t*} widget image_animation对象。
* @param {bool_t} show_when_done 是否继续显示最后一帧。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t image_animation_set_show_when_done(widget_t* widget, bool_t show_when_done);
/**
* @method image_animation_cast
* 转换为image_animation对象(供脚本语言使用)。
* @annotation ["cast", "scriptable"]
* @param {widget_t*} widget image_animation对象。
*
* @return {widget_t*} image_animation对象。
*/
widget_t* image_animation_cast(widget_t* widget);
/**
* @method image_animation_is_playing
* 判断是否在播放。
* @annotation ["scriptable"]
* @param {widget_t*} widget image_animation对象。
*
* @return {bool_t} 返回TRUE表示是，否则表示否。
*/
bool_t image_animation_is_playing(widget_t* widget);
#define IMAGE_ANIMATION_PROP_LOOP "loop"
#define IMAGE_ANIMATION_PROP_REVERSE "reverse"
#define IMAGE_ANIMATION_PROP_SEQUENCE "sequence"
#define IMAGE_ANIMATION_PROP_START_INDEX "start_index"
#define IMAGE_ANIMATION_PROP_END_INDEX "end_index"
#define IMAGE_ANIMATION_PROP_INTERVAL "interval"
#define IMAGE_ANIMATION_PROP_AUTO_PLAY "auto_play"
#define IMAGE_ANIMATION_PROP_SHOW_WHEN_DENO "show_when_done"
#define IMAGE_ANIMATION_PROP_UNLOAD_AFTER_PAINT "unload_after_paint"
#define WIDGET_TYPE_IMAGE_ANIMATION "image_animation"
#define IMAGE_ANIMATION(widget) ((image_animation_t*)(image_animation_cast(WIDGET(widget))))
/*public for subclass and runtime type check*/
TK_EXTERN_VTABLE(image_animation);
/*public for test*/
ret_t image_animation_update(widget_t* widget);
ret_t image_animation_get_image_name(image_animation_t* image_animation,
char name[TK_NAME_LEN + 1]);
END_C_DECLS
#endif /*TK_IMAGE_ANIMATION_H*/
|
0 |
repos/awtk/src/ext_widgets
|
repos/awtk/src/ext_widgets/image_animation/image_animation.c
|
/**
* File: image_animation.h
* Author: AWTK Develop Team
* Brief: image_animation
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-09-28 Li XianJing <[email protected]> created
*
*/
#include "tkc/mem.h"
#include "tkc/utils.h"
#include "base/idle.h"
#include "base/timer.h"
#include "base/image_manager.h"
#include "image_animation/image_animation.h"
static ret_t image_animation_init(widget_t* widget);
static ret_t image_animation_start_init_if_not_inited(widget_t* widget);
static ret_t image_animation_play_to_done(image_animation_t* image_animation) {
if (!image_animation->show_when_done) {
image_animation->index = -1;
}
image_animation->playing = FALSE;
return RET_OK;
}
ret_t image_animation_get_image_name(image_animation_t* image_animation,
char name[TK_NAME_LEN + 1]) {
uint32_t index = 0;
memset(name, 0x00, TK_NAME_LEN + 1);
if (image_animation->sequence != NULL) {
uint32_t len = strlen(image_animation->sequence);
tk_strncpy(name, image_animation->image, TK_NAME_LEN);
image_animation->index = image_animation->index >= len ? 0 : image_animation->index;
index = image_animation->reverse ? len - image_animation->index - 1 : image_animation->index;
name[strlen(name)] = image_animation->sequence[index];
} else {
index = image_animation->reverse
? image_animation->end_index + image_animation->start_index - image_animation->index
: image_animation->index;
const char* format = image_animation->format ? image_animation->format : "%s%d";
tk_snprintf(name, TK_NAME_LEN, format, image_animation->image, index);
}
return RET_OK;
}
#define MAX_CACHE_NR 60
static ret_t on_idle_unload_image(const idle_info_t* info) {
bitmap_t bitmap;
widget_t* widget = NULL;
image_animation_t* image_animation = NULL;
return_value_if_fail(info != NULL, RET_REMOVE);
widget = WIDGET(info->ctx);
image_animation = IMAGE_ANIMATION(info->ctx);
return_value_if_fail(widget != NULL && image_animation != NULL, RET_REMOVE);
if (image_animation->image_buffer != NULL) {
memset(&bitmap, 0x00, sizeof(bitmap));
bitmap.buffer = (graphic_buffer_t*)(image_animation->image_buffer);
widget_unload_image(widget, &bitmap);
}
return RET_REMOVE;
}
static ret_t image_animation_load_image(image_animation_t* image_animation, bitmap_t* bitmap) {
char name[TK_NAME_LEN + 1];
widget_t* widget = WIDGET(image_animation);
return_value_if_fail(widget != NULL && image_animation != NULL && bitmap != NULL, RET_BAD_PARAMS);
image_animation_get_image_name(image_animation, name);
return widget_load_image(widget, name, bitmap);
}
static ret_t image_animation_on_paint_self(widget_t* widget, canvas_t* c) {
image_animation_t* image_animation = IMAGE_ANIMATION(widget);
return_value_if_fail(widget != NULL && image_animation != NULL && image_animation->image != NULL,
RET_BAD_PARAMS);
image_animation_start_init_if_not_inited(widget);
if (image_animation->index >= 0) {
bitmap_t bitmap;
if (image_animation_load_image(image_animation, &bitmap) == RET_OK) {
rect_t s = rect_init(0, 0, bitmap.w, bitmap.h);
rect_t d = rect_init(0, 0, widget->w, widget->h);
canvas_draw_image_scale_down(c, &bitmap, &s, &d);
if (image_animation->unload_after_paint) {
image_animation->image_buffer = (bitmap.buffer);
widget_add_idle(widget, on_idle_unload_image);
}
}
}
return RET_OK;
}
static ret_t image_animation_get_prop(widget_t* widget, const char* name, value_t* v) {
image_animation_t* image_animation = IMAGE_ANIMATION(widget);
return_value_if_fail(image_animation != NULL && name != NULL && v != NULL, RET_BAD_PARAMS);
if (tk_str_eq(name, IMAGE_ANIMATION_PROP_LOOP)) {
value_set_bool(v, image_animation->loop);
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_IMAGE)) {
value_set_str(v, image_animation->image);
return RET_OK;
} else if (tk_str_eq(name, IMAGE_ANIMATION_PROP_START_INDEX)) {
value_set_int(v, image_animation->start_index);
} else if (tk_str_eq(name, IMAGE_ANIMATION_PROP_END_INDEX)) {
value_set_int(v, image_animation->end_index);
} else if (tk_str_eq(name, IMAGE_ANIMATION_PROP_SEQUENCE)) {
value_set_str(v, image_animation->sequence);
return RET_OK;
} else if (tk_str_eq(name, IMAGE_ANIMATION_PROP_AUTO_PLAY)) {
value_set_bool(v, image_animation->auto_play);
return RET_OK;
} else if (tk_str_eq(name, IMAGE_ANIMATION_PROP_INTERVAL)) {
value_set_int(v, image_animation->interval);
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_DELAY)) {
value_set_int(v, image_animation->delay);
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_FORMAT)) {
value_set_str(v, image_animation->format);
return RET_OK;
} else if (tk_str_eq(name, IMAGE_ANIMATION_PROP_UNLOAD_AFTER_PAINT)) {
value_set_bool(v, image_animation->unload_after_paint);
return RET_OK;
} else if (tk_str_eq(name, IMAGE_ANIMATION_PROP_REVERSE)) {
value_set_bool(v, image_animation->reverse);
return RET_OK;
} else if (tk_str_eq(name, IMAGE_ANIMATION_PROP_SHOW_WHEN_DENO)) {
value_set_bool(v, image_animation->show_when_done);
return RET_OK;
}
return RET_NOT_FOUND;
}
static ret_t image_animation_set_prop(widget_t* widget, const char* name, const value_t* v) {
image_animation_t* image_animation = IMAGE_ANIMATION(widget);
return_value_if_fail(image_animation != NULL && name != NULL && v != NULL, RET_BAD_PARAMS);
if (tk_str_eq(name, WIDGET_PROP_EXEC)) {
const char* action = value_str(v);
if (tk_str_eq(action, WIDGET_EXEC_START_ANIMATOR)) {
if (!image_animation_is_playing(widget)) {
image_animation_play(widget);
}
} else if (tk_str_eq(action, WIDGET_EXEC_STOP_ANIMATOR)) {
if (image_animation_is_playing(widget)) {
image_animation_stop(widget);
}
} else if (tk_str_eq(action, WIDGET_EXEC_PAUSE_ANIMATOR)) {
if (image_animation_is_playing(widget)) {
image_animation_pause(widget);
}
}
return RET_OK;
} else if (tk_str_eq(name, IMAGE_ANIMATION_PROP_LOOP)) {
return image_animation_set_loop(widget, value_bool(v));
} else if (tk_str_eq(name, WIDGET_PROP_IMAGE)) {
return image_animation_set_image(widget, value_str(v));
} else if (tk_str_eq(name, IMAGE_ANIMATION_PROP_START_INDEX)) {
image_animation->start_index = value_uint32(v);
image_animation->index = image_animation->start_index;
} else if (tk_str_eq(name, IMAGE_ANIMATION_PROP_END_INDEX)) {
image_animation->end_index = value_uint32(v);
} else if (tk_str_eq(name, IMAGE_ANIMATION_PROP_SEQUENCE)) {
return image_animation_set_sequence(widget, value_str(v));
} else if (tk_str_eq(name, IMAGE_ANIMATION_PROP_AUTO_PLAY)) {
return image_animation_set_auto_play(widget, value_bool(v));
} else if (tk_str_eq(name, IMAGE_ANIMATION_PROP_INTERVAL)) {
return image_animation_set_interval(widget, value_int(v));
} else if (tk_str_eq(name, WIDGET_PROP_DELAY)) {
return image_animation_set_delay(widget, value_int(v));
} else if (tk_str_eq(name, WIDGET_PROP_FORMAT)) {
return image_animation_set_format(widget, value_str(v));
} else if (tk_str_eq(name, IMAGE_ANIMATION_PROP_UNLOAD_AFTER_PAINT)) {
return image_animation_set_unload_after_paint(widget, value_bool(v));
} else if (tk_str_eq(name, IMAGE_ANIMATION_PROP_REVERSE)) {
return image_animation_set_reverse(widget, value_bool(v));
} else if (tk_str_eq(name, IMAGE_ANIMATION_PROP_SHOW_WHEN_DENO)) {
return image_animation_set_show_when_done(widget, value_bool(v));
}
return RET_NOT_FOUND;
}
static ret_t image_animation_on_destroy(widget_t* widget) {
image_animation_t* image_animation = IMAGE_ANIMATION(widget);
return_value_if_fail(widget != NULL && image_animation != NULL, RET_BAD_PARAMS);
if (image_animation->timer_id != TK_INVALID_ID) {
timer_remove(image_animation->timer_id);
image_animation->timer_id = TK_INVALID_ID;
}
image_animation->image_buffer = NULL;
TKMEM_FREE(image_animation->image);
TKMEM_FREE(image_animation->sequence);
TKMEM_FREE(image_animation->format);
return RET_OK;
}
static const char* s_image_animation_clone_properties[] = {IMAGE_ANIMATION_PROP_LOOP,
IMAGE_ANIMATION_PROP_SEQUENCE,
IMAGE_ANIMATION_PROP_START_INDEX,
IMAGE_ANIMATION_PROP_END_INDEX,
IMAGE_ANIMATION_PROP_INTERVAL,
IMAGE_ANIMATION_PROP_AUTO_PLAY,
NULL};
TK_DECL_VTABLE(image_animation) = {.size = sizeof(image_animation_t),
.type = WIDGET_TYPE_IMAGE_ANIMATION,
.clone_properties = s_image_animation_clone_properties,
.get_parent_vt = TK_GET_PARENT_VTABLE(widget),
.create = image_animation_create,
.init = image_animation_init,
.on_destroy = image_animation_on_destroy,
.get_prop = image_animation_get_prop,
.set_prop = image_animation_set_prop,
.on_paint_self = image_animation_on_paint_self};
static ret_t image_animation_delay_play(const timer_info_t* info) {
widget_t* widget = NULL;
image_animation_t* image_animation = NULL;
return_value_if_fail(info != NULL, RET_REMOVE);
widget = WIDGET(info->ctx);
image_animation = IMAGE_ANIMATION(widget);
return_value_if_fail(widget != NULL && image_animation != NULL, RET_REMOVE);
image_animation->timer_id = TK_INVALID_ID;
image_animation_play(widget);
return RET_REMOVE;
}
static ret_t image_animation_start_init_if_not_inited(widget_t* widget) {
image_animation_t* image_animation = IMAGE_ANIMATION(widget);
return_value_if_fail(widget != NULL && image_animation != NULL, RET_BAD_PARAMS);
if (!(image_animation->inited)) {
if (image_animation->auto_play) {
if (image_animation->delay > 0) {
image_animation->timer_id =
timer_add(image_animation_delay_play, widget, image_animation->delay);
} else {
image_animation_play(widget);
}
}
image_animation->inited = TRUE;
}
return RET_OK;
}
static ret_t image_animation_init(widget_t* widget) {
image_animation_t* image_animation = IMAGE_ANIMATION(widget);
return_value_if_fail(image_animation != NULL, RET_BAD_PARAMS);
image_animation->index = 0;
image_animation->end_index = 0;
image_animation->start_index = 0;
image_animation->interval = 16;
image_animation->loop = TRUE;
image_animation->auto_play = FALSE;
return RET_OK;
}
widget_t* image_animation_create(widget_t* parent, xy_t x, xy_t y, wh_t w, wh_t h) {
widget_t* widget = widget_create(parent, TK_REF_VTABLE(image_animation), x, y, w, h);
return_value_if_fail(image_animation_init(widget) == RET_OK, NULL);
return widget;
}
ret_t image_animation_set_loop(widget_t* widget, bool_t loop) {
image_animation_t* image_animation = IMAGE_ANIMATION(widget);
return_value_if_fail(image_animation != NULL, RET_BAD_PARAMS);
image_animation->loop = loop;
return RET_OK;
}
ret_t image_animation_set_image(widget_t* widget, const char* image) {
image_animation_t* image_animation = IMAGE_ANIMATION(widget);
return_value_if_fail(image_animation != NULL && image != NULL, RET_BAD_PARAMS);
image_animation->image = tk_str_copy(image_animation->image, image);
return RET_OK;
}
ret_t image_animation_set_interval(widget_t* widget, uint32_t interval) {
image_animation_t* image_animation = IMAGE_ANIMATION(widget);
return_value_if_fail(image_animation != NULL, RET_BAD_PARAMS);
image_animation->interval = interval;
if (image_animation->timer_id != TK_INVALID_ID) {
const timer_info_t* info = timer_find(image_animation->timer_id);
assert(info != NULL);
if (info != NULL && info->duration != image_animation->interval) {
timer_modify(info->id, image_animation->interval);
}
}
return RET_OK;
}
ret_t image_animation_set_delay(widget_t* widget, uint32_t delay) {
image_animation_t* image_animation = IMAGE_ANIMATION(widget);
return_value_if_fail(image_animation != NULL, RET_BAD_PARAMS);
image_animation->delay = delay;
return RET_OK;
}
ret_t image_animation_set_auto_play(widget_t* widget, bool_t auto_play) {
image_animation_t* image_animation = IMAGE_ANIMATION(widget);
return_value_if_fail(image_animation != NULL, RET_BAD_PARAMS);
image_animation->auto_play = auto_play;
return RET_OK;
}
ret_t image_animation_set_unload_after_paint(widget_t* widget, bool_t unload_after_paint) {
image_animation_t* image_animation = IMAGE_ANIMATION(widget);
return_value_if_fail(image_animation != NULL, RET_BAD_PARAMS);
image_animation->unload_after_paint = unload_after_paint;
return RET_OK;
}
ret_t image_animation_set_sequence(widget_t* widget, const char* sequence) {
image_animation_t* image_animation = IMAGE_ANIMATION(widget);
return_value_if_fail(image_animation != NULL && sequence != NULL, RET_BAD_PARAMS);
if (sequence != NULL && sequence[0] != '\0') {
image_animation->index = 0;
image_animation->end_index = 0;
image_animation->start_index = 0;
image_animation->sequence = tk_str_copy(image_animation->sequence, sequence);
} else {
TKMEM_FREE(image_animation->sequence);
image_animation->sequence = NULL;
}
return widget_invalidate(widget, NULL);
}
ret_t image_animation_set_range_sequence(widget_t* widget, uint32_t start_index,
uint32_t end_index) {
image_animation_t* image_animation = IMAGE_ANIMATION(widget);
return_value_if_fail(image_animation != NULL, RET_BAD_PARAMS);
image_animation->index = start_index;
image_animation->end_index = end_index;
image_animation->start_index = start_index;
return RET_OK;
}
static ret_t image_animation_restart(image_animation_t* image_animation) {
if (image_animation->sequence != NULL) {
image_animation->index = 0;
} else {
image_animation->index = image_animation->start_index;
}
return RET_REPEAT;
}
ret_t image_animation_next(widget_t* widget) {
ret_t ret = RET_DONE;
image_animation_t* image_animation = IMAGE_ANIMATION(widget);
return_value_if_fail(image_animation != NULL, RET_BAD_PARAMS);
if (image_animation->sequence) {
if (image_animation->index + 1 < strlen(image_animation->sequence)) {
image_animation->index++;
ret = RET_OK;
}
} else {
if (image_animation->index < image_animation->end_index) {
image_animation->index++;
ret = RET_OK;
}
}
return ret;
}
ret_t image_animation_update(widget_t* widget) {
ret_t ret = RET_REMOVE;
image_animation_t* image_animation = IMAGE_ANIMATION(widget);
return_value_if_fail(image_animation != NULL && image_animation->image != NULL, RET_REMOVE);
ret = image_animation_next(widget);
if (ret == RET_DONE) {
if (image_animation->loop) {
event_t e = event_init(EVT_ANIM_ONCE, widget);
widget_dispatch(widget, &e);
ret = image_animation_restart(image_animation);
} else {
event_t e = event_init(EVT_ANIM_END, widget);
image_animation_play_to_done(image_animation);
ret = RET_REMOVE;
image_animation->timer_id = TK_INVALID_ID;
widget_dispatch(widget, &e);
}
} else {
ret = RET_REPEAT;
}
widget_invalidate_force(widget, NULL);
return ret;
}
static ret_t image_animation_on_update(const timer_info_t* info) {
ret_t ret = RET_OK;
widget_t* widget = WIDGET(info->ctx);
image_animation_t* image_animation = IMAGE_ANIMATION(widget);
return_value_if_fail(info != NULL && image_animation != NULL, RET_BAD_PARAMS);
image_animation->playing = TRUE;
ret = image_animation_update(widget);
return ret;
}
ret_t image_animation_play(widget_t* widget) {
image_animation_t* image_animation = IMAGE_ANIMATION(widget);
return_value_if_fail(image_animation != NULL, RET_BAD_PARAMS);
if (image_animation->timer_id == TK_INVALID_ID) {
image_animation->timer_id =
timer_add(image_animation_on_update, widget, image_animation->interval);
}
return RET_OK;
}
bool_t image_animation_is_playing(widget_t* widget) {
image_animation_t* image_animation = IMAGE_ANIMATION(widget);
return_value_if_fail(image_animation != NULL, RET_BAD_PARAMS);
return image_animation->playing;
}
ret_t image_animation_stop(widget_t* widget) {
image_animation_t* image_animation = IMAGE_ANIMATION(widget);
return_value_if_fail(image_animation != NULL, RET_BAD_PARAMS);
image_animation_pause(widget);
image_animation_play_to_done(image_animation);
return RET_OK;
}
ret_t image_animation_pause(widget_t* widget) {
image_animation_t* image_animation = IMAGE_ANIMATION(widget);
return_value_if_fail(image_animation != NULL, RET_BAD_PARAMS);
if (image_animation->timer_id != TK_INVALID_ID) {
timer_remove(image_animation->timer_id);
image_animation->timer_id = TK_INVALID_ID;
image_animation->playing = FALSE;
}
return RET_OK;
}
ret_t image_animation_set_format(widget_t* widget, const char* format) {
image_animation_t* image_animation = IMAGE_ANIMATION(widget);
return_value_if_fail(image_animation != NULL && format != NULL, RET_BAD_PARAMS);
if (format != NULL && format[0] != '\0') {
image_animation->format = tk_str_copy(image_animation->format, format);
} else {
TKMEM_FREE(image_animation->format);
image_animation->format = NULL;
}
return widget_invalidate(widget, NULL);
}
ret_t image_animation_set_reverse(widget_t* widget, bool_t reverse) {
image_animation_t* image_animation = IMAGE_ANIMATION(widget);
return_value_if_fail(image_animation != NULL, RET_BAD_PARAMS);
image_animation->reverse = reverse;
return RET_OK;
}
ret_t image_animation_set_show_when_done(widget_t* widget, bool_t show_when_done) {
image_animation_t* image_animation = IMAGE_ANIMATION(widget);
return_value_if_fail(image_animation != NULL, RET_BAD_PARAMS);
image_animation->show_when_done = show_when_done;
return RET_OK;
}
widget_t* image_animation_cast(widget_t* widget) {
return_value_if_fail(WIDGET_IS_INSTANCE_OF(widget, image_animation), NULL);
return widget;
}
|
0 |
repos/awtk/src/ext_widgets
|
repos/awtk/src/ext_widgets/mledit/line_number.c
|
/**
* File: line_number.h
* Author: AWTK Develop Team
* Brief: line_number
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2019-07-03 Li XianJing <[email protected]> created
*
*/
#include "tkc/mem.h"
#include "tkc/utils.h"
#include "mledit/line_number.h"
#include "base/widget_vtable.h"
#include "base/window_manager.h"
static uint32_t line_number_get_line_num(line_number_t* line_number, uint32_t line) {
uint32_t line_num;
if (line_number->lines_of_each_row == NULL || line >= line_number->lines_of_each_row_len) {
line_num = 1;
} else {
line_num = tk_max(line_number->lines_of_each_row[line], 1);
}
return line_num;
}
static ret_t line_number_do_paint_self(widget_t* widget, canvas_t* c) {
uint32_t y = 0;
uint32_t x = 2;
uint32_t line = 0;
char str[32] = {0};
wstr_t* text = &(widget->text);
uint32_t w = widget->w - 2 * x;
rect_t r = rect_init(0, 0, 0, 0);
line_number_t* line_number = LINE_NUMBER(widget);
ENSURE(line_number);
int32_t yoffset = line_number->yoffset;
int32_t line_height = line_number->line_height;
style_t* style = widget->astyle;
return_value_if_fail(line_height > 0, RET_BAD_PARAMS);
if (style_is_valid(style)) {
uint32_t line_index = 0;
color_t trans = color_init(0, 0, 0, 0);
widget_prepare_text_style_ex(widget, c, trans, NULL, TK_DEFAULT_FONT_SIZE, ALIGN_H_RIGHT,
ALIGN_V_TOP);
color_t active_bg = style_get_color(style, LINE_NUMBER_STYLE_ACTIVE_LINE_BG_COLOR, trans);
color_t highlight_bg = style_get_color(style, LINE_NUMBER_STYLE_HIGHLIGHT_LINE_BG_COLOR, trans);
const char* highlight_shape = style_get_str(style, LINE_NUMBER_STYLE_HIGHLIGHT_LINE_SHAPE,
LINE_NUMBER_STYLE_HIGHLIGHT_LINE_SHAPE_CIRCLE);
while (1) {
if (line > 0) {
line_index += line_number_get_line_num(line_number, line - 1);
}
y = line_height * line_index + line_number->top_margin;
if ((y + line_height) < yoffset) {
line++;
continue;
}
if (y >= (yoffset + widget->h)) {
break;
}
r = rect_init(x, y - yoffset, w, line_height);
tk_snprintf(str, sizeof(str), "%u", (line + 1));
if (line == line_number->active_line && active_bg.rgba.a) {
canvas_set_fill_color(c, active_bg);
canvas_fill_rect(c, r.x, r.y, r.w, r.h);
} else if (line_number_is_highlight_line(widget, line) && highlight_bg.rgba.a) {
canvas_set_fill_color(c, highlight_bg);
if (highlight_shape[0] == 'c') {
rect_t save_r = r;
int32_t size = tk_min(r.w, r.h) / 2;
int32_t dx = (r.w - size) / 2;
int32_t dy = (r.h - size) / 2;
int32_t rr = size / 2;
r.x += dx;
r.y += dy;
r.w = size;
r.h = size;
canvas_fill_rounded_rect(c, &r, &r, &highlight_bg, rr);
r = save_r;
} else {
canvas_fill_rect(c, r.x, r.y, r.w, r.h);
}
}
wstr_set_utf8(text, str);
canvas_draw_text_in_rect(c, text->str, text->size, &r);
line++;
}
}
return RET_OK;
}
static ret_t line_number_on_paint_self(widget_t* widget, canvas_t* c) {
rect_t save_r = {0, 0, 0, 0};
rect_t clip_r = {0, 0, 0, 0};
rect_t edit_r = {0, 0, 0, 0};
line_number_t* line_number = LINE_NUMBER(widget);
return_value_if_fail(line_number != NULL, RET_BAD_PARAMS);
canvas_get_clip_rect(c, &save_r);
edit_r = rect_init(c->ox, c->oy + line_number->top_margin, widget->w,
widget->h - line_number->top_margin - line_number->bottom_margin);
clip_r = rect_intersect(&save_r, &edit_r);
canvas_set_clip_rect(c, &clip_r);
line_number_do_paint_self(widget, c);
canvas_set_clip_rect(c, &save_r);
return RET_OK;
}
ret_t line_number_set_yoffset(widget_t* widget, int32_t yoffset) {
line_number_t* line_number = LINE_NUMBER(widget);
return_value_if_fail(line_number != NULL, RET_BAD_PARAMS);
line_number->yoffset = yoffset;
return widget_invalidate_force(widget, NULL);
}
ret_t line_number_set_line_height(widget_t* widget, int32_t line_height) {
line_number_t* line_number = LINE_NUMBER(widget);
return_value_if_fail(line_number != NULL, RET_BAD_PARAMS);
line_number->line_height = line_height;
return widget_invalidate_force(widget, NULL);
}
ret_t line_number_set_top_margin(widget_t* widget, int32_t top_margin) {
line_number_t* line_number = LINE_NUMBER(widget);
return_value_if_fail(line_number != NULL, RET_BAD_PARAMS);
line_number->top_margin = top_margin;
return widget_invalidate_force(widget, NULL);
}
ret_t line_number_set_bottom_margin(widget_t* widget, int32_t bottom_margin) {
line_number_t* line_number = LINE_NUMBER(widget);
return_value_if_fail(line_number != NULL, RET_BAD_PARAMS);
line_number->bottom_margin = bottom_margin;
return widget_invalidate_force(widget, NULL);
}
ret_t line_number_set_lines_of_each_row(widget_t* widget, const uint32_t* lines_of_each_row,
uint32_t len) {
line_number_t* line_number = LINE_NUMBER(widget);
return_value_if_fail(line_number != NULL && lines_of_each_row != NULL && len > 0, RET_BAD_PARAMS);
if (line_number->lines_of_each_row == NULL || line_number->lines_of_each_row_len != len) {
line_number->lines_of_each_row = TKMEM_REALLOCT(uint32_t, line_number->lines_of_each_row, len);
return_value_if_fail(line_number->lines_of_each_row != NULL,
(line_number->lines_of_each_row_len = 0, RET_OOM));
line_number->lines_of_each_row_len = len;
}
memcpy(line_number->lines_of_each_row, lines_of_each_row, sizeof(uint32_t) * len);
return widget_invalidate_force(widget, NULL);
}
static ret_t line_number_on_destroy(widget_t* widget) {
line_number_t* line_number = LINE_NUMBER(widget);
return_value_if_fail(line_number != NULL, RET_BAD_PARAMS);
if (line_number->highlight_lines != NULL) {
typed_array_destroy(line_number->highlight_lines);
line_number->highlight_lines = NULL;
}
if (line_number->lines_of_each_row != NULL) {
TKMEM_FREE(line_number->lines_of_each_row);
line_number->lines_of_each_row_len = 0;
}
return RET_OK;
}
static ret_t line_number_get_prop(widget_t* widget, const char* name, value_t* v) {
line_number_t* line_number = LINE_NUMBER(widget);
return_value_if_fail(line_number != NULL && name != NULL && v != NULL, RET_BAD_PARAMS);
return RET_NOT_FOUND;
}
static ret_t line_number_set_prop(widget_t* widget, const char* name, const value_t* v) {
return_value_if_fail(widget != NULL && name != NULL && v != NULL, RET_BAD_PARAMS);
return RET_NOT_FOUND;
}
static ret_t line_number_init(widget_t* widget) {
line_number_t* line_number = LINE_NUMBER(widget);
return_value_if_fail(line_number != NULL, RET_BAD_PARAMS);
line_number->active_line = -1;
return RET_OK;
}
TK_DECL_VTABLE(line_number) = {.size = sizeof(line_number_t),
.type = WIDGET_TYPE_LINE_NUMBER,
.get_parent_vt = TK_GET_PARENT_VTABLE(widget),
.create = line_number_create,
.init = line_number_init,
.set_prop = line_number_set_prop,
.get_prop = line_number_get_prop,
.on_paint_self = line_number_on_paint_self,
.on_destroy = line_number_on_destroy};
widget_t* line_number_create(widget_t* parent, xy_t x, xy_t y, wh_t w, wh_t h) {
widget_t* widget = widget_create(parent, TK_REF_VTABLE(line_number), x, y, w, h);
return_value_if_fail(line_number_init(widget) == RET_OK, NULL);
return widget;
}
widget_t* line_number_cast(widget_t* widget) {
return_value_if_fail(WIDGET_IS_INSTANCE_OF(widget, line_number), NULL);
return widget;
}
static ret_t line_number_ensure_highlight_lines(line_number_t* line_number) {
return_value_if_fail(line_number != NULL, RET_BAD_PARAMS);
if (line_number->highlight_lines == NULL) {
line_number->highlight_lines = typed_array_create(VALUE_TYPE_INT32, 10);
}
return line_number->highlight_lines != NULL ? RET_OK : RET_FAIL;
}
bool_t line_number_is_highlight_line(widget_t* widget, int32_t line) {
line_number_t* line_number = LINE_NUMBER(widget);
if (line_number != NULL && line_number->highlight_lines != NULL) {
value_t v;
uint32_t i = 0;
for (i = 0; i < line_number->highlight_lines->size; i++) {
typed_array_get(line_number->highlight_lines, i, &v);
if (value_int(&v) == line) {
return TRUE;
}
}
}
return FALSE;
}
ret_t line_number_add_highlight_line(widget_t* widget, int32_t line) {
value_t v;
line_number_t* line_number = LINE_NUMBER(widget);
return_value_if_fail(line_number_ensure_highlight_lines(line_number) == RET_OK, RET_OOM);
widget_invalidate(widget, NULL);
return typed_array_push(line_number->highlight_lines, value_set_int(&v, line));
}
ret_t line_number_set_active_line(widget_t* widget, int32_t line) {
line_number_t* line_number = LINE_NUMBER(widget);
return_value_if_fail(line_number != NULL, RET_BAD_PARAMS);
line_number->active_line = line;
widget_invalidate(widget, NULL);
return RET_OK;
}
ret_t line_number_clear_highlight(widget_t* widget) {
line_number_t* line_number = LINE_NUMBER(widget);
return_value_if_fail(line_number != NULL, RET_BAD_PARAMS);
return typed_array_clear(line_number->highlight_lines);
}
|
0 |
repos/awtk/src/ext_widgets
|
repos/awtk/src/ext_widgets/mledit/mledit.h
|
/**
* File: mledit.h
* Author: AWTK Develop Team
* Brief: mledit
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2019-06-08 Li XianJing <[email protected]> created
*
*/
#ifndef TK_MLEDIT_H
#define TK_MLEDIT_H
#include "base/widget.h"
#include "base/text_edit.h"
BEGIN_C_DECLS
/**
* @class mledit_t
* @parent widget_t
* @annotation ["scriptable","design","widget"]
* 多行编辑器控件。
*
* mledit\_t是[widget\_t](widget_t.md)的子类控件，widget\_t的函数均适用于mledit\_t控件。
*
* 在xml中使用"mledit"标签创建多行编辑器控件。如：
*
* ```xml
* <mledit x="c" y="m" w="300" h="300" />
* ```
*
* > 更多用法请参考：[mledit.xml](
* https://github.com/zlgopen/awtk/blob/master/design/default/ui/mledit.xml)
*
* 在c代码中使用函数mledit\_create创建多行编辑器控件。如：
*
* ```c
* widget_t* tc = mledit_create(win, 10, 10, 240, 240);
* ```
*
* > 完整示例请参考：[mledit demo](
* https://github.com/zlgopen/awtk-c-demos/blob/master/demos/mledit.c)
*
* time\_clock一般不需要设置style。
*
*/
typedef struct _mledit_t {
widget_t widget;
/**
* @property {char*} tips
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 输入提示。
*/
char* tips;
/**
* @property {char*} tr_tips
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 保存用于翻译的提示信息。
*/
char* tr_tips;
/**
* @property {char*} keyboard
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 自定义软键盘名称。
*/
char* keyboard;
/**
* @property {uint32_t} max_lines
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 最大行数。
*/
uint32_t max_lines;
/**
* @property {uint32_t} max_chars
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 最大字符数。
*/
uint32_t max_chars;
/**
* @property {uint32_t} scroll_line
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 鼠标一次滚动行数。
*/
uint32_t scroll_line;
/**
* @property {bool_t} overwrite
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 是否启用覆盖行。
*/
bool_t overwrite;
/**
* @property {bool_t} wrap_word
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 是否自动折行。
*/
bool_t wrap_word;
/**
* @property {bool_t} readonly
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 编辑器是否为只读。
*/
bool_t readonly;
/**
* @property {bool_t} cancelable
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 是否支持撤销编辑。如果为TRUE，在失去焦点之前可以撤销所有修改(恢复获得焦点之前的内容)。
*
* > * 1.一般配合keyboard的"cancel"按钮使用。
* > * 2.为TRUE时，如果内容有变化，会设置编辑器的状态为changed，所以此时编辑器需要支持changed状态的style。
*/
bool_t cancelable;
/**
* @property {bool_t} open_im_when_focused
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 获得焦点时打开输入法。
*
* > 主要用于没有指针设备的情况，否则每次切换焦点时都打开输入法。
*/
bool_t open_im_when_focused;
/**
* @property {bool_t} close_im_when_blured
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
*
* 是否在失去焦点时关闭输入法(默认是)。
*
*/
bool_t close_im_when_blured;
/*private*/
bool_t lock_scrollbar_value;
uint8_t margin;
uint8_t top_margin;
uint8_t left_margin;
uint8_t right_margin;
uint8_t bottom_margin;
bool_t is_key_inputing;
bool_t is_activated;
text_edit_t* model;
uint32_t timer_id;
wstr_t temp;
wstr_t saved_text;
wstr_t last_changing_text;
wstr_t last_changed_text;
} mledit_t;
/**
* @event {value_change_event_t} EVT_VALUE_CHANGING
* 文本正在改变事件(编辑中)。
*/
/**
* @event {value_change_event_t} EVT_VALUE_CHANGED
* 文本改变事件(编辑完成或设置文本时触发)。
*/
/**
* @method mledit_create
* 创建mledit对象
* @annotation ["constructor", "scriptable"]
* @param {widget_t*} parent 父控件
* @param {xy_t} x x坐标
* @param {xy_t} y y坐标
* @param {wh_t} w 宽度
* @param {wh_t} h 高度
*
* @return {widget_t*} 对象。
*/
widget_t* mledit_create(widget_t* parent, xy_t x, xy_t y, wh_t w, wh_t h);
/**
* @method mledit_set_readonly
* 设置编辑器是否为只读。
* @annotation ["scriptable"]
* @param {widget_t*} widget widget对象。
* @param {bool_t} readonly 只读。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t mledit_set_readonly(widget_t* widget, bool_t readonly);
/**
* @method mledit_set_cancelable
* 设置编辑器是否为可撤销修改。
* @annotation ["scriptable"]
* @param {widget_t*} widget widget对象。
* @param {bool_t} cancelable 是否为可撤销修。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t mledit_set_cancelable(widget_t* widget, bool_t cancelable);
/**
* @method mledit_set_focus
* 设置为焦点。
* @annotation ["scriptable"]
* @param {widget_t*} widget widget对象。
* @param {bool_t} focus 是否为焦点。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t mledit_set_focus(widget_t* widget, bool_t focus);
/**
* @method mledit_set_wrap_word
* 设置编辑器是否自动折行。
* @annotation ["scriptable"]
* @param {widget_t*} widget widget对象。
* @param {bool_t} wrap_word 是否自动折行。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t mledit_set_wrap_word(widget_t* widget, bool_t wrap_word);
/**
* @method mledit_set_overwrite
* 设置编辑器是否启用覆盖行（在行数达到最大行数时，可继续新增行，但最早的行将会消失）。
* @annotation ["scriptable"]
* @param {widget_t*} widget widget对象。
* @param {bool_t} overwrite 是否启用覆盖行。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t mledit_set_overwrite(widget_t* widget, bool_t overwrite);
/**
* @method mledit_set_max_lines
* 设置编辑器的最大行数。
* @annotation ["scriptable"]
* @param {widget_t*} widget widget对象。
* @param {uint32_t} max_lines 最大行数。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t mledit_set_max_lines(widget_t* widget, uint32_t max_lines);
/**
* @method mledit_set_max_chars
* 设置编辑器的最大字符数（0 为不限制字符数）。
* @annotation ["scriptable"]
* @param {widget_t*} widget widget对象。
* @param {uint32_t} max_chars 最大字符数。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t mledit_set_max_chars(widget_t* widget, uint32_t max_chars);
/**
* @method mledit_set_tips
* 设置编辑器的输入提示。
* @annotation ["scriptable"]
* @param {widget_t*} widget widget对象。
* @param {const char*} tips 输入提示。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t mledit_set_tips(widget_t* widget, const char* tips);
/**
* @method mledit_set_tr_tips
* 获取翻译之后的文本，然后调用mledit_set_tips。
* @annotation ["scriptable"]
* @param {widget_t*} widget 控件对象。
* @param {const char*} tr_tips 提示信息。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t mledit_set_tr_tips(widget_t* widget, const char* tr_tips);
/**
* @method mledit_set_keyboard
* 设置自定义软键盘名称。
*
* @annotation ["scriptable"]
* @param {widget_t*} widget widget对象。
* @param {const char*} keyboard 键盘名称(相应UI资源必须存在)。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t mledit_set_keyboard(widget_t* widget, const char* keyboard);
/**
* @method mledit_set_cursor
* 设置编辑器光标位置。
* @annotation ["scriptable"]
* @param {widget_t*} widget widget对象。
* @param {uint32_t} cursor 光标位置。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t mledit_set_cursor(widget_t* widget, uint32_t cursor);
/**
* @method mledit_get_cursor
* 获取编辑器光标位置。
* @annotation ["scriptable"]
* @param {widget_t*} widget widget对象。
*
* @return {uint32_t} 返回光标位置。
*/
uint32_t mledit_get_cursor(widget_t* widget);
/**
* @method mledit_set_scroll_line
* 设置编辑器滚动速度。
* @annotation ["scriptable"]
* @param {widget_t*} widget widget对象。
* @param {uint32_t} scroll_line 滚动行数。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t mledit_set_scroll_line(widget_t* widget, uint32_t scroll_line);
/**
* @method mledit_scroll_to_offset
* 设置编辑器滚动到指定偏移位置。
* @annotation ["scriptable"]
* @param {widget_t*} widget widget对象。
* @param {uint32_t} offset 偏移位置。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t mledit_scroll_to_offset(widget_t* widget, uint32_t offset);
/**
* @method mledit_set_open_im_when_focused
* 设置编辑器是否在获得焦点时打开输入法。
*
*> * 设置默认焦点时，打开窗口时不弹出软键盘。
*> * 用键盘切换焦点时，编辑器获得焦点时不弹出软键盘。
*
* @annotation ["scriptable"]
* @param {widget_t*} widget widget对象。
* @param {bool_t} open_im_when_focused 是否在获得焦点时打开输入法。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t mledit_set_open_im_when_focused(widget_t* widget, bool_t open_im_when_focused);
/**
* @method mledit_set_close_im_when_blured
* 设置编辑器是否在失去焦点时关闭输入法。
*
* @annotation ["scriptable"]
* @param {widget_t*} widget widget对象。
* @param {bool_t} close_im_when_blured 是否是否在失去焦点时关闭输入法。在失去焦点时关闭输入法。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t mledit_set_close_im_when_blured(widget_t* widget, bool_t close_im_when_blured);
/**
* @method mledit_set_select
* 选择编辑器中指定范围的文本。
* @annotation ["scriptable"]
* @param {widget_t*} widget widget对象。
* @param {uint32_t} start 起始偏移。
* @param {uint32_t} end 结束偏移。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t mledit_set_select(widget_t* widget, uint32_t start, uint32_t end);
/**
* @method mledit_get_selected_text
* 获取选中的文本。
* 使用完后需调用 TKMEM_FREE() 进行释放文本占有内存。
* @annotation ["scriptable"]
* @param {widget_t*} widget widget对象。
*
* @return {char*} 返回选中文本。
*/
char* mledit_get_selected_text(widget_t* widget);
/**
* @method mledit_get_current_line_index
* 获取光标所在视觉行号(一行文本可能分多行显示)。
* @annotation ["scriptable"]
* @param {widget_t*} widget widget对象。
*
* @return {uint32_t} 返回光标所在行号。
*/
uint32_t mledit_get_current_line_index(widget_t* widget);
/**
* @method mledit_get_current_row_index
* 获取光标所在物理行号。
* @annotation ["scriptable"]
* @param {widget_t*} widget widget对象。
*
* @return {uint32_t} 返回光标所在行号。
*/
uint32_t mledit_get_current_row_index(widget_t* widget);
/**
* @method mledit_insert_text
* 插入一段文本。
* @annotation ["scriptable"]
* @param {widget_t*} widget widget对象。
* @param {uint32_t} offset 插入的偏移位置。
* @param {const char*} text 待插入的文本。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t mledit_insert_text(widget_t* widget, uint32_t offset, const char* text);
/**
* @method mledit_cast
* 转换为mledit对象(供脚本语言使用)。
* @annotation ["cast", "scriptable"]
* @param {widget_t*} widget mledit对象。
*
* @return {widget_t*} mledit对象。
*/
widget_t* mledit_cast(widget_t* widget);
#define WIDGET_TYPE_MLEDIT "mledit"
#define MLEDIT_PROP_MAX_LINES "max_lines"
#define MLEDIT_PROP_MAX_CHARS "max_chars"
#define MLEDIT_PROP_WRAP_WORD "wrap_word"
#define MLEDIT_PROP_OVERWRITE "overwrite"
#define MLEDIT_PROP_SCROLL_LINE "scroll_line"
#define MLEDIT(widget) ((mledit_t*)(mledit_cast(WIDGET(widget))))
/*for compatability*/
#define mledit_set_input_tips(w, t) mledit_set_tips(w, t)
/*public for subclass and runtime type check*/
TK_EXTERN_VTABLE(mledit);
END_C_DECLS
#endif /*TK_MLEDIT_H*/
|
0 |
repos/awtk/src/ext_widgets
|
repos/awtk/src/ext_widgets/mledit/line_number.h
|
/**
* File: line_number.h
* Author: AWTK Develop Team
* Brief: line_number
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2019-07-03 Li XianJing <[email protected]> created
*
*/
#ifndef TK_LINE_NUMBER_H
#define TK_LINE_NUMBER_H
#include "base/widget.h"
#include "tkc/typed_array.h"
BEGIN_C_DECLS
/**
* @class line_number_t
* @parent widget_t
* @annotation ["scriptable","design","widget"]
*
* 行号。多行编辑器的行号。
*
* line\_number\_t是[widget\_t](widget_t.md)的子类控件，widget\_t的函数均适用于line\_number\_t控件。
*
* 在xml中使用"lin\e_number"标签创建行号控件，一般配合mledit使用。如：
*
* ```xml
* <mledit x="c" y="10" h="40%" w="90%" focus="true" left_margin="36" right_margin="16"
wrap_word="true">
* <line_number x="0" y="0" w="32" h="100%" value="0"/>
* <scroll_bar_d x="right" y="0" w="14" h="100%" value="0"/>
* </mledit>
* ```
*
* > 更多用法请参考：[mledit.xml](
*https://github.com/zlgopen/awtk/blob/master/design/default/ui/mledit.xml)
*
* 可用通过style来设置控件的显示风格，如字体的大小和颜色等等。如：
*
* ```xml
* <line_number>
* <style name="default">
<normal text_color="black" bg_color="#d0d0d0" text_align_h="right"/>
* </style>
* </line_number>
* ```
*
* > 更多用法请参考：
* [theme default](
*https://github.com/zlgopen/awtk/blob/master/design/default/styles/default.xml#L556)
*
*/
typedef struct _line_number_t {
widget_t widget;
/*private*/
/*由mledit设置*/
int32_t yoffset;
int32_t line_height;
int32_t top_margin;
int32_t bottom_margin;
uint32_t* lines_of_each_row;
uint32_t lines_of_each_row_len;
int32_t active_line;
typed_array_t* highlight_lines;
} line_number_t;
/**
* @method line_number_create
* @annotation ["constructor", "scriptable"]
* 创建line_number对象
* @param {widget_t*} parent 父控件
* @param {xy_t} x x坐标
* @param {xy_t} y y坐标
* @param {wh_t} w 宽度
* @param {wh_t} h 高度
*
* @return {widget_t*} 对象。
*/
widget_t* line_number_create(widget_t* parent, xy_t x, xy_t y, wh_t w, wh_t h);
/**
* @method line_number_set_top_margin
* 设置顶部边距。
* @annotation ["scriptable"]
* @param {widget_t*} widget 控件对象。
* @param {int32_t} top_margin 顶部边距。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t line_number_set_top_margin(widget_t* widget, int32_t top_margin);
/**
* @method line_number_set_bottom_margin
* 设置顶部边距。
* @annotation ["scriptable"]
* @param {widget_t*} widget 控件对象。
* @param {int32_t} bottom_margin 顶部边距。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t line_number_set_bottom_margin(widget_t* widget, int32_t bottom_margin);
/**
* @method line_number_set_line_height
* 设置行高。
* @annotation ["scriptable"]
* @param {widget_t*} widget 控件对象。
* @param {int32_t} line_height 行高。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t line_number_set_line_height(widget_t* widget, int32_t line_height);
/**
* @method line_number_set_yoffset
* 设置y偏移。
* @annotation ["scriptable"]
* @param {widget_t*} widget 控件对象。
* @param {int32_t} yoffset 行高。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t line_number_set_yoffset(widget_t* widget, int32_t yoffset);
/**
* @method line_number_set_lines_of_each_row
* 设置每一个逻辑行(row)占几个物理行(line)。
* @param {widget_t*} widget 控件对象。
* @param {const uint32_t*} lines_of_each_row 每一个逻辑行占几个物理行。
* @param {uint32_t} len 数组大小(逻辑行数)。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t line_number_set_lines_of_each_row(widget_t* widget, const uint32_t* lines_of_each_row,
uint32_t len);
/**
* @method line_number_cast
* 转换为line_number对象(供脚本语言使用)。
* @annotation ["cast", "scriptable"]
* @param {widget_t*} widget line_number对象。
*
* @return {widget_t*} line_number对象。
*/
widget_t* line_number_cast(widget_t* widget);
/**
* @method line_number_add_highlight_line
* 增加高亮行。
* @annotation ["scriptable"]
* @param {widget_t*} widget 控件对象。
* @param {int32_t} line 行号。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t line_number_add_highlight_line(widget_t* widget, int32_t line);
/**
* @method line_number_set_active_line
* 设置active行。
* @annotation ["scriptable"]
* @param {widget_t*} widget 控件对象。
* @param {int32_t} line 行号。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t line_number_set_active_line(widget_t* widget, int32_t line);
/**
* @method line_number_clear_highlight
* 清除高亮行。
* @annotation ["scriptable"]
* @param {widget_t*} widget 控件对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t line_number_clear_highlight(widget_t* widget);
/**
* @method line_number_is_highlight_line
* 判断指定行是否是高亮行。
* @annotation ["scriptable"]
* @param {widget_t*} widget 控件对象。
* @param {int32_t} line 行号。
*
* @return {bool_t} 返回TRUE表示是，否则不是。
*/
bool_t line_number_is_highlight_line(widget_t* widget, int32_t line);
#define WIDGET_TYPE_LINE_NUMBER "line_number"
#define LINE_NUMBER(widget) ((line_number_t*)(line_number_cast(WIDGET(widget))))
#define LINE_NUMBER_STYLE_ACTIVE_LINE_BG_COLOR "active_line_bg_color"
#define LINE_NUMBER_STYLE_HIGHLIGHT_LINE_BG_COLOR "highlight_line_bg_color"
#define LINE_NUMBER_STYLE_HIGHLIGHT_LINE_SHAPE "highlight_line_shape"
#define LINE_NUMBER_STYLE_HIGHLIGHT_LINE_SHAPE_CIRCLE "circle"
#define LINE_NUMBER_STYLE_HIGHLIGHT_LINE_SHAPE_RECT "rect"
/*public for subclass and runtime type check*/
TK_EXTERN_VTABLE(line_number);
END_C_DECLS
#endif /*TK_LINE_NUMBER_H*/
|
0 |
repos/awtk/src/ext_widgets
|
repos/awtk/src/ext_widgets/mledit/mledit.c
|
/**
* File: mledit.c
* Author: AWTK Develop Team
* Brief: mledit
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2019-06-08 Li XianJing <[email protected]> created
*
*/
#include "tkc/mem.h"
#include "tkc/utf8.h"
#include "tkc/utils.h"
#include "tkc/time_now.h"
#include "base/events.h"
#include "mledit/mledit.h"
#include "mledit/line_number.h"
#include "base/input_method.h"
#include "scroll_view/scroll_bar.h"
static ret_t mledit_init(widget_t* widget);
static ret_t mledit_update_status(widget_t* widget);
static ret_t mledit_dispatch_event(widget_t* widget, uint32_t type);
static ret_t mledit_save_text(widget_t* widget) {
mledit_t* mledit = MLEDIT(widget);
return_value_if_fail(mledit != NULL, RET_BAD_PARAMS);
if (mledit->cancelable) {
wstr_set(&(mledit->saved_text), widget->text.str);
}
return RET_OK;
}
static ret_t mledit_rollback_text(widget_t* widget) {
mledit_t* mledit = MLEDIT(widget);
return_value_if_fail(mledit != NULL, RET_BAD_PARAMS);
if (mledit->cancelable) {
wstr_set(&(mledit->last_changing_text), widget->text.str);
widget_set_text(widget, mledit->saved_text.str);
mledit_dispatch_event(widget, EVT_VALUE_CHANGING);
}
return RET_OK;
}
static ret_t mledit_commit_text(widget_t* widget) {
mledit_t* mledit = MLEDIT(widget);
return_value_if_fail(mledit != NULL, RET_BAD_PARAMS);
if (mledit->cancelable) {
wstr_set(&(mledit->saved_text), widget->text.str);
mledit_update_status(widget);
}
return RET_OK;
}
static ret_t mledit_dispatch_event(widget_t* widget, uint32_t type) {
value_change_event_t evt;
mledit_t* mledit = MLEDIT(widget);
wstr_t* text = &(widget->text);
wstr_t* last = &(mledit->last_changing_text);
if (type == EVT_VALUE_CHANGED) {
last = &(mledit->last_changed_text);
}
if ((last->size == 0 && text->size == 0) || wstr_equal(last, text)) {
return RET_NOT_MODIFIED;
}
value_change_event_init(&evt, type, widget);
value_set_wstr(&(evt.old_value), last->str);
value_set_wstr(&(evt.new_value), text->str);
widget_dispatch(widget, (event_t*)&evt);
if (type == EVT_VALUE_CHANGED) {
wstr_set(last, text->str);
}
return RET_OK;
}
ret_t mledit_set_tips(widget_t* widget, const char* tips) {
mledit_t* mledit = MLEDIT(widget);
return_value_if_fail(mledit != NULL, RET_BAD_PARAMS);
mledit->tips = tk_str_copy(mledit->tips, tips);
text_edit_set_tips(mledit->model, mledit->tips, TRUE);
return RET_OK;
}
static ret_t mledit_apply_tr_text_before_paint(void* ctx, event_t* e) {
widget_t* widget = WIDGET(ctx);
mledit_t* mledit = MLEDIT(widget);
return_value_if_fail(mledit != NULL, RET_BAD_PARAMS);
if (mledit->tr_tips != NULL) {
const char* tr_tips = locale_info_tr(widget_get_locale_info(widget), mledit->tr_tips);
mledit_set_tips(widget, tr_tips);
}
return RET_REMOVE;
}
ret_t mledit_set_tr_tips(widget_t* widget, const char* tr_tips) {
mledit_t* mledit = MLEDIT(widget);
widget_t* win = widget_get_window(widget);
return_value_if_fail(mledit != NULL, RET_BAD_PARAMS);
if (TK_STR_IS_EMPTY(tr_tips)) {
TKMEM_FREE(mledit->tr_tips);
return RET_OK;
}
mledit->tr_tips = tk_str_copy(mledit->tr_tips, tr_tips);
if (win != NULL) {
tr_tips = locale_info_tr(widget_get_locale_info(widget), tr_tips);
mledit_set_tips(widget, tr_tips);
} else {
widget_on(widget, EVT_BEFORE_PAINT, mledit_apply_tr_text_before_paint, widget);
}
return RET_OK;
}
ret_t mledit_set_keyboard(widget_t* widget, const char* keyboard) {
mledit_t* mledit = MLEDIT(widget);
return_value_if_fail(mledit != NULL, RET_BAD_PARAMS);
mledit->keyboard = tk_str_copy(mledit->keyboard, keyboard);
return RET_OK;
}
ret_t mledit_set_focus(widget_t* widget, bool_t focus) {
mledit_t* mledit = MLEDIT(widget);
return_value_if_fail(mledit != NULL, RET_BAD_PARAMS);
widget_set_focused(widget, focus);
mledit_update_status(widget);
return RET_OK;
}
ret_t mledit_set_readonly(widget_t* widget, bool_t readonly) {
mledit_t* mledit = MLEDIT(widget);
return_value_if_fail(mledit != NULL, RET_BAD_PARAMS);
mledit->readonly = readonly;
return RET_OK;
}
ret_t mledit_set_cancelable(widget_t* widget, bool_t cancelable) {
mledit_t* mledit = MLEDIT(widget);
return_value_if_fail(mledit != NULL, RET_BAD_PARAMS);
mledit->cancelable = cancelable;
return RET_OK;
}
ret_t mledit_set_wrap_word(widget_t* widget, bool_t wrap_word) {
mledit_t* mledit = MLEDIT(widget);
return_value_if_fail(mledit != NULL, RET_BAD_PARAMS);
mledit->wrap_word = wrap_word;
text_edit_set_wrap_word(mledit->model, wrap_word);
return RET_OK;
}
ret_t mledit_set_overwrite(widget_t* widget, bool_t overwrite) {
mledit_t* mledit = MLEDIT(widget);
return_value_if_fail(mledit != NULL, RET_BAD_PARAMS);
mledit->overwrite = overwrite;
return RET_OK;
}
ret_t mledit_set_max_lines(widget_t* widget, uint32_t max_lines) {
mledit_t* mledit = MLEDIT(widget);
return_value_if_fail(mledit != NULL, RET_BAD_PARAMS);
mledit->max_lines = max_lines;
text_edit_set_max_rows(mledit->model, max_lines);
text_edit_layout(mledit->model);
return RET_OK;
}
ret_t mledit_set_max_chars(widget_t* widget, uint32_t max_chars) {
mledit_t* mledit = MLEDIT(widget);
return_value_if_fail(mledit != NULL, RET_BAD_PARAMS);
mledit->max_chars = max_chars;
text_edit_set_max_chars(mledit->model, max_chars);
text_edit_layout(mledit->model);
return RET_OK;
}
static ret_t mledit_get_prop(widget_t* widget, const char* name, value_t* v) {
mledit_t* mledit = MLEDIT(widget);
return_value_if_fail(mledit != NULL && name != NULL && v != NULL, RET_BAD_PARAMS);
if (tk_str_eq(name, WIDGET_PROP_READONLY)) {
value_set_bool(v, mledit->readonly);
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_CANCELABLE)) {
value_set_bool(v, mledit->cancelable);
return RET_OK;
} else if (tk_str_eq(name, MLEDIT_PROP_WRAP_WORD)) {
value_set_bool(v, mledit->wrap_word);
return RET_OK;
} else if (tk_str_eq(name, MLEDIT_PROP_OVERWRITE)) {
value_set_bool(v, mledit->overwrite);
return RET_OK;
} else if (tk_str_eq(name, MLEDIT_PROP_MAX_LINES)) {
value_set_int(v, mledit->max_lines);
return RET_OK;
} else if (tk_str_eq(name, MLEDIT_PROP_MAX_CHARS)) {
value_set_int(v, mledit->max_chars);
return RET_OK;
} else if (tk_str_eq(name, MLEDIT_PROP_SCROLL_LINE)) {
value_set_int(v, mledit->scroll_line);
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_LEFT_MARGIN)) {
uint32_t margin = 0;
if (widget->astyle != NULL) {
TEXT_EDIT_GET_STYLE_MARGIN(widget->astyle, margin, LEFT);
}
if (margin == 0) {
margin = mledit->left_margin != 0 ? mledit->left_margin : mledit->margin;
}
value_set_int(v, margin);
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_RIGHT_MARGIN)) {
uint32_t margin = 0;
if (widget->astyle != NULL) {
TEXT_EDIT_GET_STYLE_MARGIN(widget->astyle, margin, RIGHT);
}
if (margin == 0) {
margin = mledit->right_margin != 0 ? mledit->right_margin : mledit->margin;
}
value_set_int(v, margin);
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_TOP_MARGIN)) {
uint32_t margin = 0;
if (widget->astyle != NULL) {
TEXT_EDIT_GET_STYLE_MARGIN(widget->astyle, margin, TOP);
}
if (margin == 0) {
margin = mledit->top_margin != 0 ? mledit->top_margin : mledit->margin;
}
value_set_int(v, margin);
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_BOTTOM_MARGIN)) {
uint32_t margin = 0;
if (widget->astyle != NULL) {
TEXT_EDIT_GET_STYLE_MARGIN(widget->astyle, margin, BOTTOM);
}
if (margin == 0) {
margin = mledit->bottom_margin != 0 ? mledit->bottom_margin : mledit->margin;
}
value_set_int(v, margin);
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_TIPS)) {
value_set_str(v, mledit->tips);
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_TR_TIPS)) {
value_set_str(v, mledit->tr_tips);
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_KEYBOARD)) {
value_set_str(v, mledit->keyboard);
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_FOCUSABLE)) {
value_set_bool(v, !(mledit->readonly));
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_VALUE)) {
value_set_wstr(v, widget->text.str);
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_CARET_X)) {
text_edit_state_t state;
text_edit_get_state(mledit->model, &state);
value_set_int(v, state.caret.x - state.ox);
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_CARET_Y)) {
text_edit_state_t state;
text_edit_get_state(mledit->model, &state);
value_set_int(v, state.caret.y - state.oy);
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_LINE_HEIGHT)) {
text_edit_state_t state;
text_edit_get_state(mledit->model, &state);
value_set_int(v, state.line_height);
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_OPEN_IM_WHEN_FOCUSED)) {
value_set_bool(v, mledit->open_im_when_focused);
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_CLOSE_IM_WHEN_BLURED)) {
value_set_bool(v, mledit->close_im_when_blured);
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_INPUTING)) {
input_method_t* im = input_method();
bool_t inputing = (im != NULL && im->widget == widget) || mledit->is_key_inputing;
/* 当控件没有父集窗口或者父集窗口没有打开的时候，通过 focused 来判断是否正在输入 */
if (!inputing && !widget_is_window_opened(widget)) {
inputing = widget->focused;
}
value_set_bool(v, inputing);
return RET_OK;
}
return RET_NOT_FOUND;
}
static void mledit_reset_text_edit_layout(text_edit_t* text_edit) {
text_edit_layout(text_edit);
text_edit_set_offset(text_edit, 0, 0);
text_edit_set_select(text_edit, 0, 0);
text_edit_set_cursor(text_edit, text_edit_get_cursor(text_edit));
}
static ret_t mledit_set_text(widget_t* widget, const value_t* v) {
wstr_t str;
wstr_init(&str, 0);
mledit_t* mledit = MLEDIT(widget);
ENSURE(mledit);
return_value_if_fail(wstr_from_value(&str, v) == RET_OK, RET_BAD_PARAMS);
if (!wstr_equal(&(widget->text), &str)) {
wstr_set(&(widget->text), str.str);
mledit_reset_text_edit_layout(mledit->model);
text_edit_layout(mledit->model);
mledit_dispatch_event(widget, EVT_VALUE_CHANGED);
mledit_update_status(widget);
}
wstr_reset(&str);
return RET_OK;
}
static ret_t mledit_set_prop(widget_t* widget, const char* name, const value_t* v) {
mledit_t* mledit = MLEDIT(widget);
return_value_if_fail(widget != NULL && name != NULL && v != NULL, RET_BAD_PARAMS);
if (tk_str_eq(name, WIDGET_PROP_TEXT) || tk_str_eq(name, WIDGET_PROP_VALUE)) {
mledit_set_text(widget, v);
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_READONLY)) {
mledit->readonly = value_bool(v);
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_CANCELABLE)) {
mledit->cancelable = value_bool(v);
return RET_OK;
} else if (tk_str_eq(name, MLEDIT_PROP_WRAP_WORD)) {
mledit_set_wrap_word(widget, value_bool(v));
return RET_OK;
} else if (tk_str_eq(name, MLEDIT_PROP_OVERWRITE)) {
mledit_set_overwrite(widget, value_bool(v));
return RET_OK;
} else if (tk_str_eq(name, MLEDIT_PROP_MAX_LINES)) {
mledit_set_max_lines(widget, value_int(v));
return RET_OK;
} else if (tk_str_eq(name, MLEDIT_PROP_MAX_CHARS)) {
mledit_set_max_chars(widget, value_int(v));
return RET_OK;
} else if (tk_str_eq(name, MLEDIT_PROP_SCROLL_LINE)) {
mledit_set_scroll_line(widget, value_int(v));
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_OPEN_IM_WHEN_FOCUSED)) {
mledit->open_im_when_focused = value_bool(v);
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_CLOSE_IM_WHEN_BLURED)) {
mledit->close_im_when_blured = value_bool(v);
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_MARGIN)) {
mledit->margin = value_int(v);
mledit_reset_text_edit_layout(mledit->model);
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_LEFT_MARGIN)) {
mledit->left_margin = value_int(v);
mledit_reset_text_edit_layout(mledit->model);
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_RIGHT_MARGIN)) {
mledit->right_margin = value_int(v);
mledit_reset_text_edit_layout(mledit->model);
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_TOP_MARGIN)) {
mledit->top_margin = value_int(v);
mledit_reset_text_edit_layout(mledit->model);
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_BOTTOM_MARGIN)) {
mledit->bottom_margin = value_int(v);
mledit_reset_text_edit_layout(mledit->model);
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_FOCUS) || tk_str_eq(name, WIDGET_PROP_FOCUSED)) {
mledit_set_focus(widget, value_bool(v));
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_TIPS)) {
mledit_set_tips(widget, value_str(v));
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_TR_TIPS)) {
mledit_set_tr_tips(widget, value_str(v));
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_KEYBOARD)) {
mledit_set_keyboard(widget, value_str(v));
return RET_OK;
}
return RET_NOT_FOUND;
}
static ret_t mledit_on_destroy(widget_t* widget) {
mledit_t* mledit = MLEDIT(widget);
return_value_if_fail(widget != NULL && mledit != NULL, RET_BAD_PARAMS);
if (mledit->timer_id != TK_INVALID_ID) {
timer_remove(mledit->timer_id);
}
wstr_reset(&(mledit->temp));
TKMEM_FREE(mledit->tips);
TKMEM_FREE(mledit->tr_tips);
TKMEM_FREE(mledit->keyboard);
wstr_reset(&(mledit->saved_text));
wstr_reset(&(mledit->last_changing_text));
wstr_reset(&(mledit->last_changed_text));
text_edit_destroy(mledit->model);
return RET_OK;
}
static ret_t mledit_on_paint_self(widget_t* widget, canvas_t* c) {
mledit_t* mledit = MLEDIT(widget);
return_value_if_fail(mledit != NULL, RET_BAD_PARAMS);
text_edit_paint(mledit->model, c);
return RET_OK;
}
static ret_t mledit_commit_str(widget_t* widget, const char* str) {
mledit_t* mledit = MLEDIT(widget);
return_value_if_fail(mledit != NULL, RET_BAD_PARAMS);
wstr_set_utf8(&(mledit->temp), str);
wstr_set(&(mledit->last_changing_text), widget->text.str);
text_edit_paste(mledit->model, mledit->temp.str, mledit->temp.size);
mledit_dispatch_event(widget, EVT_VALUE_CHANGING);
return RET_OK;
}
static ret_t mledit_request_input_method_on_window_open(void* ctx, event_t* e) {
mledit_t* mledit = MLEDIT(ctx);
return_value_if_fail(mledit != NULL, RET_BAD_PARAMS);
if (!mledit->readonly) {
input_method_request(input_method(), WIDGET(ctx));
}
return RET_REMOVE;
}
static ret_t mledit_request_input_method(widget_t* widget) {
mledit_t* mledit = MLEDIT(widget);
return_value_if_fail(mledit != NULL, RET_BAD_PARAMS);
if (mledit->readonly) {
return RET_OK;
}
if (widget_is_window_opened(widget)) {
input_method_request(input_method(), widget);
} else {
widget_t* win = widget_get_window(widget);
if (win != NULL) {
widget_on(win, EVT_WINDOW_OPEN, mledit_request_input_method_on_window_open, widget);
}
}
return RET_OK;
}
static ret_t mledit_update_caret(const timer_info_t* timer) {
mledit_t* mledit = NULL;
widget_t* widget = NULL;
return_value_if_fail(timer != NULL, RET_REMOVE);
mledit = MLEDIT(timer->ctx);
widget = WIDGET(timer->ctx);
return_value_if_fail(mledit != NULL && widget != NULL, RET_REMOVE);
if (mledit->readonly) {
mledit->timer_id = TK_INVALID_ID;
text_edit_set_caret_visible(mledit->model, FALSE);
return RET_REMOVE;
}
widget_invalidate_force(widget, NULL);
text_edit_invert_caret_visible(mledit->model);
if (widget->focused) {
return RET_REPEAT;
} else {
mledit->timer_id = TK_INVALID_ID;
text_edit_set_caret_visible(mledit->model, FALSE);
return RET_REMOVE;
}
}
static ret_t mledit_start_update_caret(mledit_t* mledit) {
#define UPDATE_CARET_TIME 600
if (mledit->readonly) {
text_edit_set_caret_visible(mledit->model, FALSE);
} else {
if (mledit->timer_id == TK_INVALID_ID) {
mledit->timer_id = timer_add(mledit_update_caret, WIDGET(mledit), UPDATE_CARET_TIME);
} else {
timer_reset(mledit->timer_id);
}
text_edit_set_caret_visible(mledit->model, TRUE);
}
return RET_OK;
}
static ret_t mledit_update_status(widget_t* widget) {
mledit_t* mledit = MLEDIT(widget);
return_value_if_fail(mledit != NULL && widget != NULL, RET_BAD_PARAMS);
if (mledit->is_activated) {
return RET_OK;
}
if (widget->text.size == 0) {
if (widget->focused) {
widget_set_state(widget, WIDGET_STATE_EMPTY_FOCUS);
} else {
widget_set_state(widget, WIDGET_STATE_EMPTY);
}
} else {
if (mledit->cancelable) {
if (!wstr_equal(&(mledit->saved_text), &(widget->text))) {
widget_set_state(widget, WIDGET_STATE_CHANGED);
return RET_OK;
}
}
if (widget->focused) {
widget_set_state(widget, WIDGET_STATE_FOCUSED);
} else {
widget_set_state(widget, WIDGET_STATE_NORMAL);
}
}
return RET_OK;
}
static ret_t mledit_pointer_up_cleanup(widget_t* widget) {
mledit_t* mledit = MLEDIT(widget);
return_value_if_fail(mledit != NULL && widget != NULL, RET_BAD_PARAMS);
widget_ungrab(widget->parent, widget);
widget_set_state(widget, WIDGET_STATE_NORMAL);
return RET_OK;
}
ret_t mledit_clear(mledit_t* mledit) {
widget_t* widget = WIDGET(mledit);
return_value_if_fail(widget != NULL && mledit != NULL, RET_BAD_PARAMS);
widget->text.size = 0;
text_edit_set_cursor(mledit->model, 0);
return widget_invalidate_force(widget, NULL);
}
ret_t mledit_set_cursor(widget_t* widget, uint32_t cursor) {
mledit_t* mledit = MLEDIT(widget);
return_value_if_fail(widget != NULL && mledit != NULL, RET_BAD_PARAMS);
return text_edit_set_cursor(mledit->model, cursor);
}
uint32_t mledit_get_cursor(widget_t* widget) {
mledit_t* mledit = MLEDIT(widget);
return_value_if_fail(widget != NULL && mledit != NULL, 0);
return text_edit_get_cursor(mledit->model);
}
ret_t mledit_set_scroll_line(widget_t* widget, uint32_t scroll_line) {
mledit_t* mledit = MLEDIT(widget);
return_value_if_fail(widget != NULL && mledit != NULL, RET_BAD_PARAMS);
mledit->scroll_line = scroll_line;
return RET_OK;
}
ret_t mledit_scroll_to_offset(widget_t* widget, uint32_t offset) {
mledit_t* mledit = MLEDIT(widget);
int32_t scroll_y = 0;
scroll_bar_t* vscroll_bar =
SCROLL_BAR(widget_lookup_by_type(widget, WIDGET_TYPE_SCROLL_BAR_DESKTOP, TRUE));
return_value_if_fail(mledit != NULL && mledit->model != NULL, RET_BAD_PARAMS);
scroll_y = text_edit_get_height(mledit->model, offset);
if (vscroll_bar != NULL) {
text_edit_state_t state = {0};
text_edit_get_state(mledit->model, &state);
scroll_y = tk_min(scroll_y, tk_max(vscroll_bar->virtual_size - vscroll_bar->widget.h, 0));
}
return text_edit_set_offset(mledit->model, 0, scroll_y);
}
static ret_t mledit_focus_request_input_method(const idle_info_t* info) {
mledit_t* mledit = MLEDIT(info->ctx);
return_value_if_fail(mledit != NULL, RET_BAD_PARAMS);
if (mledit->open_im_when_focused) {
mledit_request_input_method(WIDGET(mledit));
}
return RET_REMOVE;
}
static ret_t mledit_on_event(widget_t* widget, event_t* e) {
ret_t ret = RET_OK;
uint32_t type = e->type;
mledit_t* mledit = MLEDIT(widget);
keyboard_type_t keyboard_type = system_info()->keyboard_type;
return_value_if_fail(widget != NULL && mledit != NULL && e != NULL, RET_BAD_PARAMS);
if (!widget->visible) {
return RET_OK;
}
switch (type) {
case EVT_POINTER_LEAVE: {
mledit_update_status(widget);
break;
}
case EVT_POINTER_ENTER:
if (widget->text.size == 0) {
widget_set_state(widget, WIDGET_STATE_EMPTY_OVER);
} else {
widget_set_state(widget, WIDGET_STATE_OVER);
}
break;
case EVT_POINTER_DOWN: {
pointer_event_t evt = *(pointer_event_t*)e;
if (widget_find_target(widget, evt.x, evt.y) == NULL) {
text_edit_click(mledit->model, evt.x, evt.y);
widget_grab(widget->parent, widget);
}
if (widget->target == NULL) {
mledit_request_input_method(widget);
}
mledit_update_status(widget);
widget_invalidate(widget, NULL);
mledit_start_update_caret(mledit);
break;
}
case EVT_POINTER_DOWN_ABORT: {
mledit_pointer_up_cleanup(widget);
widget_invalidate(widget, NULL);
break;
}
case EVT_POINTER_MOVE: {
pointer_event_t evt = *(pointer_event_t*)e;
if (widget->parent && widget->parent->grab_widget == widget) {
if (widget->target == NULL) {
text_edit_set_lock_scrollbar_value(mledit->model, FALSE);
text_edit_drag(mledit->model, evt.x, evt.y);
text_edit_set_lock_scrollbar_value(mledit->model, mledit->lock_scrollbar_value);
ret = RET_STOP;
}
}
widget_invalidate(widget, NULL);
break;
}
case EVT_POINTER_UP: {
widget_ungrab(widget->parent, widget);
widget_invalidate(widget, NULL);
break;
}
case EVT_DOUBLE_CLICK: {
uint32_t len = 0;
int32_t left = 0;
int32_t right = 0;
uint32_t cursor = 0;
wchar_t* text = NULL;
pointer_event_t evt = *(pointer_event_t*)e;
if (widget_find_target(widget, evt.x, evt.y) == NULL) {
cursor = mledit_get_cursor(widget);
len = mledit->model->widget->text.size;
text = mledit->model->widget->text.str;
if (tk_wstr_select_word(text, len, cursor, &left, &right) == RET_OK) {
mledit_set_select(widget, left, right);
}
}
break;
}
case EVT_KEY_DOWN: {
key_event_t* evt = (key_event_t*)e;
int32_t key = evt->key;
#ifdef MACOS
bool_t is_control = evt->cmd;
#else
bool_t is_control = evt->ctrl;
#endif
if ((!mledit->is_activated || key == TK_KEY_RETURN) &&
(keyboard_type == KEYBOARD_3KEYS || keyboard_type == KEYBOARD_5KEYS)) {
break;
}
if (key == TK_KEY_ESCAPE || (key >= TK_KEY_F1 && key <= TK_KEY_F12)) {
break;
}
if (mledit->readonly) {
if (is_control && (key == TK_KEY_C || key == TK_KEY_c || key == TK_KEY_A || key == TK_KEY_a)) {
log_debug("copy\n");
} else {
break;
}
}
if ((key < 128 && tk_isprint(key)) || key == TK_KEY_BACKSPACE || key == TK_KEY_DELETE ||
key == TK_KEY_TAB || key_code_is_enter(key)) {
wstr_set(&(mledit->last_changing_text), widget->text.str);
text_edit_key_down(mledit->model, (key_event_t*)e);
mledit_dispatch_event(widget, EVT_VALUE_CHANGING);
} else {
text_edit_key_down(mledit->model, (key_event_t*)e);
}
mledit_update_status(widget);
ret = RET_STOP;
mledit->is_key_inputing = TRUE;
widget_invalidate(widget, NULL);
mledit_start_update_caret(mledit);
break;
}
case EVT_IM_COMMIT: {
text_edit_state_t state;
text_edit_get_state(mledit->model, &state);
im_commit_event_t* evt = (im_commit_event_t*)e;
if (mledit->readonly || !widget->focused) {
break;
}
if (state.preedit) {
text_edit_preedit_clear(mledit->model);
}
if (evt->replace) {
mledit_clear(mledit);
}
mledit_commit_str(widget, evt->text);
mledit_update_status(widget);
widget_invalidate(widget, NULL);
break;
}
case EVT_IM_PREEDIT: {
text_edit_preedit(mledit->model);
break;
}
case EVT_IM_PREEDIT_CONFIRM: {
text_edit_preedit_confirm(mledit->model);
break;
}
case EVT_IM_PREEDIT_ABORT: {
wstr_set(&(mledit->last_changing_text), widget->text.str);
text_edit_preedit_abort(mledit->model);
mledit_dispatch_event(widget, EVT_VALUE_CHANGING);
break;
}
case EVT_IM_ACTION: {
mledit_commit_str(widget, "\n");
widget_invalidate(widget, NULL);
break;
}
case EVT_KEY_UP: {
key_event_t* evt = key_event_cast(e);
ENSURE(evt);
int32_t key = evt->key;
if (!mledit->is_activated &&
(keyboard_type == KEYBOARD_3KEYS || keyboard_type == KEYBOARD_5KEYS)) {
break;
}
if (key == TK_KEY_ESCAPE || (key >= TK_KEY_F1 && key <= TK_KEY_F12)) {
break;
}
if (key_code_is_enter(key)) {
ret = RET_STOP;
} else {
ret = text_edit_key_up(mledit->model, evt);
}
mledit->is_key_inputing = TRUE;
widget_invalidate(widget, NULL);
break;
}
case EVT_IM_CANCEL: {
mledit_rollback_text(widget);
break;
}
case EVT_UNACTIVATED: {
mledit->is_activated = FALSE;
input_method_request(input_method(), NULL);
if (mledit->timer_id != TK_INVALID_ID) {
timer_remove(mledit->timer_id);
mledit->timer_id = TK_INVALID_ID;
text_edit_set_caret_visible(mledit->model, FALSE);
}
break;
}
case EVT_ACTIVATED: {
mledit->is_activated = TRUE;
mledit_start_update_caret(mledit);
if (widget->target == NULL) {
widget_add_idle(widget, mledit_focus_request_input_method);
}
mledit_update_status(widget);
widget_invalidate(widget, NULL);
mledit_start_update_caret(mledit);
break;
}
case EVT_BLUR: {
if (mledit->close_im_when_blured) {
mledit->is_key_inputing = FALSE;
input_method_request(input_method(), NULL);
}
mledit_update_status(widget);
text_edit_set_lock_scrollbar_value(mledit->model, TRUE);
text_edit_preedit_confirm(mledit->model);
text_edit_unselect(mledit->model);
text_edit_set_lock_scrollbar_value(mledit->model, mledit->lock_scrollbar_value);
mledit_dispatch_event(widget, EVT_VALUE_CHANGED);
mledit_commit_text(widget);
break;
}
case EVT_FOCUS: {
keyboard_type_t keyboard_type = system_info()->keyboard_type;
if (keyboard_type != KEYBOARD_3KEYS && keyboard_type != KEYBOARD_5KEYS) {
mledit_start_update_caret(mledit);
if (widget->target == NULL) {
widget_add_idle(widget, mledit_focus_request_input_method);
}
}
mledit_save_text(widget);
break;
}
case EVT_WHEEL: {
key_event_t kevt;
wheel_event_t* evt = (wheel_event_t*)e;
int32_t delta = evt->dy;
if (delta > 0) {
key_event_init(&kevt, EVT_KEY_DOWN, widget, TK_KEY_UP);
text_edit_key_down(mledit->model, (key_event_t*)&kevt);
} else if (delta < 0) {
key_event_init(&kevt, EVT_KEY_DOWN, widget, TK_KEY_DOWN);
text_edit_key_down(mledit->model, (key_event_t*)&kevt);
}
ret = RET_STOP;
widget_invalidate(widget, NULL);
break;
}
case EVT_RESIZE:
case EVT_MOVE_RESIZE: {
mledit_reset_text_edit_layout(mledit->model);
widget_invalidate(widget, NULL);
break;
}
case EVT_VALUE_CHANGING: {
mledit_update_status(widget);
widget_invalidate(widget, NULL);
break;
}
case EVT_WIDGET_LOAD: {
uint32_t max_size = widget->text.size;
uint32_t line_break_num = mledit->max_lines;
uint32_t i = 0;
for (i = 0; i < max_size; i++) {
if (i + 1 < max_size &&
TWINS_WCHAR_IS_LINE_BREAK(widget->text.str[i], widget->text.str[i + 1])) {
line_break_num--;
i++;
} else if (WCHAR_IS_LINE_BREAK(widget->text.str[i])) {
line_break_num--;
}
if (line_break_num == 0) {
max_size = i;
break;
}
}
if (mledit->max_chars != 0) {
max_size = tk_min(max_size, mledit->max_chars);
}
wstr_shrink(&(widget->text), max_size);
break;
}
case EVT_CONTEXT_MENU: {
pointer_event_t* evt = (pointer_event_t*)e;
point_t p = {evt->x, evt->y};
widget_to_local(widget, &p);
widget_to_screen(widget, &p);
text_edit_show_context_menu(mledit->model, p.x, p.y);
break;
}
default:
break;
}
return ret;
}
static ret_t mledit_on_re_translate(widget_t* widget) {
mledit_t* mledit = MLEDIT(widget);
return_value_if_fail(mledit != NULL, RET_BAD_PARAMS);
if (mledit->tr_tips != NULL) {
const char* tr_tips = locale_info_tr(widget_get_locale_info(widget), mledit->tr_tips);
mledit_set_tips(widget, tr_tips);
}
return RET_OK;
}
static ret_t mledit_sync_line_number(widget_t* widget, text_edit_state_t* state) {
mledit_t* mledit = MLEDIT(widget);
widget_t* line_number = widget_lookup_by_type(widget, WIDGET_TYPE_LINE_NUMBER, TRUE);
return_value_if_fail(mledit != NULL, RET_BAD_PARAMS);
if (line_number != NULL) {
const uint32_t* lines_of_each_row = text_edit_get_lines_of_each_row(mledit->model);
if (lines_of_each_row != NULL) {
line_number_set_lines_of_each_row(line_number, lines_of_each_row, state->max_rows);
}
line_number_set_yoffset(line_number, state->oy);
line_number_set_line_height(line_number, state->line_height);
line_number_set_top_margin(line_number, mledit->top_margin);
line_number_set_bottom_margin(line_number, mledit->bottom_margin);
widget_invalidate_force(line_number, NULL);
}
return RET_BAD_PARAMS;
}
static ret_t mledit_sync_scrollbar(widget_t* widget, text_edit_state_t* state) {
xy_t y = 0;
wh_t virtual_h = 0;
int32_t margin = 0;
int32_t margin_top = 0;
int32_t margin_bottom = 0;
widget_t* vscroll_bar = NULL;
mledit_t* mledit = MLEDIT(widget);
return_value_if_fail(mledit != NULL, RET_BAD_PARAMS);
margin = style_get_int(widget->astyle, STYLE_ID_MARGIN, 0);
margin_top = style_get_int(widget->astyle, STYLE_ID_MARGIN_TOP, margin);
margin_bottom = style_get_int(widget->astyle, STYLE_ID_MARGIN_BOTTOM, margin);
virtual_h = (state->last_line_number + 1) * state->line_height + margin_top + margin_bottom;
vscroll_bar = widget_lookup_by_type(widget, WIDGET_TYPE_SCROLL_BAR_DESKTOP, TRUE);
if (vscroll_bar != NULL) {
virtual_h = virtual_h >= vscroll_bar->h ? virtual_h : vscroll_bar->h;
if (virtual_h > vscroll_bar->h) {
y = (int64_t)state->oy * (int64_t)virtual_h / (virtual_h - vscroll_bar->h);
} else {
y = 0;
}
scroll_bar_set_params(vscroll_bar, virtual_h, state->line_height);
scroll_bar_set_value_only(vscroll_bar, y);
widget_invalidate_force(vscroll_bar, NULL);
}
return RET_OK;
}
static ret_t mledit_on_text_edit_state_changed(void* ctx, text_edit_state_t* state) {
widget_t* widget = WIDGET(ctx);
mledit_sync_line_number(widget, state);
mledit_sync_scrollbar(widget, state);
widget_invalidate_force(widget, NULL);
return RET_OK;
}
static ret_t mledit_on_scroll_bar_value_changed(void* ctx, event_t* e) {
int32_t value = 0;
mledit_t* mledit = MLEDIT(ctx);
ENSURE(mledit);
widget_t* vscroll_bar = e != NULL ? WIDGET(e->target) : NULL;
scroll_bar_t* scroll_bar = SCROLL_BAR(vscroll_bar);
return_value_if_fail(vscroll_bar != NULL && scroll_bar != NULL, RET_BAD_PARAMS);
value = widget_get_value(vscroll_bar);
value = (int64_t)(scroll_bar->virtual_size - vscroll_bar->h) * (int64_t)value /
scroll_bar->virtual_size;
if (mledit->overwrite && mledit->max_chars == 0 && mledit->max_lines != 0) {
if (value == scroll_bar->virtual_size - vscroll_bar->h) {
mledit->lock_scrollbar_value = FALSE;
} else {
mledit->lock_scrollbar_value = TRUE;
}
text_edit_set_lock_scrollbar_value(mledit->model, mledit->lock_scrollbar_value);
}
text_edit_set_offset(mledit->model, 0, value);
return RET_OK;
}
static ret_t mledit_on_scroll_bar_move_resize(void* ctx, event_t* e) {
mledit_t* mledit = MLEDIT(ctx);
text_edit_state_t state;
return_value_if_fail(mledit != NULL, RET_BAD_PARAMS);
text_edit_get_state(mledit->model, &state);
mledit_sync_scrollbar(&mledit->widget, &state);
return RET_OK;
}
ret_t mledit_set_open_im_when_focused(widget_t* widget, bool_t open_im_when_focused) {
mledit_t* mledit = MLEDIT(widget);
return_value_if_fail(mledit != NULL, RET_BAD_PARAMS);
mledit->open_im_when_focused = open_im_when_focused;
return RET_OK;
}
ret_t mledit_set_close_im_when_blured(widget_t* widget, bool_t close_im_when_blured) {
mledit_t* mledit = MLEDIT(widget);
return_value_if_fail(mledit != NULL, RET_BAD_PARAMS);
mledit->close_im_when_blured = close_im_when_blured;
return RET_OK;
}
ret_t mledit_set_select(widget_t* widget, uint32_t start, uint32_t end) {
mledit_t* mledit = MLEDIT(widget);
return_value_if_fail(mledit != NULL && mledit->model != NULL, RET_BAD_PARAMS);
return text_edit_set_select(mledit->model, start, end);
}
char* mledit_get_selected_text(widget_t* widget) {
mledit_t* mledit = MLEDIT(widget);
return_value_if_fail(mledit != NULL && mledit->model != NULL, NULL);
return text_edit_get_selected_text(mledit->model);
}
static void mledit_fix_state(mledit_t* mledit, uint32_t offset, uint32_t rm_num, uint32_t cursor) {
text_edit_state_t state = {0};
text_edit_get_state(mledit->model, &state);
if (state.select_start <= offset && state.select_end >= offset) {
state.select_start = state.select_end = 0;
} else {
if (state.select_start >= rm_num && state.select_end >= rm_num) {
state.select_start -= rm_num;
state.select_end -= rm_num;
} else {
state.select_start = state.select_end = 0;
}
}
mledit->model->ignore_layout = TRUE;
text_edit_set_select(mledit->model, state.select_start, state.select_end);
mledit->model->ignore_layout = FALSE;
text_edit_set_cursor(mledit->model, cursor);
}
static ret_t mledit_insert_text_overwrite(widget_t* widget, uint32_t offset, const char* newtext) {
mledit_t* mledit = MLEDIT(widget);
wstr_t s = {0};
wstr_t* text = NULL;
uint32_t line_num = 1;
int32_t i = 0;
uint32_t rm_cnt = 0;
uint32_t newtext_len = 0;
return_value_if_fail(mledit != NULL && mledit->model != NULL, RET_BAD_PARAMS);
/* generate new text */
wstr_init(&s, 0);
wstr_set_utf8(&s, newtext);
text = &(mledit->model->widget->text);
offset = tk_min(offset, text->size);
wstr_insert(text, offset, s.str, s.size);
newtext_len = s.size;
wstr_reset(&s);
/* handle max_chars */
if (mledit->max_chars != 0 && mledit->max_chars < text->size) {
rm_cnt = text->size - mledit->max_chars;
wstr_remove(text, 0, rm_cnt);
}
/* handle max_lines */
for (i = (int32_t)(text->size) - 1; i >= 0; --i) {
if (i > 0 && TWINS_WCHAR_IS_LINE_BREAK(text->str[i - 1], text->str[i])) {
++line_num;
if (line_num > mledit->max_lines) {
break;
}
--i;
} else if (WCHAR_IS_LINE_BREAK(text->str[i])) {
++line_num;
if (line_num > mledit->max_lines) {
break;
}
}
}
if (i >= 0) {
rm_cnt += i + 1;
wstr_remove(text, 0, i + 1);
}
/* fix select & cursor */
mledit_fix_state(mledit, offset, rm_cnt, text->size);
/* 新加入的文本 由于 max_chars 或 max_lines的限制， 实际上完全没加到文本中 */
if (offset + newtext_len <= rm_cnt) {
return RET_SKIP;
}
return RET_OK;
}
ret_t mledit_insert_text(widget_t* widget, uint32_t offset, const char* text) {
ret_t ret = RET_OK;
mledit_t* mledit = MLEDIT(widget);
return_value_if_fail(mledit != NULL && mledit->model != NULL, RET_BAD_PARAMS);
if (!mledit->overwrite || mledit->max_chars > 0 || mledit->max_lines == 0) {
ret = text_edit_insert_text(mledit->model, offset, text);
} else {
ret = mledit_insert_text_overwrite(widget, offset, text);
}
if (ret == RET_OK) {
mledit_dispatch_event(widget, EVT_VALUE_CHANGED);
mledit_update_status(widget);
}
return ret;
}
static ret_t mledit_on_add_child(widget_t* widget, widget_t* child) {
mledit_t* mledit = MLEDIT(widget);
const char* type = widget_get_type(child);
return_value_if_fail(mledit != NULL && widget != NULL && child != NULL, RET_BAD_PARAMS);
if (tk_str_eq(type, WIDGET_TYPE_SCROLL_BAR_DESKTOP)) {
widget_on(child, EVT_VALUE_CHANGED, mledit_on_scroll_bar_value_changed, widget);
widget_on(child, EVT_MOVE_RESIZE, mledit_on_scroll_bar_move_resize, widget);
}
text_edit_set_on_state_changed(mledit->model, mledit_on_text_edit_state_changed, widget);
return RET_CONTINUE;
}
static ret_t mledit_init_idle_func(const idle_info_t* info) {
text_edit_state_t state = {0};
mledit_t* mledit = MLEDIT(info->ctx);
return_value_if_fail(mledit != NULL, RET_BAD_PARAMS);
mledit_set_cursor(WIDGET(mledit), 0);
text_edit_get_state(mledit->model, &state);
mledit_on_text_edit_state_changed(mledit, &state);
return RET_REMOVE;
}
const char* s_mledit_properties[] = {WIDGET_PROP_READONLY,
WIDGET_PROP_CANCELABLE,
WIDGET_PROP_MARGIN,
WIDGET_PROP_LEFT_MARGIN,
WIDGET_PROP_RIGHT_MARGIN,
WIDGET_PROP_TOP_MARGIN,
WIDGET_PROP_BOTTOM_MARGIN,
WIDGET_PROP_TIPS,
WIDGET_PROP_TR_TIPS,
WIDGET_PROP_KEYBOARD,
WIDGET_PROP_OPEN_IM_WHEN_FOCUSED,
WIDGET_PROP_CLOSE_IM_WHEN_BLURED,
MLEDIT_PROP_MAX_LINES,
MLEDIT_PROP_MAX_CHARS,
MLEDIT_PROP_WRAP_WORD,
MLEDIT_PROP_SCROLL_LINE,
MLEDIT_PROP_OVERWRITE,
NULL};
TK_DECL_VTABLE(mledit) = {.size = sizeof(mledit_t),
.type = WIDGET_TYPE_MLEDIT,
.focusable = TRUE,
.inputable = TRUE,
.pointer_cursor = WIDGET_CURSOR_EDIT,
.clone_properties = s_mledit_properties,
.persistent_properties = s_mledit_properties,
.get_parent_vt = TK_GET_PARENT_VTABLE(widget),
.create = mledit_create,
.init = mledit_init,
.on_paint_self = mledit_on_paint_self,
.on_re_translate = mledit_on_re_translate,
.set_prop = mledit_set_prop,
.get_prop = mledit_get_prop,
.on_event = mledit_on_event,
.on_add_child = mledit_on_add_child,
.on_destroy = mledit_on_destroy};
static ret_t mledit_init(widget_t* widget) {
mledit_t* mledit = MLEDIT(widget);
return_value_if_fail(mledit != NULL, RET_BAD_PARAMS);
mledit->model = text_edit_create(widget, FALSE);
ENSURE(mledit->model != NULL);
mledit->wrap_word = TRUE;
mledit->margin = 1;
mledit->top_margin = 0;
mledit->left_margin = 0;
mledit->right_margin = 0;
mledit->bottom_margin = 0;
mledit->scroll_line = 1.0f;
wstr_init(&(mledit->temp), 0);
wstr_init(&(mledit->last_changing_text), 0);
wstr_init(&(mledit->last_changed_text), 0);
widget_set_text(widget, L"");
mledit->close_im_when_blured = TRUE;
mledit->open_im_when_focused = TRUE;
wstr_init(&(mledit->saved_text), 0);
mledit_update_status(widget);
widget_add_idle(widget, mledit_init_idle_func);
return RET_OK;
}
widget_t* mledit_create(widget_t* parent, xy_t x, xy_t y, wh_t w, wh_t h) {
widget_t* widget = widget_create(parent, TK_REF_VTABLE(mledit), x, y, w, h);
return_value_if_fail(mledit_init(widget) == RET_OK, NULL);
return widget;
}
widget_t* mledit_cast(widget_t* widget) {
return_value_if_fail(WIDGET_IS_INSTANCE_OF(widget, mledit), NULL);
return widget;
}
uint32_t mledit_get_current_line_index(widget_t* widget) {
text_edit_state_t state;
mledit_t* mledit = MLEDIT(widget);
return_value_if_fail(mledit != NULL && mledit->model != NULL, 0);
return_value_if_fail(text_edit_get_state(mledit->model, &state) == RET_OK, 0);
return state.current_line_index;
}
uint32_t mledit_get_current_row_index(widget_t* widget) {
text_edit_state_t state;
mledit_t* mledit = MLEDIT(widget);
return_value_if_fail(mledit != NULL && mledit->model != NULL, 0);
return_value_if_fail(text_edit_get_state(mledit->model, &state) == RET_OK, 0);
return state.current_row_index;
}
|
0 |
repos/awtk/src/ext_widgets
|
repos/awtk/src/ext_widgets/scroll_view/list_view.c
|
/**
* File: list_view.h
* Author: AWTK Develop Team
* Brief: list_view
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-07-04 Li XianJing <[email protected]> created
*
*/
#include "tkc/mem.h"
#include "tkc/utils.h"
#include "tkc/time_now.h"
#include "base/layout.h"
#include "scroll_view/list_view.h"
#include "scroll_view/scroll_bar.h"
#include "scroll_view/scroll_view.h"
#define LIST_VIEW_FLOATING_SCROLL_BAR_HIDE_TIME 500
#define LIST_VIEW_FLOATING_SCROLL_BAR_SHOW_TIME 300
static ret_t list_view_on_add_child(widget_t* widget, widget_t* child);
static ret_t list_view_on_remove_child(widget_t* widget, widget_t* child);
static ret_t list_view_on_paint_self(widget_t* widget, canvas_t* c) {
return widget_paint_helper(widget, c, NULL, NULL);
}
static ret_t list_view_get_prop(widget_t* widget, const char* name, value_t* v) {
list_view_t* list_view = LIST_VIEW(widget);
return_value_if_fail(list_view != NULL && name != NULL && v != NULL, RET_BAD_PARAMS);
if (tk_str_eq(name, WIDGET_PROP_ITEM_HEIGHT)) {
value_set_int(v, list_view->item_height);
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_DEFAULT_ITEM_HEIGHT)) {
value_set_int(v, list_view->default_item_height);
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_AUTO_HIDE_SCROLL_BAR)) {
value_set_bool(v, list_view->auto_hide_scroll_bar);
return RET_OK;
} else if (tk_str_eq(name, LIST_VIEW_PROP_FLOATING_SCROLL_BAR)) {
value_set_bool(v, list_view->floating_scroll_bar);
return RET_OK;
}
return RET_NOT_FOUND;
}
static ret_t list_view_on_pointer_up(list_view_t* list_view, pointer_event_t* e) {
scroll_bar_t* scroll_bar = (scroll_bar_t*)list_view->scroll_bar;
if (scroll_bar != NULL && scroll_bar->wa_opactiy == NULL && list_view->scroll_bar->visible &&
scroll_bar_is_mobile(list_view->scroll_bar)) {
scroll_bar_hide_by_opacity_animation(list_view->scroll_bar,
LIST_VIEW_FLOATING_SCROLL_BAR_HIDE_TIME,
LIST_VIEW_FLOATING_SCROLL_BAR_HIDE_TIME);
}
return RET_OK;
}
static ret_t list_view_set_prop(widget_t* widget, const char* name, const value_t* v) {
list_view_t* list_view = LIST_VIEW(widget);
return_value_if_fail(list_view != NULL && name != NULL && v != NULL, RET_BAD_PARAMS);
if (tk_str_eq(name, WIDGET_PROP_ITEM_HEIGHT)) {
list_view->item_height = value_int(v);
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_DEFAULT_ITEM_HEIGHT)) {
list_view->default_item_height = value_int(v);
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_AUTO_HIDE_SCROLL_BAR)) {
list_view->auto_hide_scroll_bar = value_bool(v);
return RET_OK;
} else if (tk_str_eq(name, LIST_VIEW_PROP_FLOATING_SCROLL_BAR)) {
return list_view_set_floating_scroll_bar(widget, value_bool(v));
}
return RET_NOT_FOUND;
}
static ret_t list_view_handle_wheel_event(list_view_t* list_view, event_t* e) {
wheel_event_t* evt = (wheel_event_t*)e;
int32_t delta = -evt->dy;
if (list_view->scroll_bar != NULL) {
scroll_bar_add_delta(list_view->scroll_bar, delta);
log_debug("wheel: %d\n", delta);
}
return RET_STOP;
}
static ret_t list_view_on_wheel_before(void* ctx, event_t* e) {
return list_view_handle_wheel_event(LIST_VIEW(ctx), e);
}
static bool_t list_view_is_play_auto_hide_scroll_bar_animtion(list_view_t* list_view) {
scroll_view_t* scroll_view = NULL;
return_value_if_fail(list_view != NULL && list_view->scroll_view != NULL, FALSE);
if (list_view->scroll_bar != NULL) {
scroll_view = SCROLL_VIEW(list_view->scroll_view);
return_value_if_fail(scroll_view != NULL, FALSE);
if (list_view->auto_hide_scroll_bar && scroll_view->virtual_h > list_view->widget.h) {
return TRUE;
}
}
return FALSE;
}
static ret_t list_view_on_pointer_leave(list_view_t* list_view) {
return_value_if_fail(list_view != NULL, RET_BAD_PARAMS);
list_view->is_over = FALSE;
if (list_view_is_play_auto_hide_scroll_bar_animtion(list_view)) {
scroll_bar_hide_by_opacity_animation(list_view->scroll_bar,
LIST_VIEW_FLOATING_SCROLL_BAR_HIDE_TIME, 0);
}
return RET_OK;
}
static ret_t list_view_on_pointer_enter(list_view_t* list_view) {
return_value_if_fail(list_view != NULL, RET_BAD_PARAMS);
list_view->is_over = TRUE;
if (list_view_is_play_auto_hide_scroll_bar_animtion(list_view)) {
scroll_bar_show_by_opacity_animation(list_view->scroll_bar,
LIST_VIEW_FLOATING_SCROLL_BAR_SHOW_TIME, 0);
}
return RET_OK;
}
static ret_t list_view_on_event(widget_t* widget, event_t* e) {
ret_t ret = RET_OK;
list_view_t* list_view = LIST_VIEW(widget);
keyboard_type_t keyboard_type = system_info()->keyboard_type;
return_value_if_fail(list_view != NULL, RET_BAD_PARAMS);
switch (e->type) {
case EVT_WHEEL: {
if (list_view->is_over) {
ret = list_view_handle_wheel_event(list_view, e);
}
break;
}
case EVT_KEY_DOWN: {
key_event_t* evt = (key_event_t*)e;
if (!evt->alt && !evt->ctrl && !evt->shift && !evt->cmd && !evt->menu) {
if (evt->key == TK_KEY_PAGEDOWN) {
scroll_view_scroll_delta_to(list_view->scroll_view, 0, widget->h, TK_ANIMATING_TIME);
ret = RET_STOP;
} else if (evt->key == TK_KEY_PAGEUP) {
scroll_view_scroll_delta_to(list_view->scroll_view, 0, -widget->h, TK_ANIMATING_TIME);
ret = RET_STOP;
} else if (keyboard_type == KEYBOARD_NORMAL) {
if (evt->key == TK_KEY_UP) {
uint32_t item_height = tk_max(list_view->item_height, list_view->default_item_height);
scroll_view_scroll_delta_to(list_view->scroll_view, 0, -item_height, TK_ANIMATING_TIME);
ret = RET_STOP;
} else if (evt->key == TK_KEY_DOWN) {
uint32_t item_height = tk_max(list_view->item_height, list_view->default_item_height);
scroll_view_scroll_delta_to(list_view->scroll_view, 0, item_height, TK_ANIMATING_TIME);
ret = RET_STOP;
}
}
}
break;
}
case EVT_KEY_UP:
case EVT_POINTER_UP: {
pointer_event_t* evt = (pointer_event_t*)e;
list_view_on_pointer_up(list_view, evt);
break;
}
case EVT_POINTER_LEAVE: {
list_view_on_pointer_leave(list_view);
break;
}
case EVT_POINTER_ENTER: {
list_view_on_pointer_enter(list_view);
break;
}
default:
break;
}
return ret;
}
TK_DECL_VTABLE(list_view) = {.type = WIDGET_TYPE_LIST_VIEW,
.size = sizeof(list_view_t),
.get_parent_vt = TK_GET_PARENT_VTABLE(widget),
.create = list_view_create,
.set_prop = list_view_set_prop,
.get_prop = list_view_get_prop,
.on_event = list_view_on_event,
.on_add_child = list_view_on_add_child,
.on_remove_child = list_view_on_remove_child,
.on_paint_self = list_view_on_paint_self};
static int32_t scroll_bar_to_scroll_view(list_view_t* list_view, int32_t v) {
int32_t range = 0;
float_t percent = 0;
scroll_view_t* scroll_view = NULL;
scroll_bar_t* scroll_bar = NULL;
return_value_if_fail(list_view != NULL, 0);
scroll_view = SCROLL_VIEW(list_view->scroll_view);
scroll_bar = SCROLL_BAR(list_view->scroll_bar);
return_value_if_fail(scroll_bar != NULL && scroll_view != NULL, 0);
range = scroll_bar->virtual_size;
percent = range > 0 ? (float_t)v / (float_t)(range) : 0;
return percent * (scroll_view->virtual_h - list_view->scroll_view->h);
}
static ret_t list_view_on_scroll_bar_value_changed(void* ctx, event_t* e) {
int32_t offset = 0;
scroll_bar_t* scroll_bar = NULL;
list_view_t* list_view = LIST_VIEW(ctx);
return_value_if_fail(list_view != NULL, RET_REMOVE);
scroll_bar = SCROLL_BAR(list_view->scroll_bar);
return_value_if_fail(scroll_bar != NULL, RET_REMOVE);
offset = scroll_bar_to_scroll_view(list_view, scroll_bar->value);
scroll_view_set_offset(list_view->scroll_view, 0, offset);
return RET_OK;
}
static int32_t scroll_view_to_scroll_bar(list_view_t* list_view, int32_t v) {
int32_t range = 0;
float_t percent = 0;
scroll_view_t* scroll_view = NULL;
scroll_bar_t* scroll_bar = NULL;
return_value_if_fail(list_view != NULL, 0);
scroll_view = SCROLL_VIEW(list_view->scroll_view);
scroll_bar = SCROLL_BAR(list_view->scroll_bar);
return_value_if_fail(scroll_bar != NULL && scroll_view != NULL, 0);
range = scroll_view->virtual_h - list_view->scroll_view->h;
percent = range > 0 ? (float_t)v / (float_t)range : 0;
return percent * scroll_bar->virtual_size;
}
static ret_t list_view_on_scroll_view_scroll(widget_t* widget, int32_t xoffset, int32_t yoffset) {
list_view_t* list_view = LIST_VIEW(widget->parent);
return_value_if_fail(list_view != NULL, RET_BAD_PARAMS);
if (list_view->scroll_bar != NULL) {
int32_t value = scroll_view_to_scroll_bar(list_view, yoffset);
scroll_bar_set_value_only(list_view->scroll_bar, value);
if (scroll_bar_is_mobile(list_view->scroll_bar)) {
widget_set_opacity(list_view->scroll_bar, 0xff);
widget_set_visible_only(list_view->scroll_bar, TRUE);
}
}
return RET_OK;
}
static ret_t list_view_on_scroll_view_scroll_to(widget_t* widget, int32_t xoffset_end,
int32_t yoffset_end, int32_t duration) {
int32_t value = 0;
list_view_t* list_view = LIST_VIEW(widget->parent);
return_value_if_fail(widget != NULL && list_view != NULL, RET_BAD_PARAMS);
(void)xoffset_end;
value = scroll_view_to_scroll_bar(list_view, yoffset_end);
return_value_if_fail(list_view->scroll_bar != NULL, RET_BAD_PARAMS);
emitter_disable(list_view->scroll_bar->emitter);
scroll_bar_scroll_to(list_view->scroll_bar, value, duration);
emitter_enable(list_view->scroll_bar->emitter);
return RET_OK;
}
static ret_t list_view_on_scroll_view_layout_children(widget_t* widget) {
if (widget->children_layout == NULL) {
widget_set_children_layout(widget, "list_view(m=0,s=0)");
}
return_value_if_fail(widget->children_layout != NULL, RET_BAD_PARAMS);
children_layouter_layout(widget->children_layout, widget);
return RET_OK;
}
static ret_t list_view_on_scroll_view_paint_children(widget_t* widget, canvas_t* c) {
int32_t left = 0;
int32_t top = 0;
int32_t bottom = 0;
int32_t right = 0;
int32_t max_w = canvas_get_width(c);
int32_t max_h = canvas_get_height(c);
WIDGET_FOR_EACH_CHILD_BEGIN(widget, iter, i)
if (!iter->visible) {
iter->dirty = FALSE;
continue;
}
left = c->ox + iter->x;
top = c->oy + iter->y;
bottom = top + iter->h;
right = left + iter->w;
if (top > max_h || left > max_w) {
break;
}
if (bottom < 0 || right < 0) {
iter->dirty = FALSE;
continue;
}
if (!canvas_is_rect_in_clip_rect(c, left, top, right, bottom)) {
iter->dirty = FALSE;
continue;
}
widget_paint(iter, c);
WIDGET_FOR_EACH_CHILD_END();
return RET_OK;
}
static ret_t list_view_on_add_child(widget_t* widget, widget_t* child) {
list_view_t* list_view = LIST_VIEW(widget);
const char* type = widget_get_type(child);
return_value_if_fail(list_view != NULL && widget != NULL && child != NULL, RET_BAD_PARAMS);
if (tk_str_eq(type, WIDGET_TYPE_SCROLL_VIEW)) {
scroll_view_t* scroll_view = (scroll_view_t*)list_view->scroll_view;
if (scroll_view != NULL) {
scroll_view->on_scroll = NULL;
scroll_view->on_scroll_to = NULL;
scroll_view->on_layout_children = NULL;
}
list_view->scroll_view = child;
scroll_view = SCROLL_VIEW(child);
scroll_view->on_scroll = list_view_on_scroll_view_scroll;
scroll_view->on_scroll_to = list_view_on_scroll_view_scroll_to;
scroll_view->on_layout_children = list_view_on_scroll_view_layout_children;
scroll_view->on_paint_children = list_view_on_scroll_view_paint_children;
scroll_view_set_recursive_only(child, FALSE);
} else if (tk_str_eq(type, WIDGET_TYPE_SCROLL_BAR) ||
tk_str_eq(type, WIDGET_TYPE_SCROLL_BAR_DESKTOP) ||
tk_str_eq(type, WIDGET_TYPE_SCROLL_BAR_MOBILE)) {
if (list_view->scroll_bar != NULL) {
widget_off_by_func(list_view->scroll_bar, EVT_VALUE_CHANGED,
list_view_on_scroll_bar_value_changed, widget);
}
list_view->scroll_bar = child;
widget_on(child, EVT_VALUE_CHANGED, list_view_on_scroll_bar_value_changed, widget);
}
return RET_CONTINUE;
}
static ret_t list_view_on_remove_child(widget_t* widget, widget_t* child) {
list_view_t* list_view = LIST_VIEW(widget);
return_value_if_fail(list_view != NULL && widget != NULL && child != NULL, RET_BAD_PARAMS);
if (list_view->scroll_view == child) {
scroll_view_t* scroll_view = SCROLL_VIEW(child);
scroll_view->on_scroll = NULL;
scroll_view->on_scroll_to = NULL;
scroll_view->on_layout_children = NULL;
list_view->scroll_view = NULL;
WIDGET_FOR_EACH_CHILD_BEGIN_R(widget, iter, i)
if (iter && iter != child && tk_str_eq(iter->vt->type, WIDGET_TYPE_SCROLL_VIEW)) {
list_view->scroll_view = iter;
scroll_view->on_scroll = list_view_on_scroll_view_scroll;
scroll_view->on_scroll_to = list_view_on_scroll_view_scroll_to;
scroll_view->on_layout_children = list_view_on_scroll_view_layout_children;
break;
}
WIDGET_FOR_EACH_CHILD_END();
} else if (list_view->scroll_bar == child) {
widget_off_by_func(child, EVT_VALUE_CHANGED, list_view_on_scroll_bar_value_changed, widget);
list_view->scroll_bar = NULL;
WIDGET_FOR_EACH_CHILD_BEGIN_R(widget, iter, i)
if (iter && iter != child &&
(tk_str_eq(iter->vt->type, WIDGET_TYPE_SCROLL_BAR) ||
tk_str_eq(iter->vt->type, WIDGET_TYPE_SCROLL_BAR_DESKTOP) ||
tk_str_eq(iter->vt->type, WIDGET_TYPE_SCROLL_BAR_MOBILE))) {
list_view->scroll_bar = iter;
widget_on(iter, EVT_VALUE_CHANGED, list_view_on_scroll_bar_value_changed, widget);
break;
}
WIDGET_FOR_EACH_CHILD_END();
}
return RET_FAIL;
}
ret_t list_view_reinit(widget_t* widget) {
list_view_t* list_view = LIST_VIEW(widget);
return_value_if_fail(list_view != NULL && widget != NULL, RET_BAD_PARAMS);
WIDGET_FOR_EACH_CHILD_BEGIN_R(widget, iter, i)
if (iter && tk_str_eq(iter->vt->type, WIDGET_TYPE_SCROLL_VIEW)) {
if (iter == list_view->scroll_view) break;
scroll_view_t* scroll_view = SCROLL_VIEW(list_view->scroll_view);
list_view->scroll_view = iter;
scroll_view->on_scroll = list_view_on_scroll_view_scroll;
scroll_view->on_scroll_to = list_view_on_scroll_view_scroll_to;
scroll_view->on_layout_children = list_view_on_scroll_view_layout_children;
break;
}
WIDGET_FOR_EACH_CHILD_END();
WIDGET_FOR_EACH_CHILD_BEGIN_R(widget, iter, i)
if (iter && (tk_str_eq(iter->vt->type, WIDGET_TYPE_SCROLL_BAR) ||
tk_str_eq(iter->vt->type, WIDGET_TYPE_SCROLL_BAR_DESKTOP) ||
tk_str_eq(iter->vt->type, WIDGET_TYPE_SCROLL_BAR_MOBILE))) {
if (iter == list_view->scroll_bar) break;
if (list_view->scroll_bar != NULL) {
widget_off_by_func(list_view->scroll_bar, EVT_VALUE_CHANGED,
list_view_on_scroll_bar_value_changed, widget);
}
list_view->scroll_bar = iter;
widget_on(iter, EVT_VALUE_CHANGED, list_view_on_scroll_bar_value_changed, widget);
break;
}
WIDGET_FOR_EACH_CHILD_END();
return RET_OK;
}
widget_t* list_view_create(widget_t* parent, xy_t x, xy_t y, wh_t w, wh_t h) {
return widget_create(parent, TK_REF_VTABLE(list_view), x, y, w, h);
}
ret_t list_view_set_item_height(widget_t* widget, int32_t item_height) {
list_view_t* list_view = LIST_VIEW(widget);
return_value_if_fail(list_view != NULL, RET_BAD_PARAMS);
list_view->item_height = item_height;
return RET_OK;
}
ret_t list_view_set_default_item_height(widget_t* widget, int32_t default_item_height) {
list_view_t* list_view = LIST_VIEW(widget);
return_value_if_fail(list_view != NULL, RET_BAD_PARAMS);
list_view->default_item_height = default_item_height;
return RET_OK;
}
ret_t list_view_set_auto_hide_scroll_bar(widget_t* widget, bool_t auto_hide_scroll_bar) {
list_view_t* list_view = LIST_VIEW(widget);
return_value_if_fail(list_view != NULL, RET_BAD_PARAMS);
list_view->auto_hide_scroll_bar = auto_hide_scroll_bar;
return RET_OK;
}
ret_t list_view_set_floating_scroll_bar(widget_t* widget, bool_t floating_scroll_bar) {
list_view_t* list_view = LIST_VIEW(widget);
return_value_if_fail(list_view != NULL, RET_BAD_PARAMS);
list_view->floating_scroll_bar = floating_scroll_bar;
return RET_OK;
}
widget_t* list_view_cast(widget_t* widget) {
return_value_if_fail(WIDGET_IS_INSTANCE_OF(widget, list_view), NULL);
return widget;
}
|
0 |
repos/awtk/src/ext_widgets
|
repos/awtk/src/ext_widgets/scroll_view/list_item_seperator.inc
|
/**
* File: list_item_seperator.h
* Author: AWTK Develop Team
* Brief: list_item_seperator
*
* Copyright (c) 2018 - 2022 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2022-05-03 Li XianJing <[email protected]> created
*
*/
#include "tkc/mem.h"
#include "list_item_seperator.h"
static ret_t list_item_seperator_update(widget_t* widget, bool_t checked) {
bool_t meet = FALSE;
const char* type = widget_get_type(widget);
WIDGET_FOR_EACH_CHILD_BEGIN(widget->parent, iter, i)
if (!meet) {
if (iter == widget) {
meet = TRUE;
}
continue;
}
if (tk_str_eq(widget_get_type(iter), type)) {
break;
}
widget_set_visible(iter, checked);
widget_set_sensitive(iter, checked);
WIDGET_FOR_EACH_CHILD_END()
return RET_OK;
}
static ret_t list_item_seperator_on_value_changed(void* ctx, event_t* e) {
widget_t* widget = WIDGET(ctx);
list_item_seperator_update(widget, widget_get_value_int(widget));
return RET_OK;
}
static ret_t list_item_seperator_on_will_open(void* ctx, event_t* e) {
widget_t* widget = WIDGET(ctx);
list_item_seperator_update(widget, widget_get_value_int(widget));
return RET_REMOVE;
}
widget_t* list_item_seperator_create(widget_t* parent, xy_t x, xy_t y, wh_t w, wh_t h) {
widget_t* widget =
check_button_create_ex(parent, x, y, w, h, WIDGET_TYPE_LIST_ITEM_SEPERATOR, FALSE);
return_value_if_fail(widget != NULL, NULL);
widget_on(widget, EVT_VALUE_CHANGED, list_item_seperator_on_value_changed, widget);
widget_on(widget, EVT_WINDOW_WILL_OPEN, list_item_seperator_on_value_changed, widget);
return widget;
}
widget_t* list_item_seperator_cast(widget_t* widget) {
return_value_if_fail(widget != NULL, NULL);
if (!tk_str_eq(widget_get_type(widget), WIDGET_TYPE_LIST_ITEM_SEPERATOR)) {
return NULL;
}
return widget;
}
|
0 |
repos/awtk/src/ext_widgets
|
repos/awtk/src/ext_widgets/scroll_view/children_layouter_list_view.h
|
/**
* File: children_layouter_list_view.h
* Author: AWTK Develop Team
* Brief: children layouter list view
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2019-05-22 Li XianJing <[email protected]> created
*
*/
#ifndef TK_CHILDREN_LAYOUTER_LIST_VIEW_H
#define TK_CHILDREN_LAYOUTER_LIST_VIEW_H
#include "base/children_layouter.h"
BEGIN_C_DECLS
/**
* @class children_layouter_list_view_t
* @parent children_layouter_t
*
* listview的子控件布局算法实现。
*
*> 用法请参考：[listview子控件布局算法](
*https://github.com/zlgopen/awtk/blob/master/docs/children_layouter_list_view.md)
*
*/
typedef struct _children_layouter_list_view_t {
children_layouter_t layouter;
uint8_t x_margin;
uint8_t y_margin;
uint16_t spacing;
uint16_t cols;
uint16_t item_height;
uint16_t default_item_height;
uint8_t hlayouter : 1;
uint8_t keep_invisible : 1;
uint8_t keep_disable : 1;
uint32_t animating_time; /* 单位为毫秒，仅适用于单列的情况 */
} children_layouter_list_view_t;
/**
* @method children_layouter_list_view_create
* @annotation ["constructor"]
*
* 创建子控件布局对象。
*
* @return {children_layouter_t*} 返回创建子控件布局对象。
*
*/
children_layouter_t* children_layouter_list_view_create(void);
#define CHILDREN_LAYOUTER_LIST_VIEW "list_view"
END_C_DECLS
#endif /*TK_CHILDREN_LAYOUTER_LIST_VIEW_H*/
|
0 |
repos/awtk/src/ext_widgets
|
repos/awtk/src/ext_widgets/scroll_view/scroll_bar.c
|
/**
* File: scroll_bar.h
* Author: AWTK Develop Team
* Brief: scroll_bar
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-01-28 Li XianJing <[email protected]> created
*
*/
#include "tkc/mem.h"
#include "tkc/utils.h"
#include "widgets/button.h"
#include "base/layout.h"
#include "widgets/dragger.h"
#include "base/widget_vtable.h"
#include "base/window_manager.h"
#include "scroll_view/scroll_bar.h"
#include "widget_animators/widget_animator_value.h"
#include "widget_animators/widget_animator_opacity.h"
#define CHILD_UP "up"
#define CHILD_DOWN "down"
#define CHILD_DRAGGER "dragger"
#define SCROLL_BAR_UP_BUTTON_STYLE_NAME "scroll_up"
#define SCROLL_BAR_DOWN_BUTTON_STYLE_NAME "scroll_down"
#define SCROLL_BAR_LEFT_BUTTON_STYLE_NAME "scroll_left"
#define SCROLL_BAR_RIGHT_BUTTON_STYLE_NAME "scroll_right"
#ifndef TK_DRAGGER_MIN_SIZE
#define TK_DRAGGER_MIN_SIZE 10
#endif /*TK_DRAGGER_MIN_SIZE*/
#define SCROLL_BAR_UP_AND_DOWN_BUTTON_STYLE_IS_EXIST(up, down) \
((up) != NULL && (up)->style != NULL && (down) != NULL && (down)->style != NULL)
static ret_t scroll_bar_init(widget_t* widget);
static ret_t scroll_bar_desktop_init(widget_t* widget);
static ret_t scroll_bar_update_dragger(widget_t* widget);
static ret_t scroll_bar_create_children(widget_t* widget);
static ret_t scroll_bar_set_is_mobile(widget_t* widget, bool_t value);
widget_t* scroll_bar_create_desktop_self(widget_t* parent, xy_t x, xy_t y, wh_t w, wh_t h);
/*mobile*/
static ret_t scroll_bar_mobile_get_dragger_size(widget_t* widget, rect_t* r) {
int64_t x = 0;
int64_t y = 0;
int64_t w = 0;
int64_t h = 0;
int64_t virtual_size = 0;
int64_t value = 0;
int64_t widget_w = widget->w;
int64_t widget_h = widget->h;
scroll_bar_t* scroll_bar = SCROLL_BAR(widget);
ENSURE(scroll_bar);
if (scroll_bar->virtual_size <= 0) {
return RET_OK;
}
virtual_size = scroll_bar->virtual_size;
value = scroll_bar->value;
if (widget_w > widget_h) {
/*horizon*/
return_value_if_fail(virtual_size >= widget_w, RET_BAD_PARAMS);
y = 1;
h = widget_h - 2;
w = (widget_w * widget_w) / virtual_size;
w = tk_max(w, 4);
x = (widget_w - w) * value / virtual_size;
} else {
/*vertical*/
return_value_if_fail(virtual_size >= widget_h, RET_BAD_PARAMS);
x = 1;
w = widget_w - 2;
h = (widget_h * widget_h) / virtual_size;
h = tk_max(h, 4);
y = (widget_h - h) * value / virtual_size;
}
r->x = x;
r->y = y;
r->w = w;
r->h = h;
return RET_OK;
}
static ret_t scroll_bar_mobile_on_paint_self(widget_t* widget, canvas_t* c) {
rect_t r = rect_init(0, 0, 0, 0);
style_t* style = widget->astyle;
color_t trans = color_init(80, 80, 80, 0xff);
color_t fg = style_get_color(style, STYLE_ID_FG_COLOR, trans);
uint32_t round_radius = style_get_int(style, STYLE_ID_ROUND_RADIUS, 0);
return_value_if_fail(scroll_bar_mobile_get_dragger_size(widget, &r) == RET_OK, RET_FAIL);
canvas_set_fill_color(c, fg);
if (round_radius > 0) {
canvas_fill_rounded_rect(c, &r, &r, &fg, round_radius);
} else {
canvas_fill_rect(c, r.x, r.y, r.w, r.h);
}
return RET_OK;
}
/*destkop*/
static ret_t scroll_bar_desktop_on_click(widget_t* widget, pointer_event_t* e) {
int32_t delta = 0;
point_t p = {e->x, e->y};
scroll_bar_t* scroll_bar = SCROLL_BAR(widget);
ENSURE(scroll_bar);
if (widget->target != NULL) {
return RET_OK;
}
widget_to_local(widget, &p);
if (widget->w > widget->h) {
if (p.x < scroll_bar->dragger->x) {
delta = -widget->w;
} else {
delta = widget->w;
}
if (scroll_bar->dragger->x <= p.y && p.x <= (scroll_bar->dragger->x + scroll_bar->dragger->w)) {
return RET_OK;
}
} else {
if (p.y < scroll_bar->dragger->y) {
delta = -widget->h;
} else {
delta = widget->h;
}
if (scroll_bar->dragger->y <= p.y && p.y <= (scroll_bar->dragger->y + scroll_bar->dragger->h)) {
return RET_OK;
}
}
if (delta > 0) {
delta -= scroll_bar->row;
} else {
delta += scroll_bar->row;
}
scroll_bar_scroll_delta(widget, delta);
return RET_OK;
}
static ret_t scroll_bar_desktop_on_event(widget_t* widget, event_t* e) {
uint16_t type = e->type;
scroll_bar_t* scroll_bar = SCROLL_BAR(widget);
return_value_if_fail(scroll_bar != NULL, RET_BAD_PARAMS);
switch (type) {
case EVT_POINTER_UP: {
scroll_bar_desktop_on_click(widget, (pointer_event_t*)e);
break;
}
case EVT_POINTER_LEAVE:
widget_set_state(widget, WIDGET_STATE_NORMAL);
break;
case EVT_POINTER_ENTER:
widget_set_state(widget, WIDGET_STATE_OVER);
break;
case EVT_RESIZE:
case EVT_MOVE_RESIZE: {
widget_t* up = widget_lookup(widget, CHILD_UP, FALSE);
widget_t* down = widget_lookup(widget, CHILD_DOWN, FALSE);
bool_t horizon = widget->w > widget->h;
if (!scroll_bar->user_wheel_scroll) {
scroll_bar->wheel_scroll = !horizon;
}
if (up != NULL) {
const char* style_name =
horizon ? SCROLL_BAR_LEFT_BUTTON_STYLE_NAME : SCROLL_BAR_UP_BUTTON_STYLE_NAME;
if (widget_is_style_exist(down, style_name, NULL)) {
widget_use_style(up, style_name);
}
}
if (down != NULL) {
const char* style_name =
horizon ? SCROLL_BAR_RIGHT_BUTTON_STYLE_NAME : SCROLL_BAR_DOWN_BUTTON_STYLE_NAME;
if (widget_is_style_exist(down, style_name, NULL)) {
widget_use_style(down, style_name);
}
}
break;
}
default:
break;
}
return RET_OK;
}
static ret_t scroll_bar_destop_get_dragger_size(widget_t* widget, rect_t* r) {
int64_t x = 0;
int64_t y = 0;
int64_t w = 0;
int64_t h = 0;
int64_t value = 0;
int64_t virtual_size = 0;
uint32_t button_margin = 0;
int64_t widget_w = widget->w;
int64_t widget_h = widget->h;
scroll_bar_t* scroll_bar = SCROLL_BAR(widget);
widget_t* up = widget_lookup(widget, CHILD_UP, FALSE);
widget_t* down = widget_lookup(widget, CHILD_DOWN, FALSE);
memset(r, 0x00, sizeof(rect_t));
if (scroll_bar->virtual_size <= 0) {
return RET_OK;
}
if (SCROLL_BAR_UP_AND_DOWN_BUTTON_STYLE_IS_EXIST(up, down)) {
if (widget_w > widget_h) {
button_margin = widget_h;
} else {
button_margin = widget_w;
}
}
value = scroll_bar->value;
if (widget_w > widget_h) {
int64_t max_bar_w = widget_w - 2 * button_margin;
/*horizon*/
virtual_size = tk_max(widget_w, scroll_bar->virtual_size);
y = 1;
h = widget_h - 2;
w = (widget_w * max_bar_w) / virtual_size;
w = tk_max(w, TK_DRAGGER_MIN_SIZE);
x = (widget_w - w - 2 * button_margin) * value / virtual_size + button_margin;
} else {
/*vertical*/
int64_t max_bar_h = widget_h - 2 * button_margin;
virtual_size = tk_max(widget_h, scroll_bar->virtual_size);
x = 1;
w = widget_w - 2;
h = (widget_h * max_bar_h) / virtual_size;
h = tk_max(h, TK_DRAGGER_MIN_SIZE);
y = (widget_h - h - 2 * button_margin) * value / virtual_size + button_margin;
}
r->x = x;
r->y = y;
r->w = w;
r->h = h;
return RET_OK;
}
ret_t scroll_bar_add_delta_ex(widget_t* widget, int32_t d, bool_t animatable) {
int64_t delta = 0;
int64_t new_value = 0;
scroll_bar_t* scroll_bar = SCROLL_BAR(widget);
ENSURE(scroll_bar);
if (widget->w > widget->h) {
if (scroll_bar->virtual_size > widget->w) {
double scale = (double)(scroll_bar->virtual_size) / (scroll_bar->virtual_size - widget->w);
delta = d * scale;
}
} else {
if (scroll_bar->virtual_size > widget->h) {
double scale = (double)(scroll_bar->virtual_size) / (scroll_bar->virtual_size - widget->h);
delta = d * scale;
}
}
new_value = scroll_bar->value + delta;
new_value = tk_max(new_value, 0);
new_value = tk_min(new_value, scroll_bar->virtual_size);
if (scroll_bar->value != new_value) {
if (scroll_bar->animatable && animatable) {
scroll_bar_scroll_to(widget, new_value, scroll_bar->animator_time);
} else {
scroll_bar_set_value(widget, new_value);
}
}
return RET_OK;
}
ret_t scroll_bar_scroll_delta(widget_t* widget, int32_t delta) {
return scroll_bar_add_delta_ex(widget, delta, TRUE);
}
ret_t scroll_bar_add_delta(widget_t* widget, int32_t delta) {
return scroll_bar_add_delta_ex(widget, delta, FALSE);
}
static ret_t scroll_bar_on_up_button_clicked(void* ctx, event_t* e) {
return scroll_bar_scroll_delta(WIDGET(ctx), -SCROLL_BAR(ctx)->row);
}
static ret_t scroll_bar_on_down_button_clicked(void* ctx, event_t* e) {
return scroll_bar_scroll_delta(WIDGET(ctx), SCROLL_BAR(ctx)->row);
}
static ret_t scroll_bar_on_drag(void* ctx, event_t* e) {
int64_t value = 0;
uint32_t button_margin = 0;
widget_t* widget = WIDGET(ctx);
int64_t widget_w = widget->w;
int64_t widget_h = widget->h;
scroll_bar_t* scroll_bar = SCROLL_BAR(ctx);
ENSURE(scroll_bar);
widget_t* dragger = scroll_bar->dragger;
widget_t* up = widget_lookup(widget, CHILD_UP, FALSE);
widget_t* down = widget_lookup(widget, CHILD_DOWN, FALSE);
if (SCROLL_BAR_UP_AND_DOWN_BUTTON_STYLE_IS_EXIST(up, down)) {
if (widget_w > widget_h) {
button_margin = widget_h;
} else {
button_margin = widget_w;
}
}
if (widget_w > widget_h) {
int64_t x = scroll_bar->dragger->x;
int64_t max_x = (widget_w - 2 * button_margin - dragger->w);
if (max_x <= 0) {
value = 0;
} else {
value = (x - button_margin) * scroll_bar->virtual_size / max_x;
}
} else {
int64_t y = scroll_bar->dragger->y;
int64_t max_y = (widget_h - 2 * button_margin - dragger->h);
if (max_y <= 0) {
value = 0;
} else {
value = (y - button_margin) * scroll_bar->virtual_size / max_y;
}
}
scroll_bar_set_value(widget, value);
return RET_OK;
}
static ret_t scroll_bar_on_copy(widget_t* widget, widget_t* other) {
scroll_bar_t* scroll_bar = SCROLL_BAR(widget);
scroll_bar_t* scroll_bar_other = SCROLL_BAR(other);
return_value_if_fail(scroll_bar != NULL && scroll_bar_other != NULL, RET_BAD_PARAMS);
widget_on_copy_recursive(widget, other);
if (!scroll_bar_is_mobile(widget)) {
scroll_bar_create_children(widget);
}
return RET_OK;
}
static ret_t scroll_bar_on_layout_children(widget_t* widget) {
uint32_t button_margin = 0;
int32_t widget_w = widget->w;
int32_t widget_h = widget->h;
rect_t r = rect_init(0, 0, 0, 0);
scroll_bar_t* scroll_bar = SCROLL_BAR(widget);
ENSURE(scroll_bar);
widget_t* dragger = scroll_bar->dragger;
widget_t* up = widget_lookup(widget, CHILD_UP, FALSE);
widget_t* down = widget_lookup(widget, CHILD_DOWN, FALSE);
if (SCROLL_BAR_UP_AND_DOWN_BUTTON_STYLE_IS_EXIST(up, down)) {
widget_set_visible(up, TRUE);
widget_set_visible(down, TRUE);
if (widget->w > widget->h) {
button_margin = widget_h;
widget_move_resize(up, 0, 0, widget->h, widget->h);
widget_move_resize(down, widget->w - widget->h, 0, widget->h, widget->h);
} else {
button_margin = widget_w;
widget_move_resize(up, 0, 0, widget->w, widget->w);
widget_move_resize(down, 0, widget->h - widget->w, widget->w, widget->w);
}
} else {
if (up != NULL) {
widget_set_visible(up, FALSE);
}
if (down != NULL) {
widget_set_visible(down, FALSE);
}
}
if (scroll_bar->virtual_size <= 0) {
return RET_OK;
}
return_value_if_fail(scroll_bar_destop_get_dragger_size(widget, &r) == RET_OK, RET_FAIL);
if (dragger != NULL) {
if (widget->w > widget->h) {
int32_t max_x = button_margin + (widget_w - 2 * button_margin - r.w);
max_x = tk_max(max_x, button_margin);
dragger_set_range(dragger, button_margin, r.y, max_x, r.y);
} else {
int32_t max_y = button_margin + (widget_h - 2 * button_margin - r.h);
max_y = tk_max(max_y, button_margin);
dragger_set_range(dragger, r.x, button_margin, r.x, max_y);
}
widget_move_resize(WIDGET(dragger), r.x, r.y, r.w, r.h);
}
widget_invalidate_force(widget, NULL);
return RET_OK;
}
static ret_t scroll_bar_create_children(widget_t* widget) {
widget_t* up = NULL;
widget_t* down = NULL;
widget_t* dragger = NULL;
scroll_bar_t* scroll_bar = SCROLL_BAR(widget);
return_value_if_fail(widget != NULL && scroll_bar != NULL, RET_BAD_PARAMS);
if (scroll_bar->dragger != NULL) {
return RET_OK;
}
up = button_create(widget, 0, 0, 0, 0);
up->auto_created = TRUE;
button_set_repeat(up, 300);
widget_set_name(up, CHILD_UP);
widget_on(up, EVT_CLICK, scroll_bar_on_up_button_clicked, widget);
down = button_create(widget, 0, 0, 0, 0);
down->auto_created = TRUE;
button_set_repeat(down, 300);
widget_set_name(down, CHILD_DOWN);
widget_on(down, EVT_CLICK, scroll_bar_on_down_button_clicked, widget);
dragger = dragger_create(widget, 0, 0, 0, 0);
dragger->auto_created = TRUE;
widget_set_name(dragger, CHILD_DRAGGER);
widget_use_style(dragger, "scroll_bar");
widget_on(dragger, EVT_DRAG, scroll_bar_on_drag, widget);
if (widget->w > widget->h) {
if (widget_is_style_exist(up, SCROLL_BAR_LEFT_BUTTON_STYLE_NAME, NULL)) {
widget_use_style(up, SCROLL_BAR_LEFT_BUTTON_STYLE_NAME);
}
if (widget_is_style_exist(up, SCROLL_BAR_RIGHT_BUTTON_STYLE_NAME, NULL)) {
widget_use_style(down, SCROLL_BAR_RIGHT_BUTTON_STYLE_NAME);
}
} else {
if (widget_is_style_exist(up, SCROLL_BAR_UP_BUTTON_STYLE_NAME, NULL)) {
widget_use_style(up, SCROLL_BAR_UP_BUTTON_STYLE_NAME);
}
if (widget_is_style_exist(up, SCROLL_BAR_DOWN_BUTTON_STYLE_NAME, NULL)) {
widget_use_style(down, SCROLL_BAR_DOWN_BUTTON_STYLE_NAME);
}
}
scroll_bar->row = 30;
scroll_bar->dragger = dragger;
widget_set_need_relayout_children(widget);
return RET_OK;
}
/*share*/
ret_t scroll_bar_set_params(widget_t* widget, int32_t virtual_size, int32_t row) {
scroll_bar_t* scroll_bar = SCROLL_BAR(widget);
return_value_if_fail(scroll_bar != NULL, RET_BAD_PARAMS);
widget_set_need_relayout_children(widget);
scroll_bar->virtual_size = virtual_size;
scroll_bar->row = row;
if (scroll_bar->value > virtual_size) {
scroll_bar->value = virtual_size;
}
return RET_OK;
}
static ret_t scroll_bar_get_prop(widget_t* widget, const char* name, value_t* v) {
scroll_bar_t* scroll_bar = SCROLL_BAR(widget);
return_value_if_fail(scroll_bar != NULL && name != NULL && v != NULL, RET_BAD_PARAMS);
if (tk_str_eq(name, WIDGET_PROP_MAX)) {
value_set_int(v, scroll_bar->virtual_size);
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_ROW)) {
value_set_int(v, scroll_bar->row);
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_ANIMATABLE)) {
value_set_bool(v, scroll_bar->animatable);
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_VALUE)) {
value_set_int(v, scroll_bar->value);
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_AUTO_HIDE)) {
value_set_bool(v, scroll_bar->auto_hide);
return RET_OK;
} else if (tk_str_eq(name, SCROLL_BAR_PROP_IS_MOBILE)) {
value_set_bool(v, scroll_bar_is_mobile(widget));
return RET_OK;
} else if (tk_str_eq(name, SCROLL_BAR_PROP_ANIMATOR_TIME)) {
value_set_uint32(v, scroll_bar->animator_time);
return RET_OK;
} else if (tk_str_eq(name, SCROLL_BAR_PROP_IS_HORIZON)) {
bool_t is_horizon = (widget->w > widget->h) ? TRUE : FALSE;
value_set_bool(v, is_horizon);
return RET_OK;
} else if (tk_str_eq(name, SCROLL_BAR_PROP_WHEEL_SCROLL)) {
value_set_bool(v, scroll_bar->wheel_scroll);
return RET_OK;
} else if (tk_str_eq(name, SCROLL_BAR_PROP_SCROLL_DELTA)) {
value_set_uint32(v, scroll_bar->scroll_delta);
return RET_OK;
}
return RET_NOT_FOUND;
}
static ret_t scroll_bar_set_prop(widget_t* widget, const char* name, const value_t* v) {
scroll_bar_t* scroll_bar = SCROLL_BAR(widget);
return_value_if_fail(scroll_bar != NULL && name != NULL && v != NULL, RET_BAD_PARAMS);
if (tk_str_eq(name, WIDGET_PROP_MAX)) {
scroll_bar->virtual_size = value_int(v);
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_ROW)) {
scroll_bar->row = value_int(v);
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_ANIMATABLE)) {
scroll_bar->animatable = value_bool(v);
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_VALUE)) {
scroll_bar_set_value(widget, value_int(v));
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_AUTO_HIDE)) {
scroll_bar_set_auto_hide(widget, value_bool(v));
return RET_OK;
} else if (tk_str_eq(name, SCROLL_BAR_PROP_IS_MOBILE)) {
scroll_bar_set_is_mobile(widget, value_bool(v));
return RET_OK;
} else if (tk_str_eq(name, SCROLL_BAR_PROP_ANIMATOR_TIME)) {
return scroll_bar_set_animator_time(widget, value_uint32(v));
} else if (tk_str_eq(name, SCROLL_BAR_PROP_WHEEL_SCROLL)) {
return scroll_bar_set_wheel_scroll(widget, value_bool(v));
} else if (tk_str_eq(name, SCROLL_BAR_PROP_SCROLL_DELTA)) {
return scroll_bar_set_scroll_delta(widget, value_uint32(v));
}
return RET_NOT_FOUND;
}
static ret_t scroll_bar_desktop_on_parent_wheel_event(void* ctx, event_t* e) {
wheel_event_t* evt = (wheel_event_t*)e;
widget_t* widget = WIDGET(ctx);
scroll_bar_t* scroll_bar = SCROLL_BAR(widget);
int32_t delta = scroll_bar->scroll_delta == 0 ? -evt->dy : (evt->dy > 0 ? -scroll_bar->scroll_delta : scroll_bar->scroll_delta);
return_value_if_fail(scroll_bar != NULL, RET_BAD_PARAMS);
if (widget->enable && widget->sensitive && scroll_bar->wheel_scroll) {
scroll_bar_add_delta(widget, delta);
return RET_STOP;
} else {
return RET_OK;
}
}
static ret_t scroll_bar_desktop_on_attach_parent(widget_t* widget, widget_t* parent) {
scroll_bar_t* scroll_bar = SCROLL_BAR(widget);
return_value_if_fail(scroll_bar != NULL && parent != NULL, RET_BAD_PARAMS);
scroll_bar->wheel_before_id = widget_on(parent, EVT_WHEEL_BEFORE_CHILDREN, scroll_bar_desktop_on_parent_wheel_event, WIDGET(scroll_bar));
return RET_OK;
}
static ret_t scroll_bar_desktop_on_detach_parent(widget_t* widget, widget_t* parent) {
scroll_bar_t* scroll_bar = SCROLL_BAR(widget);
return_value_if_fail(scroll_bar != NULL && parent != NULL, RET_BAD_PARAMS);
if (!parent->destroying) {
widget_off(parent, scroll_bar->wheel_before_id);
}
scroll_bar->wheel_before_id = TK_INVALID_ID;
return RET_OK;
}
static ret_t scroll_bar_desktop_on_destroy(widget_t* widget) {
scroll_bar_t* scroll_bar = SCROLL_BAR(widget);
return_value_if_fail(scroll_bar != NULL, RET_BAD_PARAMS);
if (scroll_bar->wheel_before_id != TK_INVALID_ID && widget->parent != NULL) {
widget_off(widget->parent, scroll_bar->wheel_before_id);
scroll_bar->wheel_before_id = TK_INVALID_ID;
}
return RET_OK;
}
static const char* s_scroll_bar_clone_properties[] = {WIDGET_PROP_MAX,
WIDGET_PROP_ROW,
WIDGET_PROP_ANIMATABLE,
WIDGET_PROP_VALUE,
SCROLL_BAR_PROP_ANIMATOR_TIME,
NULL};
static const char* s_scroll_bar_persitent_properties[] = {WIDGET_PROP_ANIMATABLE, NULL};
TK_DECL_VTABLE(scroll_bar_mobile) = {.size = sizeof(scroll_bar_t),
.inputable = TRUE,
.type = WIDGET_TYPE_SCROLL_BAR_MOBILE,
.clone_properties = s_scroll_bar_clone_properties,
.get_parent_vt = TK_GET_PARENT_VTABLE(widget),
.create = scroll_bar_create_mobile,
.init = scroll_bar_init,
.set_prop = scroll_bar_set_prop,
.get_prop = scroll_bar_get_prop,
.on_copy = scroll_bar_on_copy,
.on_layout_children = scroll_bar_on_layout_children,
.on_paint_self = scroll_bar_mobile_on_paint_self};
TK_DECL_VTABLE(scroll_bar_desktop) = {.size = sizeof(scroll_bar_t),
.inputable = TRUE,
.type = WIDGET_TYPE_SCROLL_BAR_DESKTOP,
.clone_properties = s_scroll_bar_clone_properties,
.persistent_properties = s_scroll_bar_persitent_properties,
.get_parent_vt = TK_GET_PARENT_VTABLE(widget),
.create = scroll_bar_create_desktop_self,
.init = scroll_bar_desktop_init,
.on_attach_parent = scroll_bar_desktop_on_attach_parent,
.on_detach_parent = scroll_bar_desktop_on_detach_parent,
.on_destroy = scroll_bar_desktop_on_destroy,
.on_event = scroll_bar_desktop_on_event,
.on_layout_children = scroll_bar_on_layout_children,
.on_copy = scroll_bar_on_copy,
.set_prop = scroll_bar_set_prop,
.get_prop = scroll_bar_get_prop};
bool_t scroll_bar_is_mobile(widget_t* widget) {
return widget != NULL && tk_str_eq(widget->vt->type, WIDGET_TYPE_SCROLL_BAR_MOBILE);
}
static ret_t scroll_bar_on_value_animate_end(void* ctx, event_t* e) {
widget_t* widget = WIDGET(ctx);
scroll_bar_t* scroll_bar = SCROLL_BAR(ctx);
return_value_if_fail(widget != NULL && scroll_bar != NULL, RET_REMOVE);
scroll_bar->wa_value = NULL;
return RET_REMOVE;
}
static ret_t scroll_bar_on_opactiy_animate_end(void* ctx, event_t* e) {
widget_t* widget = WIDGET(ctx);
scroll_bar_t* scroll_bar = SCROLL_BAR(ctx);
return_value_if_fail(widget != NULL && scroll_bar != NULL, RET_REMOVE);
scroll_bar->wa_opactiy = NULL;
if (widget->opacity == 0xff) {
widget_set_sensitive(widget, TRUE);
widget_set_visible_only(widget, TRUE);
} else {
widget_set_sensitive(widget, FALSE);
widget_set_visible_only(widget, FALSE);
}
return RET_REMOVE;
}
ret_t scroll_bar_scroll_to(widget_t* widget, int32_t value, int32_t duration) {
scroll_bar_t* scroll_bar = SCROLL_BAR(widget);
return_value_if_fail(scroll_bar != NULL, RET_BAD_PARAMS);
if (scroll_bar->wa_value != NULL) {
widget_animator_destroy(scroll_bar->wa_value);
scroll_bar->wa_value = NULL;
}
widget_set_opacity(widget, 0xff);
widget_set_sensitive(widget, TRUE);
widget_set_visible_only(widget, TRUE);
widget_invalidate_force(widget, NULL);
if (scroll_bar->value == value) {
if (scroll_bar_is_mobile(widget)) {
scroll_bar_hide_by_opacity_animation(widget, duration, TK_ANIMATING_TIME);
}
return RET_OK;
}
#ifndef WITHOUT_WIDGET_ANIMATORS
if (duration > 0) {
scroll_bar->wa_value = widget_animator_value_create(widget, duration, 0, EASING_SIN_INOUT);
return_value_if_fail(scroll_bar->wa_value != NULL, RET_OOM);
widget_animator_value_set_params(scroll_bar->wa_value, scroll_bar->value, value);
widget_animator_start(scroll_bar->wa_value);
widget_animator_on(scroll_bar->wa_value, EVT_ANIM_END, scroll_bar_on_value_animate_end,
scroll_bar);
if (scroll_bar_is_mobile(widget)) {
scroll_bar_hide_by_opacity_animation(widget, TK_ANIMATING_TIME, TK_ANIMATING_TIME);
} else {
scroll_bar->wa_opactiy = NULL;
}
} else
#endif
{
scroll_bar_set_value(widget, value);
scroll_bar_on_value_animate_end(widget, NULL);
}
return RET_OK;
}
static ret_t scroll_bar_update_dragger(widget_t* widget) {
scroll_bar_t* scroll_bar = SCROLL_BAR(widget);
return_value_if_fail(scroll_bar != NULL, RET_BAD_PARAMS);
if (!scroll_bar_is_mobile(widget)) {
rect_t r = rect_init(0, 0, 0, 0);
return_value_if_fail(scroll_bar_destop_get_dragger_size(widget, &r) == RET_OK, RET_FAIL);
widget_move_resize(scroll_bar->dragger, r.x, r.y, r.w, r.h);
}
return RET_OK;
}
static ret_t scroll_bar_set_value_only_impl(widget_t* widget, int32_t value) {
scroll_bar_t* scroll_bar = SCROLL_BAR(widget);
return_value_if_fail(scroll_bar != NULL, RET_BAD_PARAMS);
if (value < 0) {
value = 0;
}
if (value > scroll_bar->virtual_size) {
value = scroll_bar->virtual_size;
}
scroll_bar->value = value;
return RET_OK;
}
ret_t scroll_bar_set_value(widget_t* widget, int32_t value) {
scroll_bar_t* scroll_bar = SCROLL_BAR(widget);
return_value_if_fail(scroll_bar != NULL && value >= 0, RET_BAD_PARAMS);
if (scroll_bar->value != value) {
value_change_event_t evt;
value_change_event_init(&evt, EVT_VALUE_WILL_CHANGE, widget);
value_set_int(&(evt.old_value), scroll_bar->value);
value_set_int(&(evt.new_value), value);
if (widget_dispatch(widget, (event_t*)&evt) != RET_STOP) {
scroll_bar_set_value_only_impl(widget, value);
evt.e.type = EVT_VALUE_CHANGED;
widget_dispatch(widget, (event_t*)&evt);
widget_invalidate(widget, NULL);
}
scroll_bar_update_dragger(widget);
}
return RET_OK;
}
ret_t scroll_bar_set_value_only(widget_t* widget, int32_t value) {
scroll_bar_t* scroll_bar = SCROLL_BAR(widget);
return_value_if_fail(scroll_bar != NULL, RET_BAD_PARAMS);
if (scroll_bar->value != value) {
scroll_bar_set_value_only_impl(widget, value);
/*解决调用此接口设置value后，界面滑块位置没更新的问题。*/
scroll_bar_update_dragger(widget);
}
return RET_OK;
}
/*create*/
static ret_t scroll_bar_set_is_mobile(widget_t* widget, bool_t value) {
scroll_bar_t* scroll_bar = SCROLL_BAR(widget);
return_value_if_fail(scroll_bar != NULL, RET_BAD_PARAMS);
if (value == scroll_bar_is_mobile(widget)) {
return RET_OK;
}
if (value) {
widget->vt = TK_REF_VTABLE(scroll_bar_mobile);
widget_destroy_children(widget);
scroll_bar->dragger = NULL;
} else {
widget->vt = TK_REF_VTABLE(scroll_bar_desktop);
scroll_bar_create_children(widget);
}
scroll_bar_set_auto_hide(widget, scroll_bar_is_mobile(widget));
return RET_OK;
}
static ret_t scroll_bar_init(widget_t* widget) {
scroll_bar_t* scroll_bar = SCROLL_BAR(widget);
return_value_if_fail(scroll_bar != NULL, RET_BAD_PARAMS);
scroll_bar->animatable = TRUE;
scroll_bar->animator_time = TK_ANIMATING_TIME;
scroll_bar_set_auto_hide(widget, scroll_bar_is_mobile(widget));
widget_set_state(widget, WIDGET_STATE_NORMAL);
return RET_OK;
}
static widget_t* scroll_bar_create_internal(widget_t* parent, xy_t x, xy_t y, wh_t w, wh_t h,
const widget_vtable_t* vt) {
widget_t* widget = widget_create(parent, vt, x, y, w, h);
return_value_if_fail(scroll_bar_init(widget) == RET_OK, NULL);
return widget;
}
widget_t* scroll_bar_create_mobile(widget_t* parent, xy_t x, xy_t y, wh_t w, wh_t h) {
return scroll_bar_create_internal(parent, x, y, w, h, TK_REF_VTABLE(scroll_bar_mobile));
}
static ret_t scroll_bar_desktop_init(widget_t* widget) {
scroll_bar_t* scroll_bar = SCROLL_BAR(widget);
return_value_if_fail(scroll_bar != NULL, RET_BAD_PARAMS);
scroll_bar->wheel_scroll = TRUE;
return RET_OK;
}
widget_t* scroll_bar_create_desktop_self(widget_t* parent, xy_t x, xy_t y, wh_t w, wh_t h) {
widget_t* widget = scroll_bar_create_internal(parent, x, y, w, h, TK_REF_VTABLE(scroll_bar_desktop));
scroll_bar_desktop_init(widget);
return widget;
}
widget_t* scroll_bar_create_desktop(widget_t* parent, xy_t x, xy_t y, wh_t w, wh_t h) {
widget_t* widget = scroll_bar_create_desktop_self(parent, x, y, w, h);
return_value_if_fail(widget != NULL, NULL);
scroll_bar_create_children(widget);
return widget;
}
widget_t* scroll_bar_create(widget_t* parent, xy_t x, xy_t y, wh_t w, wh_t h) {
#ifdef WITH_DESKTOP_STYLE
return scroll_bar_create_desktop(parent, x, y, w, h);
#else
return scroll_bar_create_mobile(parent, x, y, w, h);
#endif /*WITH_DESKTOP_STYLE*/
}
widget_t* scroll_bar_cast(widget_t* widget) {
return_value_if_fail(WIDGET_IS_INSTANCE_OF(widget, scroll_bar_mobile) ||
WIDGET_IS_INSTANCE_OF(widget, scroll_bar_desktop),
NULL);
return widget;
}
ret_t scroll_bar_hide_by_opacity_animation(widget_t* widget, int32_t duration, int32_t delay) {
scroll_bar_t* scroll_bar = SCROLL_BAR(widget);
return_value_if_fail(scroll_bar != NULL, RET_BAD_PARAMS);
if (scroll_bar_is_mobile(widget) && !scroll_bar->auto_hide) {
return RET_OK;
}
#ifndef WITHOUT_WIDGET_ANIMATORS
if (scroll_bar->wa_opactiy != NULL) {
widget_animator_destroy(scroll_bar->wa_opactiy);
scroll_bar->wa_opactiy = NULL;
}
scroll_bar->wa_opactiy =
widget_animator_opacity_create(widget, duration, delay, EASING_SIN_INOUT);
widget_animator_on(scroll_bar->wa_opactiy, EVT_ANIM_END, scroll_bar_on_opactiy_animate_end,
scroll_bar);
widget_animator_opacity_set_params(scroll_bar->wa_opactiy, widget->opacity, 0);
widget_animator_start(scroll_bar->wa_opactiy);
#else
widget->opacity = 0;
scroll_bar_on_opactiy_animate_end(widget, NULL);
#endif /*WITHOUT_WIDGET_ANIMATORS*/
return RET_OK;
}
ret_t scroll_bar_show_by_opacity_animation(widget_t* widget, int32_t duration, int32_t delay) {
scroll_bar_t* scroll_bar = SCROLL_BAR(widget);
return_value_if_fail(scroll_bar != NULL, RET_BAD_PARAMS);
if (scroll_bar->wa_opactiy != NULL) {
widget_animator_destroy(scroll_bar->wa_opactiy);
scroll_bar->wa_opactiy = NULL;
}
scroll_bar->wa_opactiy =
widget_animator_opacity_create(widget, duration, delay, EASING_SIN_INOUT);
widget_animator_on(scroll_bar->wa_opactiy, EVT_ANIM_END, scroll_bar_on_opactiy_animate_end,
scroll_bar);
widget_animator_opacity_set_params(scroll_bar->wa_opactiy, widget->opacity, 0xff);
widget_animator_start(scroll_bar->wa_opactiy);
return RET_OK;
}
ret_t scroll_bar_set_auto_hide(widget_t* widget, bool_t auto_hide) {
scroll_bar_t* scroll_bar = SCROLL_BAR(widget);
return_value_if_fail(scroll_bar != NULL, RET_BAD_PARAMS);
if (auto_hide) {
return_value_if_fail(scroll_bar_is_mobile(widget), RET_BAD_PARAMS);
}
scroll_bar->auto_hide = auto_hide;
if (!auto_hide) {
widget_set_visible(widget, TRUE);
widget_set_sensitive(widget, TRUE);
}
return RET_OK;
}
ret_t scroll_bar_set_animator_time(widget_t* widget, uint32_t animator_time) {
scroll_bar_t* scroll_bar = SCROLL_BAR(widget);
return_value_if_fail(scroll_bar != NULL, RET_BAD_PARAMS);
scroll_bar->animator_time = animator_time;
return RET_OK;
}
ret_t scroll_bar_set_wheel_scroll(widget_t* widget, bool_t wheel_scroll) {
scroll_bar_t* scroll_bar = SCROLL_BAR(widget);
return_value_if_fail(scroll_bar != NULL && !scroll_bar_is_mobile(widget), RET_BAD_PARAMS);
scroll_bar->wheel_scroll = wheel_scroll;
scroll_bar->user_wheel_scroll = TRUE;
return RET_OK;
}
ret_t scroll_bar_set_scroll_delta(widget_t* widget, uint32_t scroll_delta) {
scroll_bar_t* scroll_bar = SCROLL_BAR(widget);
return_value_if_fail(scroll_bar != NULL && !scroll_bar_is_mobile(widget), RET_BAD_PARAMS);
scroll_bar->scroll_delta = scroll_delta;
return RET_OK;
}
|
0 |
repos/awtk/src/ext_widgets
|
repos/awtk/src/ext_widgets/scroll_view/list_item_seperator.h
|
/**
* File: list_item_seperator.h
* Author: AWTK Develop Team
* Brief: list_item_seperator
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2022-05-03 Li XianJing <[email protected]> created
*
*/
#ifndef TK_LIST_ITEM_SEPERATOR_H
#define TK_LIST_ITEM_SEPERATOR_H
#include "widgets/check_button.h"
BEGIN_C_DECLS
/**
* @class list_item_seperator_t
* @parent check_button_t
* @annotation ["scriptable","design","widget"]
* list_item_seperator。
* 用来模拟实现风琴控件(accordion)和属性页分组控件。
*> 当前控件被点击时，显示/隐藏当前控件到下一个分隔符控件之间的控件。
* list_item_seperator\_t是[widget\_t](widget_t.md)的子类控件，widget\_t的函数均适用于list_item_seperator\_t控件。
*
* 在xml中使用"list_item_seperator"标签创建list_item_seperator。如：
*
* ```xml
* <list_item_seperator radio="true" text="Group2" h="32"/>
* <list_item style="empty" children_layout="default(r=1,c=0,ym=1)">
* <label w="30%" text="ASCII"/>
* <edit w="70%" text="" tips="ascii" input_type="ascii" focused="true" action_text="next"/>
* </list_item>
* <list_item style="empty" children_layout="default(r=1,c=0,ym=1)">
* <label w="30%" text="Int"/>
* <edit w="70%" text="" tips="int" input_type="int"/>
* </list_item>
*
* <list_item_seperator radio="true" text="Group3" h="32"/>
* <list_item style="empty" children_layout="default(r=1,c=0,ym=1)">
* <label w="30%" text="Float"/>
* <edit w="70%" text="" tips="float" input_type="float"/>
* </list_item>
* <list_item style="empty" children_layout="default(r=1,c=0,ym=1)">
* <label w="30%" text="UFloat"/>
* <edit w="70%" text="" tips="unsigned float" input_type="ufloat"/>
* </list_item>
* ```
*
* 可用通过style来设置控件的显示风格，如背景颜色等。如：
*
* ```xml
*<list_item_seperator text_color="black" bg_color="#e0e0e0">
* <style name="default" icon_at="left">
* <normal icon="collapse" />
* <pressed icon="collapse" />
* <over icon="collapse" text_color="green"/>
* <focused icon="collapse" text_color="green"/>
* <normal_of_checked icon="expand" text_color="blue"/>
* <pressed_of_checked icon="expand" text_color="blue"/>
* <over_of_checked icon="expand" text_color="green"/>
* <focused_of_checked icon="expand" text_color="green"/>
* </style>
*</list_item_seperator>
* ```
*/
typedef struct _list_item_seperator_t {
check_button_t check_button;
} list_item_seperator_t;
/**
* @method list_item_seperator_create
* 创建list_item_seperator对象
* @annotation ["constructor", "scriptable"]
* @param {widget_t*} parent 父控件
* @param {xy_t} x x坐标
* @param {xy_t} y y坐标
* @param {wh_t} w 宽度
* @param {wh_t} h 高度
*
* @return {widget_t*} 对象。
*/
widget_t* list_item_seperator_create(widget_t* parent, xy_t x, xy_t y, wh_t w, wh_t h);
/**
* @method list_item_seperator_cast
* 转换为list_item_seperator对象(供脚本语言使用)。
* @annotation ["cast", "scriptable"]
* @param {widget_t*} widget list_item_seperator对象。
*
* @return {widget_t*} list_item_seperator对象。
*/
widget_t* list_item_seperator_cast(widget_t* widget);
#define LIST_ITEM_SEPERATOR(widget) \
((list_item_seperator_t*)(list_item_seperator_cast(WIDGET(widget))))
#define WIDGET_TYPE_LIST_ITEM_SEPERATOR "list_item_seperator"
END_C_DECLS
#endif /*TK_LIST_ITEM_SEPERATOR_H*/
|
0 |
repos/awtk/src/ext_widgets
|
repos/awtk/src/ext_widgets/scroll_view/list_view_h.h
|
/**
* File: list_view_h.h
* Author: AWTK Develop Team
* Brief: list_view_h
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-07-17 Li XianJing <[email protected]> created
*
*/
#ifndef TK_LIST_VIEW_H_H
#define TK_LIST_VIEW_H_H
#include "base/widget.h"
BEGIN_C_DECLS
/**
* @class list_view_h_t
* @parent widget_t
* @annotation ["scriptable","design","widget"]
* 水平列表视图控件。
*
* list\_view\_h\_t是[widget\_t](widget_t.md)的子类控件，widget\_t的函数均适用于list\_view\_h\_t控件。
*
* 在xml中使用"list\_view\_h"标签创建水平列表视图控件。如：
*
* ```xml
* <list_view_h x="center" y="10" w="90%" h="100" item_width="200" spacing="5">
* <scroll_view name="view" w="100%" h="100%">
* <image style="border" draw_type="auto" image="1" text="1"/>
* ...
* </scroll_view>
* </list_view_h>
* ```
*
* > 注意：列表项不是作为列表视图控件的直接子控件，而是作为滚动视图的子控件。
*
*
* > 更多用法请参考：[list\_view\_h.xml](
*https://github.com/zlgopen/awtk/blob/master/design/default/ui/list_view_h.xml)
*
* 在c代码中使用函数list\_view\_h\_create创建水平列表视图控件。如：
*
* ```c
* widget_t* list_view = list_view_h_create(win, 0, 0, 0, 0);
* ```
*
* 用代码构造列表视图是比较繁琐的事情，最好用XML来构造。
* 如果需要动态修改，可以使用widget\_clone来增加列表项，使用widget\_remove\_child来移出列表项。
*
* 可用通过style来设置控件的显示风格，如背景颜色和边框颜色等(一般情况不需要)。
*
*/
typedef struct _list_view_h_t {
widget_t widget;
/**
* @property {int32_t} item_width
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 列表项的宽度。
*/
int32_t item_width;
/**
* @property {int32_t} spacing
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 间距。
*/
int32_t spacing;
/*private*/
widget_t* scroll_view;
} list_view_h_t;
/**
* @method list_view_h_create
* 创建list_view_h对象
* @annotation ["constructor", "scriptable"]
* @param {widget_t*} parent 父控件
* @param {xy_t} x x坐标
* @param {xy_t} y y坐标
* @param {wh_t} w 宽度
* @param {wh_t} h 高度
*
* @return {widget_t*} 对象。
*/
widget_t* list_view_h_create(widget_t* parent, xy_t x, xy_t y, wh_t w, wh_t h);
/**
* @method list_view_h_set_item_width
* 设置列表项的宽度。
* @annotation ["scriptable"]
* @param {widget_t*} widget 控件对象。
* @param {int32_t} item_width 列表项的宽度。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t list_view_h_set_item_width(widget_t* widget, int32_t item_width);
/**
* @method list_view_h_set_spacing
* 设置列表项的间距。
* @annotation ["scriptable"]
* @param {widget_t*} widget 控件对象。
* @param {int32_t} spacing 列表项的间距。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t list_view_h_set_spacing(widget_t* widget, int32_t spacing);
/**
* @method list_view_h_cast
* 转换为list_view_h对象(供脚本语言使用)。
* @annotation ["cast", "scriptable"]
* @param {widget_t*} widget list_view_h对象。
*
* @return {widget_t*} list_view_h对象。
*/
widget_t* list_view_h_cast(widget_t* widget);
#define LIST_VIEW_H(widget) ((list_view_h_t*)(list_view_h_cast(WIDGET(widget))))
/*public for subclass and runtime type check*/
TK_EXTERN_VTABLE(list_view_h);
END_C_DECLS
#endif /*TK_LIST_VIEW_H_H*/
|
0 |
repos/awtk/src/ext_widgets
|
repos/awtk/src/ext_widgets/scroll_view/scroll_view.c
|
/**
* File: scroll_view.c
* Author: AWTK Develop Team
* Brief: scroll_view
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-07-03 Li XianJing <[email protected]> created
*
*/
#include "tkc/mem.h"
#include "tkc/utils.h"
#include "base/layout.h"
#include "base/velocity.h"
#include "tkc/time_now.h"
#include "scroll_view/scroll_view.h"
#include "base/widget_vtable.h"
#include "base/image_manager.h"
#include "widget_animators/widget_animator_scroll.h"
#define SCROLL_VIEW_DEFAULT_XSPEED_SCALE 2.0f
#define SCROLL_VIEW_DEFAULT_YSPEED_SCALE 2.0f
static uint32_t scroll_view_get_curr_page(widget_t* widget);
static uint32_t scroll_view_get_page_max_number(widget_t* widget);
static ret_t scroll_view_set_xoffset(scroll_view_t* scroll_view, int32_t xoffset) {
offset_change_event_t evt;
if (scroll_view->xoffset != xoffset) {
offset_change_event_init(&evt, EVT_PAGE_CHANGING, WIDGET(scroll_view),
(float_t)scroll_view->xoffset_save, (float_t)xoffset);
scroll_view->xoffset = xoffset;
widget_dispatch(WIDGET(scroll_view), (event_t*)&evt);
}
return RET_OK;
}
static ret_t scroll_view_set_yoffset(scroll_view_t* scroll_view, int32_t yoffset) {
offset_change_event_t evt;
if (scroll_view->yoffset != yoffset) {
offset_change_event_init(&evt, EVT_PAGE_CHANGING, WIDGET(scroll_view),
(float_t)scroll_view->yoffset_save, (float_t)yoffset);
scroll_view->yoffset = yoffset;
widget_dispatch(WIDGET(scroll_view), (event_t*)&evt);
}
return RET_OK;
}
static ret_t scroll_view_get_item_rect(widget_t* parent, widget_t* widget, rect_t* item_rect) {
rect_t r;
point_t p;
WIDGET_FOR_EACH_CHILD_BEGIN(widget, iter, i)
memset(&p, 0x0, sizeof(point_t));
widget_to_screen_ex(iter, parent, &p);
r = rect_init(p.x, p.y, iter->w, iter->h);
rect_merge(item_rect, &r);
scroll_view_get_item_rect(parent, iter, item_rect);
WIDGET_FOR_EACH_CHILD_END();
return RET_OK;
}
static ret_t scroll_view_update_virtual_size(widget_t* widget) {
int32_t virtual_w = 0;
int32_t virtual_h = 0;
scroll_view_t* scroll_view = SCROLL_VIEW(widget);
return_value_if_fail(scroll_view != NULL && widget != NULL, RET_BAD_PARAMS);
virtual_w = widget->w;
virtual_h = widget->h;
WIDGET_FOR_EACH_CHILD_BEGIN(widget, iter, i)
int32_t r = 0;
int32_t b = 0;
if (scroll_view->recursive) {
rect_t rect = rect_init(0, 0, iter->w, iter->h);
scroll_view_get_item_rect(iter, iter, &rect);
r = iter->x + rect.x + rect.w;
b = iter->y + rect.y + rect.h;
} else {
r = iter->x + iter->w;
b = iter->y + iter->h;
}
if (r > virtual_w) {
virtual_w = r;
}
if (b > virtual_h) {
virtual_h = b;
}
WIDGET_FOR_EACH_CHILD_END();
scroll_view->virtual_w = virtual_w;
scroll_view->virtual_h = virtual_h;
return RET_OK;
}
static ret_t scroll_view_on_layout_children(widget_t* widget) {
scroll_view_t* scroll_view = SCROLL_VIEW(widget);
return_value_if_fail(widget != NULL && scroll_view != NULL, RET_BAD_PARAMS);
if (scroll_view->on_layout_children) {
scroll_view->on_layout_children(widget);
} else {
widget_layout_children_default(widget);
scroll_view_update_virtual_size(widget);
scroll_view_set_offset(widget,
tk_min(scroll_view->xoffset, (scroll_view->virtual_w - widget->w)),
tk_min(scroll_view->yoffset, (scroll_view->virtual_h - widget->h)));
}
if (scroll_view->snap_to_page) {
int32_t curr_page = scroll_view_get_curr_page(widget);
uint32_t max_page = scroll_view_get_page_max_number(widget);
scroll_view->xoffset_end = scroll_view->xoffset;
scroll_view->yoffset_end = scroll_view->yoffset;
scroll_view->fix_end_offset(widget);
scroll_view->xoffset = scroll_view->xoffset_end;
scroll_view->yoffset = scroll_view->yoffset_end;
if (scroll_view->curr_page != curr_page || scroll_view->max_page != max_page) {
scroll_view->max_page = max_page;
scroll_view->curr_page = curr_page;
widget_dispatch_simple_event(widget, EVT_PAGE_CHANGED);
}
}
return RET_OK;
}
static ret_t scroll_view_on_pointer_down(scroll_view_t* scroll_view, pointer_event_t* e) {
velocity_t* v = &(scroll_view->velocity);
velocity_reset(v);
scroll_view->down.x = e->x;
scroll_view->down.y = e->y;
scroll_view->xoffset_save = scroll_view->xoffset;
scroll_view->yoffset_save = scroll_view->yoffset;
scroll_view->xoffset_end = scroll_view->xoffset;
scroll_view->yoffset_end = scroll_view->yoffset;
velocity_update(v, e->e.time, e->x, e->y);
return RET_OK;
}
static ret_t scroll_view_on_scroll_done(void* ctx, event_t* e) {
widget_t* widget = WIDGET(ctx);
scroll_view_t* scroll_view = SCROLL_VIEW(ctx);
return_value_if_fail(widget != NULL && scroll_view != NULL, RET_BAD_PARAMS);
scroll_view->wa = NULL;
scroll_view->curr_page = scroll_view_get_curr_page(widget);
widget_invalidate_force(widget, NULL);
widget_dispatch_simple_event(widget, EVT_SCROLL_END);
widget_dispatch_simple_event(widget, EVT_PAGE_CHANGED);
return RET_REMOVE;
}
static ret_t scroll_view_fix_end_offset_default(widget_t* widget) {
int32_t xoffset_end = 0;
int32_t yoffset_end = 0;
scroll_view_t* scroll_view = SCROLL_VIEW(widget);
return_value_if_fail(widget != NULL && scroll_view != NULL, RET_BAD_PARAMS);
xoffset_end = scroll_view->xoffset_end;
yoffset_end = scroll_view->yoffset_end;
xoffset_end = tk_max(xoffset_end, 0);
yoffset_end = tk_max(yoffset_end, 0);
xoffset_end = tk_min(xoffset_end, (scroll_view->virtual_w - widget->w));
yoffset_end = tk_min(yoffset_end, (scroll_view->virtual_h - widget->h));
if (scroll_view->virtual_w <= widget->w) {
xoffset_end = 0;
}
if (scroll_view->virtual_h <= widget->h) {
yoffset_end = 0;
}
scroll_view->xoffset_end = xoffset_end;
scroll_view->yoffset_end = yoffset_end;
return RET_OK;
}
static int32_t scroll_view_get_snap_to_page_offset_value(widget_t* widget, int32_t offset_end) {
uint32_t tmp = 0;
scroll_view_t* scroll_view = SCROLL_VIEW(widget);
return_value_if_fail(scroll_view != NULL, offset_end);
if (scroll_view->xslidable && !scroll_view->yslidable) {
tmp = widget->w;
} else if (!scroll_view->xslidable && scroll_view->yslidable) {
tmp = widget->h;
}
if (tmp != 0) {
int32_t n = (int32_t)((offset_end + tmp * 0.5f) / tmp);
if (scroll_view->move_to_page) {
if (scroll_view->curr_page - n > 1) {
n = scroll_view->curr_page - 1;
} else if (n - scroll_view->curr_page > 1) {
n = scroll_view->curr_page + 1;
}
}
offset_end = n * tmp;
}
return offset_end;
}
ret_t scroll_view_scroll_to(widget_t* widget, int32_t xoffset_end, int32_t yoffset_end,
int32_t duration) {
int32_t xoffset = 0;
int32_t yoffset = 0;
scroll_view_t* scroll_view = SCROLL_VIEW(widget);
return_value_if_fail(scroll_view != NULL, RET_FAIL);
if (scroll_view->snap_to_page) {
xoffset_end = scroll_view_get_snap_to_page_offset_value(widget, xoffset_end);
yoffset_end = scroll_view_get_snap_to_page_offset_value(widget, yoffset_end);
}
if (scroll_view->fix_end_offset) {
scroll_view->xoffset_end = xoffset_end;
scroll_view->yoffset_end = yoffset_end;
scroll_view->fix_end_offset(widget);
xoffset_end = scroll_view->xoffset_end;
yoffset_end = scroll_view->yoffset_end;
}
if (xoffset_end == scroll_view->xoffset && yoffset_end == scroll_view->yoffset) {
return RET_OK;
}
xoffset = scroll_view->xoffset;
yoffset = scroll_view->yoffset;
if (scroll_view->on_scroll_to) {
scroll_view->on_scroll_to(widget, xoffset_end, yoffset_end, duration);
}
#ifndef WITHOUT_WIDGET_ANIMATORS
if (scroll_view->wa != NULL) {
widget_animator_scroll_t* wa = (widget_animator_scroll_t*)scroll_view->wa;
if (xoffset_end != scroll_view->xoffset) {
bool_t changed = wa->x_to != xoffset_end;
bool_t in_range = wa->x_to > 0 && wa->x_to < (scroll_view->virtual_w - widget->w);
if (changed && in_range) {
wa->x_to = xoffset_end;
wa->x_from = scroll_view->xoffset;
} else if (!scroll_view->yslidable) {
return RET_OK;
}
}
if (yoffset_end != scroll_view->yoffset) {
bool_t changed = wa->y_to != yoffset_end;
bool_t in_range = wa->y_to > 0 && wa->y_to < (scroll_view->virtual_h - widget->h);
if (changed && in_range) {
wa->y_to = yoffset_end;
wa->y_from = scroll_view->yoffset;
} else if (!scroll_view->xslidable) {
return RET_OK;
}
}
wa->base.now = 0;
wa->base.start_time = 0;
} else {
scroll_view->wa = widget_animator_scroll_create(widget, TK_ANIMATING_TIME, 0, EASING_SIN_INOUT);
return_value_if_fail(scroll_view->wa != NULL, RET_OOM);
widget_animator_scroll_set_params(scroll_view->wa, xoffset, yoffset, xoffset_end, yoffset_end);
widget_animator_on(scroll_view->wa, EVT_ANIM_END, scroll_view_on_scroll_done, scroll_view);
widget_animator_start(scroll_view->wa);
widget_dispatch_simple_event(widget, EVT_SCROLL_START);
}
#else
scroll_view->xoffset = xoffset_end;
scroll_view->yoffset = yoffset_end;
scroll_view_on_scroll_done(widget, NULL);
#endif /*WITHOUT_WIDGET_ANIMATORS*/
return RET_OK;
}
ret_t scroll_view_scroll_delta_to(widget_t* widget, int32_t xoffset_delta, int32_t yoffset_delta,
int32_t duration) {
scroll_view_t* scroll_view = SCROLL_VIEW(widget);
return_value_if_fail(scroll_view != NULL, RET_FAIL);
scroll_view->xoffset_end = scroll_view->xoffset + xoffset_delta;
scroll_view->yoffset_end = scroll_view->yoffset + yoffset_delta;
return scroll_view_scroll_to(widget, scroll_view->xoffset_end, scroll_view->yoffset_end,
duration);
}
static ret_t scroll_view_on_pointer_down_abort(scroll_view_t* scroll_view, pointer_event_t* e) {
widget_t* widget = WIDGET(scroll_view);
(void)e;
if (scroll_view->xslidable || scroll_view->yslidable) {
scroll_view_scroll_to(widget, scroll_view->xoffset_end, scroll_view->yoffset_end,
TK_ANIMATING_TIME);
}
return RET_OK;
}
static ret_t scroll_view_on_pointer_up(scroll_view_t* scroll_view, pointer_event_t* e) {
widget_t* widget = WIDGET(scroll_view);
velocity_t* v = &(scroll_view->velocity);
int32_t move_dx = e->x - scroll_view->down.x;
int32_t move_dy = e->y - scroll_view->down.y;
velocity_update(v, e->e.time, e->x, e->y);
if (scroll_view->xslidable || scroll_view->yslidable) {
#ifndef WITHOUT_WIDGET_ANIMATORS
int yv = v->yv;
int xv = v->xv;
#else
int yv = 0;
int xv = 0;
#endif /*WITHOUT_WIDGET_ANIMATORS*/
if (scroll_view->wa != NULL) {
widget_animator_scroll_t* wa = (widget_animator_scroll_t*)scroll_view->wa;
int32_t dx = wa->x_to - scroll_view->xoffset;
int32_t dy = wa->y_to - scroll_view->yoffset;
xv -= dx;
yv -= dy;
log_debug("dx=%d xv=%d dy=%d yv=%d\n", dx, xv, dy, yv);
}
if (scroll_view->xslidable) {
if (tk_abs(move_dx) > TK_CLICK_TOLERANCE) {
scroll_view->xoffset_end = scroll_view->xoffset - xv * scroll_view->xspeed_scale;
} else {
scroll_view->xoffset_end = scroll_view->xoffset - xv / scroll_view->xspeed_scale;
}
}
if (scroll_view->yslidable) {
if (tk_abs(move_dy) > TK_CLICK_TOLERANCE) {
scroll_view->yoffset_end = scroll_view->yoffset - yv * scroll_view->yspeed_scale;
} else {
scroll_view->yoffset_end = scroll_view->yoffset - yv / scroll_view->yspeed_scale;
}
}
scroll_view_scroll_to(widget, scroll_view->xoffset_end, scroll_view->yoffset_end,
TK_ANIMATING_TIME);
}
return RET_OK;
}
static ret_t scroll_view_notify_scrolled(scroll_view_t* scroll_view) {
widget_t* widget = WIDGET(scroll_view);
if (scroll_view->on_scroll) {
scroll_view->on_scroll(widget, scroll_view->xoffset, scroll_view->yoffset);
}
widget_dispatch_simple_event(widget, EVT_SCROLL);
return RET_OK;
}
static int32_t scroll_view_calc_bight_offset(scroll_view_t* scroll_view, int32_t offset,
bool_t vertical) {
float_t r = 0;
float_t temp = 0;
float_t max_d = 0;
float_t translate = 0;
int32_t size = 0;
int32_t ret = offset;
int32_t virtual_size = 0;
widget_t* widget = WIDGET(scroll_view);
return_value_if_fail(scroll_view != NULL && widget != NULL, RET_BAD_PARAMS);
if (vertical) {
size = widget->h;
max_d = (float_t)widget->h * scroll_view->slide_limit_ratio;
virtual_size = scroll_view->virtual_h;
} else {
size = widget->w;
max_d = (float_t)widget->w * scroll_view->slide_limit_ratio;
virtual_size = scroll_view->virtual_w;
}
r = max_d * M_SQRT2 / (M_SQRT2 - 1.0);
translate = r - max_d;
/* Calculation formula: (offset - translate)^2 + (ret + translate)^2 = r^2 */
if (offset < 0) {
offset = tk_min(tk_abs(offset), (int32_t)translate);
temp = powf(r, 2.0) - powf((float_t)offset - translate, 2.0);
ret = -tk_roundi(sqrtf(temp) - translate);
} else if (offset > virtual_size - size) {
offset = tk_min(offset - virtual_size + size, translate);
temp = powf(r, 2.0) - powf((float_t)offset - translate, 2.0);
ret = tk_roundi(sqrtf(temp) - translate) + virtual_size - size;
}
return ret;
}
static ret_t scroll_view_on_pointer_move(scroll_view_t* scroll_view, pointer_event_t* e) {
int32_t dx = 0;
int32_t dy = 0;
int32_t offset = 0;
velocity_t* v = NULL;
return_value_if_fail(scroll_view != NULL && e != NULL, RET_BAD_PARAMS);
v = &(scroll_view->velocity);
dx = e->x - scroll_view->down.x;
dy = e->y - scroll_view->down.y;
velocity_update(v, e->e.time, e->x, e->y);
if (scroll_view->wa == NULL) {
if (scroll_view->xslidable && dx) {
offset = scroll_view_calc_bight_offset(scroll_view, scroll_view->xoffset_save - dx, FALSE);
scroll_view_set_xoffset(scroll_view, offset);
}
if (scroll_view->yslidable && dy) {
offset = scroll_view_calc_bight_offset(scroll_view, scroll_view->yoffset_save - dy, TRUE);
scroll_view_set_yoffset(scroll_view, offset);
}
scroll_view_notify_scrolled(scroll_view);
}
scroll_view->first_move_after_down = FALSE;
return RET_OK;
}
static bool_t scroll_view_is_dragged(widget_t* widget, pointer_event_t* evt) {
int32_t delta = 0;
scroll_view_t* scroll_view = SCROLL_VIEW(widget);
return_value_if_fail(scroll_view != NULL, FALSE);
if (scroll_view->xslidable && scroll_view->yslidable) {
int32_t xdelta = evt->x - scroll_view->down.x;
int32_t ydelta = evt->y - scroll_view->down.y;
delta = tk_abs(xdelta) > tk_abs(ydelta) ? xdelta : ydelta;
} else if (scroll_view->yslidable) {
delta = evt->y - scroll_view->down.y;
} else {
delta = evt->x - scroll_view->down.x;
}
return scroll_view->snap_to_page || (tk_abs(delta) >= TK_DRAG_THRESHOLD);
}
static ret_t scroll_view_on_event(widget_t* widget, event_t* e) {
ret_t ret = RET_OK;
uint16_t type = e->type;
scroll_view_t* scroll_view = SCROLL_VIEW(widget);
return_value_if_fail(scroll_view != NULL, RET_BAD_PARAMS);
switch (type) {
case EVT_POINTER_DOWN:
scroll_view->pressed = TRUE;
scroll_view->dragged = FALSE;
widget_grab(widget->parent, widget);
scroll_view->first_move_after_down = TRUE;
scroll_view_on_pointer_down(scroll_view, (pointer_event_t*)e);
break;
case EVT_POINTER_DOWN_ABORT:
scroll_view_on_pointer_down_abort(scroll_view, (pointer_event_t*)e);
if (scroll_view->pressed) {
widget_ungrab(widget->parent, widget);
}
scroll_view->pressed = FALSE;
scroll_view->dragged = FALSE;
break;
case EVT_POINTER_UP: {
pointer_event_t* evt = (pointer_event_t*)e;
if (scroll_view->pressed && scroll_view_is_dragged(widget, evt)) {
scroll_view_on_pointer_up(scroll_view, (pointer_event_t*)e);
}
scroll_view->pressed = FALSE;
scroll_view->dragged = FALSE;
widget_ungrab(widget->parent, widget);
break;
}
case EVT_POINTER_MOVE: {
pointer_event_t* evt = (pointer_event_t*)e;
if (!scroll_view->pressed || !(scroll_view->xslidable || scroll_view->yslidable)) {
break;
}
if (scroll_view->dragged) {
scroll_view_on_pointer_move(scroll_view, evt);
widget_invalidate_force(widget, NULL);
} else {
if (scroll_view_is_dragged(widget, evt)) {
pointer_event_t abort = *evt;
abort.e.type = EVT_POINTER_DOWN_ABORT;
widget_dispatch_event_to_target_recursive(widget, (event_t*)(&abort));
scroll_view->dragged = TRUE;
}
}
ret = scroll_view->dragged ? RET_STOP : RET_OK;
break;
}
default:
break;
}
return ret;
}
static ret_t scroll_view_on_paint_children(widget_t* widget, canvas_t* c) {
rect_t r;
rect_t r_save;
int32_t xoffset = 0;
int32_t yoffset = 0;
vgcanvas_t* vg = NULL;
scroll_view_t* scroll_view = SCROLL_VIEW(widget);
return_value_if_fail(widget != NULL && c != NULL && scroll_view != NULL, RET_BAD_PARAMS);
vg = canvas_get_vgcanvas(c);
xoffset = -scroll_view->xoffset;
yoffset = -scroll_view->yoffset;
r = rect_init(c->ox, c->oy, widget->w, widget->h);
canvas_translate(c, xoffset, yoffset);
canvas_get_clip_rect(c, &r_save);
r = rect_intersect(&r, &r_save);
if (vg != NULL) {
vgcanvas_save(vg);
vgcanvas_clip_rect(vg, (float_t)r.x, (float_t)r.y, (float_t)r.w, (float_t)r.h);
}
canvas_set_clip_rect(c, &r);
if (scroll_view->on_paint_children) {
scroll_view->on_paint_children(widget, c);
} else {
widget_on_paint_children_default(widget, c);
}
canvas_set_clip_rect(c, &r_save);
canvas_untranslate(c, xoffset, yoffset);
if (vg != NULL) {
vgcanvas_clip_rect(vg, (float_t)r_save.x, (float_t)r_save.y, (float_t)r_save.w,
(float_t)r_save.h);
vgcanvas_restore(vg);
}
return RET_OK;
}
static ret_t scroll_view_on_add_child(widget_t* widget, widget_t* child) {
scroll_view_t* scroll_view = SCROLL_VIEW(widget);
return_value_if_fail(scroll_view != NULL, RET_BAD_PARAMS);
if (scroll_view->on_add_child) {
return scroll_view->on_add_child(widget, child);
} else {
return RET_CONTINUE;
}
}
static widget_t* scroll_view_find_target(widget_t* widget, xy_t x, xy_t y) {
scroll_view_t* scroll_view = SCROLL_VIEW(widget);
return_value_if_fail(scroll_view != NULL, NULL);
if (scroll_view->find_target) {
return scroll_view->find_target(widget, x, y);
} else {
return widget_find_target_default(widget, x, y);
}
}
static uint32_t scroll_view_get_page_max_number(widget_t* widget) {
scroll_view_t* scroll_view = SCROLL_VIEW(widget);
return_value_if_fail(widget != NULL && scroll_view != NULL, 0);
if (scroll_view->xslidable && !scroll_view->yslidable) {
return scroll_view->virtual_w / widget->w;
} else if (!scroll_view->xslidable && scroll_view->yslidable) {
return scroll_view->virtual_h / widget->h;
}
return 0;
}
static uint32_t scroll_view_get_curr_page(widget_t* widget) {
scroll_view_t* scroll_view = SCROLL_VIEW(widget);
return_value_if_fail(widget != NULL && scroll_view != NULL, 0);
if (scroll_view->xslidable && !scroll_view->yslidable) {
return scroll_view->xoffset / widget->w;
} else if (!scroll_view->xslidable && scroll_view->yslidable) {
return scroll_view->yoffset / widget->h;
}
return 0;
}
static ret_t scroll_view_set_curr_page(widget_t* widget, int32_t new_page) {
scroll_view_t* scroll_view = SCROLL_VIEW(widget);
return_value_if_fail(widget != NULL && scroll_view != NULL, RET_BAD_PARAMS);
if (scroll_view->xslidable && !scroll_view->yslidable) {
scroll_view->xoffset_end = new_page * widget->w;
} else if (!scroll_view->xslidable && scroll_view->yslidable) {
scroll_view->yoffset_end = new_page * widget->h;
}
scroll_view->snap_to_page = FALSE;
scroll_view_scroll_to(widget, scroll_view->xoffset_end, scroll_view->yoffset_end,
TK_ANIMATING_TIME);
scroll_view->snap_to_page = TRUE;
return RET_OK;
}
static ret_t scroll_view_get_prop(widget_t* widget, const char* name, value_t* v) {
scroll_view_t* scroll_view = SCROLL_VIEW(widget);
return_value_if_fail(scroll_view != NULL && name != NULL && v != NULL, RET_BAD_PARAMS);
if (tk_str_eq(name, WIDGET_PROP_VIRTUAL_W) || tk_str_eq(name, WIDGET_PROP_LAYOUT_W)) {
value_set_int(v, tk_max(widget->w, scroll_view->virtual_w));
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_VIRTUAL_H) || tk_str_eq(name, WIDGET_PROP_LAYOUT_H)) {
value_set_int(v, tk_max(widget->h, scroll_view->virtual_h));
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_XOFFSET)) {
value_set_int(v, scroll_view->xoffset);
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_YOFFSET)) {
value_set_int(v, scroll_view->yoffset);
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_XSLIDABLE)) {
value_set_bool(v, scroll_view->xslidable);
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_YSLIDABLE)) {
value_set_bool(v, scroll_view->yslidable);
return RET_OK;
} else if (tk_str_eq(name, SCROLL_VIEW_X_SPEED_SCALE)) {
value_set_float(v, scroll_view->xspeed_scale);
return RET_OK;
} else if (tk_str_eq(name, SCROLL_VIEW_Y_SPEED_SCALE)) {
value_set_float(v, scroll_view->yspeed_scale);
return RET_OK;
} else if (tk_str_eq(name, SCROLL_VIEW_RECURSIVE)) {
value_set_bool(v, scroll_view->recursive);
return RET_OK;
} else if (tk_str_eq(name, SCROLL_VIEW_MOVE_TO_PAGE)) {
value_set_bool(v, scroll_view->move_to_page);
return RET_OK;
} else if (tk_str_eq(name, SCROLL_VIEW_SNAP_TO_PAGE)) {
value_set_bool(v, scroll_view->snap_to_page);
return RET_OK;
} else if (tk_str_eq(name, SCROLL_VIEW_SLIDE_LIMIT_RATIO)) {
value_set_float(v, scroll_view->slide_limit_ratio);
return RET_OK;
}
if (scroll_view->snap_to_page) {
if (tk_str_eq(name, WIDGET_PROP_PAGE_MAX_NUMBER)) {
value_set_uint32(v, scroll_view_get_page_max_number(widget));
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_CURR_PAGE)) {
value_set_uint32(v, scroll_view_get_curr_page(widget));
return RET_OK;
}
}
return RET_NOT_FOUND;
}
static ret_t scroll_view_set_prop(widget_t* widget, const char* name, const value_t* v) {
scroll_view_t* scroll_view = SCROLL_VIEW(widget);
return_value_if_fail(scroll_view != NULL && name != NULL && v != NULL, RET_BAD_PARAMS);
if (tk_str_eq(name, WIDGET_PROP_VIRTUAL_W)) {
scroll_view->virtual_w = value_int(v);
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_VIRTUAL_H)) {
scroll_view->virtual_h = value_int(v);
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_XSLIDABLE)) {
scroll_view->xslidable = value_bool(v);
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_YSLIDABLE)) {
scroll_view->yslidable = value_bool(v);
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_XOFFSET)) {
scroll_view_set_xoffset(scroll_view, value_int(v));
scroll_view_notify_scrolled(scroll_view);
widget_invalidate_force(widget, NULL);
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_YOFFSET)) {
scroll_view_set_yoffset(scroll_view, value_int(v));
scroll_view_notify_scrolled(scroll_view);
widget_invalidate_force(widget, NULL);
return RET_OK;
} else if (tk_str_eq(name, SCROLL_VIEW_X_SPEED_SCALE)) {
scroll_view->xspeed_scale = value_float(v);
return RET_OK;
} else if (tk_str_eq(name, SCROLL_VIEW_Y_SPEED_SCALE)) {
scroll_view->yspeed_scale = value_float(v);
return RET_OK;
} else if (tk_str_eq(name, SCROLL_VIEW_RECURSIVE)) {
return scroll_view_set_recursive(widget, value_bool(v));
} else if (tk_str_eq(name, SCROLL_VIEW_MOVE_TO_PAGE)) {
return scroll_view_set_move_to_page(widget, value_bool(v));
} else if (tk_str_eq(name, SCROLL_VIEW_SNAP_TO_PAGE)) {
return scroll_view_set_snap_to_page(widget, value_bool(v));
} else if (scroll_view->snap_to_page && tk_str_eq(name, WIDGET_PROP_CURR_PAGE)) {
return scroll_view_set_curr_page(widget, value_int(v));
} else if (tk_str_eq(name, SCROLL_VIEW_SLIDE_LIMIT_RATIO)) {
return scroll_view_set_slide_limit_ratio(widget, value_float(v));
}
return RET_NOT_FOUND;
}
static ret_t scroll_view_get_offset(widget_t* widget, xy_t* out_x, xy_t* out_y) {
scroll_view_t* scroll_view = SCROLL_VIEW(widget);
return_value_if_fail(scroll_view != NULL && out_x != NULL && out_y != NULL, RET_BAD_PARAMS);
*out_x = scroll_view->xoffset;
*out_y = scroll_view->yoffset;
return RET_OK;
}
static ret_t scroll_view_get_only_active_children(widget_t* widget, darray_t* all_focusable) {
ret_t ret = RET_OK;
scroll_view_t* scroll_view = SCROLL_VIEW(widget);
return_value_if_fail(widget != NULL && scroll_view != NULL && all_focusable != NULL,
RET_BAD_PARAMS);
if (scroll_view->snap_to_page && scroll_view->move_to_page) {
WIDGET_FOR_EACH_CHILD_BEGIN(widget, iter, i)
if ((scroll_view->xslidable && scroll_view->xoffset <= iter->x &&
iter->x < scroll_view->xoffset + widget->w) ||
(scroll_view->yslidable && scroll_view->yoffset <= iter->y &&
iter->y < scroll_view->yoffset + widget->h)) {
ret = widget_foreach(iter, widget_on_visit_focusable, all_focusable);
if (ret == RET_STOP || ret == RET_DONE) {
return ret;
}
}
WIDGET_FOR_EACH_CHILD_END()
} else {
WIDGET_FOR_EACH_CHILD_BEGIN(widget, iter, i)
ret = widget_foreach(iter, widget_on_visit_focusable, all_focusable);
if (ret == RET_STOP || ret == RET_DONE) {
return ret;
}
WIDGET_FOR_EACH_CHILD_END()
}
return RET_SKIP;
}
static ret_t scroll_view_init(widget_t* widget) {
scroll_view_t* scroll_view = SCROLL_VIEW(widget);
return_value_if_fail(scroll_view != NULL, RET_BAD_PARAMS);
scroll_view->snap_to_page = FALSE;
scroll_view->xspeed_scale = SCROLL_VIEW_DEFAULT_XSPEED_SCALE;
scroll_view->yspeed_scale = SCROLL_VIEW_DEFAULT_YSPEED_SCALE;
scroll_view->fix_end_offset = scroll_view_fix_end_offset_default;
scroll_view->slide_limit_ratio = 1.0;
return RET_OK;
}
static const char* s_scroll_view_clone_properties[] = {
WIDGET_PROP_VIRTUAL_W, WIDGET_PROP_VIRTUAL_H, WIDGET_PROP_XSLIDABLE,
WIDGET_PROP_YSLIDABLE, WIDGET_PROP_XOFFSET, WIDGET_PROP_YOFFSET,
SCROLL_VIEW_X_SPEED_SCALE, SCROLL_VIEW_Y_SPEED_SCALE, SCROLL_VIEW_RECURSIVE,
SCROLL_VIEW_MOVE_TO_PAGE, SCROLL_VIEW_SNAP_TO_PAGE, NULL};
TK_DECL_VTABLE(scroll_view) = {.size = sizeof(scroll_view_t),
.type = WIDGET_TYPE_SCROLL_VIEW,
.scrollable = TRUE,
.clone_properties = s_scroll_view_clone_properties,
.get_parent_vt = TK_GET_PARENT_VTABLE(widget),
.create = scroll_view_create,
.on_event = scroll_view_on_event,
.on_layout_children = scroll_view_on_layout_children,
.on_paint_children = scroll_view_on_paint_children,
.on_add_child = scroll_view_on_add_child,
.find_target = scroll_view_find_target,
.get_offset = scroll_view_get_offset,
.get_only_active_children = scroll_view_get_only_active_children,
.get_prop = scroll_view_get_prop,
.set_prop = scroll_view_set_prop};
widget_t* scroll_view_create(widget_t* parent, xy_t x, xy_t y, wh_t w, wh_t h) {
widget_t* widget = widget_create(parent, TK_REF_VTABLE(scroll_view), x, y, w, h);
return_value_if_fail(scroll_view_init(widget) == RET_OK, NULL);
return widget;
}
ret_t scroll_view_set_virtual_w(widget_t* widget, wh_t w) {
scroll_view_t* scroll_view = SCROLL_VIEW(widget);
return_value_if_fail(scroll_view != NULL, RET_BAD_PARAMS);
scroll_view->virtual_w = w;
return RET_OK;
}
ret_t scroll_view_set_virtual_h(widget_t* widget, wh_t h) {
scroll_view_t* scroll_view = SCROLL_VIEW(widget);
return_value_if_fail(scroll_view != NULL, RET_BAD_PARAMS);
scroll_view->virtual_h = h;
return RET_OK;
}
ret_t scroll_view_set_speed_scale(widget_t* widget, float_t xspeed_scale, float_t yspeed_scale) {
scroll_view_t* scroll_view = SCROLL_VIEW(widget);
return_value_if_fail(scroll_view != NULL, RET_FAIL);
scroll_view->xspeed_scale = xspeed_scale;
scroll_view->yspeed_scale = yspeed_scale;
return RET_OK;
}
ret_t scroll_view_set_offset(widget_t* widget, int32_t xoffset, int32_t yoffset) {
scroll_view_t* scroll_view = SCROLL_VIEW(widget);
return_value_if_fail(scroll_view != NULL, RET_FAIL);
if (scroll_view->snap_to_page) {
xoffset = scroll_view_get_snap_to_page_offset_value(widget, xoffset);
yoffset = scroll_view_get_snap_to_page_offset_value(widget, yoffset);
}
scroll_view_set_xoffset(scroll_view, xoffset);
scroll_view_set_yoffset(scroll_view, yoffset);
widget_invalidate_force(widget, NULL);
return RET_OK;
}
ret_t scroll_view_set_xslidable(widget_t* widget, bool_t xslidable) {
scroll_view_t* scroll_view = SCROLL_VIEW(widget);
return_value_if_fail(scroll_view != NULL, RET_FAIL);
scroll_view->xslidable = xslidable;
return RET_OK;
}
ret_t scroll_view_set_yslidable(widget_t* widget, bool_t yslidable) {
scroll_view_t* scroll_view = SCROLL_VIEW(widget);
return_value_if_fail(scroll_view != NULL, RET_FAIL);
scroll_view->yslidable = yslidable;
return RET_OK;
}
ret_t scroll_view_set_move_to_page(widget_t* widget, bool_t move_to_page) {
scroll_view_t* scroll_view = SCROLL_VIEW(widget);
return_value_if_fail(scroll_view != NULL, RET_FAIL);
scroll_view->move_to_page = move_to_page;
return RET_OK;
}
ret_t scroll_view_set_snap_to_page(widget_t* widget, bool_t snap_to_page) {
scroll_view_t* scroll_view = SCROLL_VIEW(widget);
return_value_if_fail(scroll_view != NULL, RET_FAIL);
scroll_view->snap_to_page = snap_to_page;
if (snap_to_page) {
if (scroll_view->xspeed_scale == SCROLL_VIEW_DEFAULT_XSPEED_SCALE) {
scroll_view->xspeed_scale /= 2;
}
if (scroll_view->yspeed_scale == SCROLL_VIEW_DEFAULT_YSPEED_SCALE) {
scroll_view->yspeed_scale /= 2;
}
}
return RET_OK;
}
ret_t scroll_view_set_recursive_only(widget_t* widget, bool_t recursive) {
scroll_view_t* scroll_view = SCROLL_VIEW(widget);
return_value_if_fail(scroll_view != NULL, RET_FAIL);
scroll_view->recursive = recursive;
return RET_OK;
}
ret_t scroll_view_set_recursive(widget_t* widget, bool_t recursive) {
ret_t ret = RET_OK;
ret = scroll_view_set_recursive_only(widget, recursive);
return_value_if_fail(ret == RET_OK, ret);
return widget_layout(widget);
}
ret_t scroll_view_set_slide_limit_ratio(widget_t* widget, float_t slide_limit_ratio) {
scroll_view_t* scroll_view = SCROLL_VIEW(widget);
return_value_if_fail(scroll_view != NULL, RET_FAIL);
scroll_view->slide_limit_ratio = slide_limit_ratio;
return RET_OK;
}
widget_t* scroll_view_cast(widget_t* widget) {
return_value_if_fail(WIDGET_IS_INSTANCE_OF(widget, scroll_view), NULL);
return widget;
}
|
0 |
repos/awtk/src/ext_widgets
|
repos/awtk/src/ext_widgets/scroll_view/scroll_view.h
|
/**
* File: scroll_view.h
* Author: AWTK Develop Team
* Brief: scroll_view
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-07-03 Li XianJing <[email protected]> created
*
*/
#ifndef TK_SCROLL_VIEW_H
#define TK_SCROLL_VIEW_H
#include "base/widget.h"
#include "base/velocity.h"
#include "base/widget_animator.h"
BEGIN_C_DECLS
typedef ret_t (*scroll_view_fix_end_offset_t)(widget_t* widget);
typedef ret_t (*scroll_view_on_scroll_t)(widget_t* widget, int32_t xoffset, int32_t yoffset);
typedef ret_t (*scroll_view_on_scroll_to_t)(widget_t* widget, int32_t xoffset_end,
int32_t yoffset_end, int32_t duration);
/**
* @class scroll_view_t
* @parent widget_t
* @annotation ["scriptable","design","widget"]
* 滚动视图。
*
* scroll\_view\_t是[widget\_t](widget_t.md)的子类控件，widget\_t的函数均适用于scroll\_view\_t控件。
*
* 在xml中使用"scroll\_view"标签创建滚动视图控件。如：
*
* ```xml
* <list_view x="0" y="30" w="100%" h="-80" item_height="60">
* <scroll_view name="view" x="0" y="0" w="100%" h="100%">
* <list_item style="odd" children_layout="default(rows=1,cols=0)">
* <image draw_type="icon" w="30" image="earth"/>
* <label w="-30" text="1.Hello AWTK !">
* <switch x="r:10" y="m" w="60" h="20"/>
* </label>
* </list_item>
* ...
* </scroll_view>
* </list_view>
* ```
*
* > 滚动视图一般作为列表视图的子控件使用。
*
* > 更多用法请参考：[list\_view\_m.xml](
*https://github.com/zlgopen/awtk/blob/master/design/default/ui/list_view_m.xml)
*
* 在c代码中使用函数scroll\_view\_create创建列表视图控件。如：
*
* ```c
* widget_t* scroll_view = scroll_view_create(win, 0, 0, 0, 0);
* ```
*
* 可用通过style来设置控件的显示风格，如背景颜色和边框颜色等(一般情况不需要)。
*
*/
typedef struct _scroll_view_t {
widget_t widget;
/**
* @property {wh_t} virtual_w
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 虚拟宽度。
*/
wh_t virtual_w;
/**
* @property {wh_t} virtual_h
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 虚拟高度。
*/
wh_t virtual_h;
/**
* @property {int32_t} xoffset
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* x偏移量。
*/
int32_t xoffset;
/**
* @property {int32_t} yoffset
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* y偏移量。
*/
int32_t yoffset;
/**
* @property {float_t} xspeed_scale
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* x偏移速度比例。
*/
float_t xspeed_scale;
/**
* @property {float_t} yspeed_scale
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* y偏移速度比例。
*/
float_t yspeed_scale;
/**
* @property {bool_t} xslidable
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 是否允许x方向滑动。
*/
bool_t xslidable;
/**
* @property {bool_t} yslidable
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 是否允许y方向滑动。
*/
bool_t yslidable;
/**
* @property {bool_t} snap_to_page
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 滚动时offset是否按页面对齐。
*/
bool_t snap_to_page;
/**
* @property {bool_t} move_to_page
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 是否每次翻一页（当 move_to_page 为ture 的时候才有效果，主要用于区分一次翻一页还是一次翻多页）。
*/
bool_t move_to_page;
/**
* @property {bool_t} recursive
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 是否递归查找全部子控件。
*/
bool_t recursive;
/**
* @property {float_t} slide_limit_ratio
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 滑动到极限时可继续滑动区域的占比。
*/
float_t slide_limit_ratio;
/*private*/
point_t down;
bool_t pressed;
bool_t dragged;
int32_t xoffset_end;
int32_t yoffset_end;
int32_t xoffset_save;
int32_t yoffset_save;
int32_t curr_page;
uint32_t max_page;
velocity_t velocity;
widget_animator_t* wa;
scroll_view_fix_end_offset_t fix_end_offset;
widget_on_layout_children_t on_layout_children;
widget_on_paint_children_t on_paint_children;
widget_on_add_child_t on_add_child;
widget_find_target_t find_target;
scroll_view_on_scroll_t on_scroll;
scroll_view_on_scroll_to_t on_scroll_to;
bool_t first_move_after_down;
} scroll_view_t;
/**
* @event {event_t} EVT_SCROLL_START
* 开始滚动事件。
*/
/**
* @event {event_t} EVT_SCROLL_END
* 结束滚动事件。
*/
/**
* @event {event_t} EVT_SCROLL
* 滚动事件。
*/
/**
* @event {event_t} EVT_PAGE_CHANGED
* 页面改变事件。
*/
/**
* @event {event_t} EVT_PAGE_CHANGING
* 页面正在改变。
*/
/**
* @method scroll_view_create
* 创建scroll_view对象
* @annotation ["constructor", "scriptable"]
* @param {widget_t*} parent 父控件
* @param {xy_t} x x坐标
* @param {xy_t} y y坐标
* @param {wh_t} w 宽度
* @param {wh_t} h 高度
*
* @return {widget_t*} 对象。
*/
widget_t* scroll_view_create(widget_t* parent, xy_t x, xy_t y, wh_t w, wh_t h);
/**
* @method scroll_view_cast
* 转换为scroll_view对象(供脚本语言使用)。
* @annotation ["cast", "scriptable"]
* @param {widget_t*} widget scroll_view对象。
*
* @return {widget_t*} scroll_view对象。
*/
widget_t* scroll_view_cast(widget_t* widget);
/**
* @method scroll_view_set_virtual_w
* 设置虚拟宽度。
* @annotation ["scriptable"]
* @param {widget_t*} widget 控件对象。
* @param {wh_t} w 虚拟宽度。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t scroll_view_set_virtual_w(widget_t* widget, wh_t w);
/**
* @method scroll_view_set_virtual_h
* 设置虚拟高度。
* @annotation ["scriptable"]
* @param {widget_t*} widget 控件对象。
* @param {wh_t} h 虚拟高度。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t scroll_view_set_virtual_h(widget_t* widget, wh_t h);
/**
* @method scroll_view_set_xslidable
* 设置是否允许x方向滑动。
* @annotation ["scriptable"]
* @param {widget_t*} widget 控件对象。
* @param {bool_t} xslidable 是否允许滑动。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t scroll_view_set_xslidable(widget_t* widget, bool_t xslidable);
/**
* @method scroll_view_set_yslidable
* 设置是否允许y方向滑动。
* @annotation ["scriptable"]
* @param {widget_t*} widget 控件对象。
* @param {bool_t} yslidable 是否允许滑动。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t scroll_view_set_yslidable(widget_t* widget, bool_t yslidable);
/**
* @method scroll_view_set_snap_to_page
* 设置滚动时offset是否按页面对齐。
* @annotation ["scriptable"]
* @param {widget_t*} widget 控件对象。
* @param {bool_t} snap_to_page 是否按页面对齐。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t scroll_view_set_snap_to_page(widget_t* widget, bool_t snap_to_page);
/**
* @method scroll_view_set_move_to_page
* 设置滚动时是否每次翻一页
* 备注：当 snap_to_page 为ture 的时候才有效果，主要用于区分一次翻一页还是一次翻多页。
* @annotation ["scriptable"]
* @param {widget_t*} widget 控件对象。
* @param {bool_t} move_to_page 是否每次翻一页。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t scroll_view_set_move_to_page(widget_t* widget, bool_t move_to_page);
/**
* @method scroll_view_set_recursive
* 设置是否递归查找全部子控件。
* @annotation ["scriptable"]
* @param {widget_t*} widget 控件对象。
* @param {bool_t} recursive 是否递归查找全部子控件。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t scroll_view_set_recursive(widget_t* widget, bool_t recursive);
/**
* @method scroll_view_set_recursive_only
* 设置是否递归查找全部子控件。(不触发repaint和relayout)。
* @annotation ["scriptable"]
* @param {widget_t*} widget 控件对象。
* @param {bool_t} recursive 是否递归查找全部子控件。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t scroll_view_set_recursive_only(widget_t* widget, bool_t recursive);
/**
* @method scroll_view_set_offset
* 设置偏移量。
* @annotation ["scriptable"]
* @param {widget_t*} widget 控件对象。
* @param {int32_t} xoffset x偏移量。
* @param {int32_t} yoffset y偏移量。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t scroll_view_set_offset(widget_t* widget, int32_t xoffset, int32_t yoffset);
/**
* @method scroll_view_set_speed_scale
* 设置偏移速度比例。
* @annotation ["scriptable"]
* @param {widget_t*} widget 控件对象。
* @param {float_t} xspeed_scale x偏移速度比例。
* @param {float_t} yspeed_scale y偏移速度比例。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t scroll_view_set_speed_scale(widget_t* widget, float_t xspeed_scale, float_t yspeed_scale);
/**
* @method scroll_view_set_slide_limit_ratio
* 设置滑动到极限时可继续滑动区域的占比。
* @annotation ["scriptable"]
* @param {widget_t*} widget 控件对象。
* @param {float_t} slide_limit_ratio 滑动到极限时可继续滑动区域的占比。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t scroll_view_set_slide_limit_ratio(widget_t* widget, float_t slide_limit_ratio);
/**
* @method scroll_view_scroll_to
* 滚动到指定的偏移量。
* @annotation ["scriptable"]
* @param {widget_t*} widget 控件对象。
* @param {int32_t} xoffset_end x偏移量。
* @param {int32_t} yoffset_end y偏移量。
* @param {int32_t} duration 时间(毫秒)。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t scroll_view_scroll_to(widget_t* widget, int32_t xoffset_end, int32_t yoffset_end,
int32_t duration);
/**
* @method scroll_view_scroll_delta_to
* 滚动到指定的偏移量。
* @annotation ["scriptable"]
* @param {widget_t*} widget 控件对象。
* @param {int32_t} xoffset_delta x偏移量。
* @param {int32_t} yoffset_delta y偏移量。
* @param {int32_t} duration 时间(毫秒)。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t scroll_view_scroll_delta_to(widget_t* widget, int32_t xoffset_delta, int32_t yoffset_delta,
int32_t duration);
#define SCROLL_VIEW(widget) ((scroll_view_t*)(scroll_view_cast(WIDGET(widget))))
#define SCROLL_VIEW_RECURSIVE "recursive"
#define SCROLL_VIEW_SNAP_TO_PAGE "snap_to_page"
#define SCROLL_VIEW_MOVE_TO_PAGE "move_to_page"
#define SCROLL_VIEW_X_SPEED_SCALE "xspeed_scale"
#define SCROLL_VIEW_Y_SPEED_SCALE "yspeed_scale"
#define SCROLL_VIEW_SLIDE_LIMIT_RATIO "slide_limit_ratio"
/*public for subclass and runtime type check*/
TK_EXTERN_VTABLE(scroll_view);
END_C_DECLS
#endif /*TK_SCROLL_VIEW_H*/
|
0 |
repos/awtk/src/ext_widgets
|
repos/awtk/src/ext_widgets/scroll_view/scroll_bar.h
|
/**
* File: scroll_bar.h
* Author: AWTK Develop Team
* Brief: scroll_bar
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-07-01 Li XianJing <[email protected]> created
*
*/
#ifndef TK_SCROLL_BAR_H
#define TK_SCROLL_BAR_H
#include "base/widget.h"
#include "base/widget_animator.h"
BEGIN_C_DECLS
/**
* @class scroll_bar_t
* @parent widget_t
* @annotation ["scriptable","design","widget"]
* 滚动条控件。
*
*> 目前只支持垂直滚动。
*
* scroll\_bar\_t是[widget\_t](widget_t.md)的子类控件，widget\_t的函数均适用于scroll\_bar\_t控件。
*
* 在xml中使用"scroll\_bar"或"scroll\_bar\_d"或"scroll\_bar\_m"标签创建滚动条控件。如：
*
* ```xml
* <list_view x="0" y="30" w="100%" h="-80" item_height="60">
* <scroll_view name="view" x="0" y="0" w="100%" h="100%">
* ...
* </scroll_view>
* <scroll_bar_m name="bar" x="right" y="0" w="6" h="100%" value="0"/>
* </list_view>
* ```
*
* > 更多用法请参考：[list\_view\_m.xml](
*https://github.com/zlgopen/awtk/blob/master/design/default/ui/list_view_m.xml)
*
* 在c代码中使用函数scroll\_bar\_create创建列表项控件。如：
*
* ```c
* widget_t* scroll_bar = scroll_bar_create(list_view, 0, 0, 0, 0);
* ```
*
* ```xml
* <style name="default">
* <normal bg_color="#c0c0c0" fg_color="#808080"/>
* <over bg_color="#c0c0c0" fg_color="#808080"/>
* <pressed bg_color="#c0c0c0" fg_color="#808080"/>
* </style>
* ```
*
* > 更多用法请参考：[theme default](
*https://github.com/zlgopen/awtk/blob/master/design/default/styles/default.xml#L350)
*
*/
typedef struct _scroll_bar_t {
widget_t widget;
/**
* @property {int32_t} virtual_size
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 虚拟宽度或高度。
*/
int32_t virtual_size;
/**
* @property {int32_t} value
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 当前的值。
*/
int32_t value;
/**
* @property {int32_t} row
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 行的高度。
*/
int32_t row;
/**
* @property {uint32_t} animator_time
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 翻页滚动动画时间(毫秒)。
*/
uint32_t animator_time;
/**
* @property {uint32_t} scroll_delta
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 每次鼠标滚动值。（缺省值为0，0 则使用鼠标滚动默认值）
*/
uint32_t scroll_delta;
/**
* @property {bool_t} animatable
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 滚动时是否启用动画。
*/
bool_t animatable;
/**
* @property {bool_t} auto_hide
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 是否自动隐藏(仅对mobile风格的滚动条有效)。
*/
bool_t auto_hide;
/**
* @property {bool_t} wheel_scroll
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 设置鼠标滚轮是否滚动(仅对desktop风格的滚动条有效)（垂直滚动条缺省值为TRUE，水平滚动条缺省值为FALSE）。
*/
bool_t wheel_scroll;
/*private*/
bool_t user_wheel_scroll;
widget_t* dragger;
widget_animator_t* wa_value;
widget_animator_t* wa_opactiy;
uint32_t wheel_before_id;
} scroll_bar_t;
/**
* @event {value_change_event_t} EVT_VALUE_WILL_CHANGE
* 值(滚动值)即将改变事件。
*/
/**
* @event {value_change_event_t} EVT_VALUE_CHANGED
* 值(滚动值)改变事件。
*/
/**
* @method scroll_bar_create
* 创建scroll_bar对象
*
* > 根据宏WITH_DESKTOP_STYLE决定创建desktop风格还是mobile风格的滚动条
*
* @annotation ["constructor", "scriptable"]
* @param {widget_t*} parent 父控件
* @param {xy_t} x x坐标
* @param {xy_t} y y坐标
* @param {wh_t} w 宽度
* @param {wh_t} h 高度
*
* @return {widget_t*} 对象。
*/
widget_t* scroll_bar_create(widget_t* parent, xy_t x, xy_t y, wh_t w, wh_t h);
/**
* @method scroll_bar_cast
* 转换为scroll_bar对象(供脚本语言使用)。
* @annotation ["cast", "scriptable"]
* @param {widget_t*} widget scroll_bar对象。
*
* @return {widget_t*} scroll_bar对象。
*/
widget_t* scroll_bar_cast(widget_t* widget);
/**
* @method scroll_bar_create_mobile
* 创建mobile风格的scroll_bar对象
* @annotation ["constructor", "scriptable"]
* @param {widget_t*} parent 父控件
* @param {xy_t} x x坐标
* @param {xy_t} y y坐标
* @param {wh_t} w 宽度
* @param {wh_t} h 高度
*
* @return {widget_t*} 对象。
*/
widget_t* scroll_bar_create_mobile(widget_t* parent, xy_t x, xy_t y, wh_t w, wh_t h);
/**
* @method scroll_bar_create_desktop
* 创建desktop风格的scroll_bar对象
* @annotation ["constructor", "scriptable"]
* @param {widget_t*} parent 父控件
* @param {xy_t} x x坐标
* @param {xy_t} y y坐标
* @param {wh_t} w 宽度
* @param {wh_t} h 高度
*
* @return {widget_t*} 对象。
*/
widget_t* scroll_bar_create_desktop(widget_t* parent, xy_t x, xy_t y, wh_t w, wh_t h);
/**
* @method scroll_bar_set_params
* 设置参数。
* @annotation ["scriptable"]
* @param {widget_t*} widget scroll_bar控件。
* @param {int32_t} virtual_size 虚拟高度。
* @param {int32_t} row 每一行的高度。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t scroll_bar_set_params(widget_t* widget, int32_t virtual_size, int32_t row);
/**
* @method scroll_bar_scroll_to
* 滚动到指定的值。
* @annotation ["scriptable"]
* @param {widget_t*} widget scroll_bar控件。
* @param {int32_t} value 值。
* @param {int32_t} duration 动画持续时间(毫秒)。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t scroll_bar_scroll_to(widget_t* widget, int32_t value, int32_t duration);
/**
* @method scroll_bar_set_value
* 设置值，并触发EVT_VALUE_CHANGED事件。
* @annotation ["scriptable"]
* @param {widget_t*} widget scroll_bar控件。
* @param {int32_t} value 值。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t scroll_bar_set_value(widget_t* widget, int32_t value);
/**
* @method scroll_bar_add_delta
* 在当前的值上增加一个值，并触发EVT_VALUE_CHANGED事件。
* @annotation ["scriptable"]
* @param {widget_t*} widget scroll_bar控件。
* @param {int32_t} delta 值。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t scroll_bar_add_delta(widget_t* widget, int32_t delta);
/**
* @method scroll_bar_scroll_delta
* 在当前的值上增加一个值，并滚动到新的值，并触发EVT_VALUE_CHANGED事件。
* @param {widget_t*} widget scroll_bar控件。
* @param {int32_t} delta 值。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t scroll_bar_scroll_delta(widget_t* widget, int32_t delta);
/**
* @method scroll_bar_set_value_only
* 设置值，但不触发EVT_VALUE_CHANGED事件。
* @annotation ["scriptable"]
* @param {widget_t*} widget scroll_bar控件。
* @param {int32_t} value 值。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t scroll_bar_set_value_only(widget_t* widget, int32_t value);
/**
* @method scroll_bar_set_auto_hide
* 设置auto_hide属性。
*
*>仅对mobile风格的滚动条有效
*
* @annotation ["scriptable"]
* @param {widget_t*} widget scroll_bar控件。
* @param {bool_t} auto_hide 值。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t scroll_bar_set_auto_hide(widget_t* widget, bool_t auto_hide);
/**
* @method scroll_bar_is_mobile
* 判断是否是mobile风格的滚动条。
* @annotation ["scriptable"]
* @param {widget_t*} widget scroll_bar控件。
*
* @return {bool_t} 返回TRUE表示是mobile风格的，否则表示不是mobile风格的。
*/
bool_t scroll_bar_is_mobile(widget_t* widget);
/**
* @method scroll_bar_set_animator_time
* 设置翻页滚动动画时间(毫秒)。
*
* @annotation ["scriptable"]
* @param {widget_t*} widget scroll_bar控件。
* @param {uint32_t} animator_time 时间(毫秒)。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t scroll_bar_set_animator_time(widget_t* widget, uint32_t animator_time);
/**
* @method scroll_bar_hide_by_opacity_animation
* 通过动画隐藏滚动条。
*
* @annotation ["scriptable"]
* @param {widget_t*} widget scroll_bar控件。
* @param {int32_t} duration 动画持续时间(毫秒)。
* @param {int32_t} delay 动画执行时间(毫秒)。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t scroll_bar_hide_by_opacity_animation(widget_t* widget, int32_t duration, int32_t delay);
/**
* @method scroll_bar_show_by_opacity_animation
* 通过动画显示滚动条。
*
* @annotation ["scriptable"]
* @param {widget_t*} widget scroll_bar控件。
* @param {int32_t} duration 动画持续时间(毫秒)。
* @param {int32_t} delay 动画执行时间(毫秒)。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t scroll_bar_show_by_opacity_animation(widget_t* widget, int32_t duration, int32_t delay);
/**
* @method scroll_bar_set_wheel_scroll
* 设置鼠标滚轮是否滚动(仅对desktop风格的滚动条有效)。
*
* @annotation ["scriptable"]
* @param {widget_t*} widget scroll_bar控件。
* @param {bool_t} scroll 是否设置该功能。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t scroll_bar_set_wheel_scroll(widget_t* widget, bool_t scroll);
/**
* @method scroll_bar_set_scroll_delta
* 设置鼠标滚轮幅度(仅对desktop风格的滚动条有效)。
*
* @annotation ["scriptable"]
* @param {widget_t*} widget scroll_bar控件。
* @param {uint32_t} scroll_delta 滚动幅度。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t scroll_bar_set_scroll_delta(widget_t* widget, uint32_t scroll_delta);
/* private */
#define SCROLL_BAR_PROP_IS_MOBILE "is_mobile"
#define SCROLL_BAR_PROP_IS_HORIZON "is_horizon"
#define SCROLL_BAR_PROP_ANIMATOR_TIME "animator_time"
#define SCROLL_BAR_PROP_WHEEL_SCROLL "wheel_scroll"
#define SCROLL_BAR_PROP_SCROLL_DELTA "scroll_delta"
#define SCROLL_BAR(widget) ((scroll_bar_t*)(scroll_bar_cast(WIDGET(widget))))
/*public for subclass and runtime type check*/
TK_EXTERN_VTABLE(scroll_bar_mobile);
TK_EXTERN_VTABLE(scroll_bar_desktop);
END_C_DECLS
#endif /*TK_SCROLL_BAR_H*/
|
0 |
repos/awtk/src/ext_widgets
|
repos/awtk/src/ext_widgets/scroll_view/list_view_h.c
|
/**
* File: list_view_h.h
* Author: AWTK Develop Team
* Brief: list_view_h
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-07-04 Li XianJing <[email protected]> created
*
*/
#include "tkc/mem.h"
#include "tkc/utils.h"
#include "base/layout.h"
#include "scroll_view/list_view_h.h"
#include "scroll_view/scroll_view.h"
static ret_t list_view_h_on_add_child(widget_t* widget, widget_t* child);
static ret_t list_view_h_on_paint_self(widget_t* widget, canvas_t* c) {
return widget_paint_helper(widget, c, NULL, NULL);
}
static ret_t list_view_h_get_prop(widget_t* widget, const char* name, value_t* v) {
list_view_h_t* list_view_h = LIST_VIEW_H(widget);
ENSURE(list_view_h);
return_value_if_fail(widget != NULL && name != NULL && v != NULL, RET_BAD_PARAMS);
if (tk_str_eq(name, WIDGET_PROP_ITEM_WIDTH)) {
value_set_int(v, list_view_h->item_width);
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_SPACING)) {
value_set_int(v, list_view_h->spacing);
return RET_OK;
}
return RET_NOT_FOUND;
}
static ret_t list_view_h_set_prop(widget_t* widget, const char* name, const value_t* v) {
list_view_h_t* list_view_h = LIST_VIEW_H(widget);
ENSURE(list_view_h);
return_value_if_fail(widget != NULL && name != NULL && v != NULL, RET_BAD_PARAMS);
if (tk_str_eq(name, WIDGET_PROP_ITEM_WIDTH)) {
list_view_h->item_width = value_int(v);
return RET_OK;
} else if (tk_str_eq(name, WIDGET_PROP_SPACING)) {
list_view_h->spacing = value_int(v);
return RET_OK;
}
return RET_NOT_FOUND;
}
static ret_t list_view_h_on_event(widget_t* widget, event_t* e) {
ret_t ret = RET_OK;
list_view_h_t* list_view = LIST_VIEW_H(widget);
return_value_if_fail(list_view != NULL, RET_BAD_PARAMS);
switch (e->type) {
case EVT_KEY_DOWN: {
key_event_t* evt = (key_event_t*)e;
if (evt->key == TK_KEY_PAGEDOWN) {
scroll_view_scroll_delta_to(list_view->scroll_view, widget->w, 0, TK_ANIMATING_TIME);
ret = RET_STOP;
} else if (evt->key == TK_KEY_PAGEUP) {
scroll_view_scroll_delta_to(list_view->scroll_view, -widget->w, 0, TK_ANIMATING_TIME);
ret = RET_STOP;
}
break;
}
default:
break;
}
return ret;
}
TK_DECL_VTABLE(list_view_h) = {.type = WIDGET_TYPE_LIST_VIEW_H,
.size = sizeof(list_view_h_t),
.get_parent_vt = TK_GET_PARENT_VTABLE(widget),
.create = list_view_h_create,
.set_prop = list_view_h_set_prop,
.get_prop = list_view_h_get_prop,
.on_event = list_view_h_on_event,
.on_add_child = list_view_h_on_add_child,
.on_paint_self = list_view_h_on_paint_self};
static ret_t list_view_h_on_scroll_view_layout_children(widget_t* widget) {
list_view_h_t* list_view_h = LIST_VIEW_H(widget->parent);
return_value_if_fail(list_view_h != NULL, RET_BAD_PARAMS);
int32_t i = 0;
int32_t x = 0;
int32_t y = 0;
int32_t w = list_view_h->item_width;
int32_t h = widget->h;
int32_t spacing = 0;
int32_t x_margin = 0;
int32_t max_w = 0;
int32_t virtual_w = widget->w;
if (widget->children_layout != NULL) {
children_layouter_layout(widget->children_layout, widget);
if (tk_str_start_with(children_layouter_to_string(widget->children_layout), "list_view")) {
scroll_view_set_xslidable(list_view_h->scroll_view, TRUE);
scroll_view_set_yslidable(list_view_h->scroll_view, FALSE);
return RET_OK;
}
spacing = children_layouter_get_param_int(widget->children_layout, "spacing", 0);
x_margin = children_layouter_get_param_int(widget->children_layout, "x_margin", 0);
} else {
spacing = list_view_h->spacing;
}
if (widget->children != NULL) {
for (i = 0; i < widget->children->size; i++) {
widget_t* iter = (widget_t*)darray_get(widget->children, i);
if (widget->children_layout == NULL) {
widget_move_resize_ex(iter, x, y, w, h, FALSE);
widget_layout(iter);
}
x = iter->x + iter->w + spacing;
max_w = tk_max(max_w, x);
}
}
max_w += x_margin - spacing;
if (max_w > virtual_w) {
virtual_w = max_w;
}
scroll_view_set_virtual_w(list_view_h->scroll_view, virtual_w);
scroll_view_set_xslidable(list_view_h->scroll_view, TRUE);
scroll_view_set_yslidable(list_view_h->scroll_view, FALSE);
return RET_OK;
}
static ret_t list_view_h_on_add_child(widget_t* widget, widget_t* child) {
list_view_h_t* list_view_h = LIST_VIEW_H(widget);
ENSURE(list_view_h);
const char* type = widget_get_type(child);
if (tk_str_eq(type, WIDGET_TYPE_SCROLL_VIEW)) {
scroll_view_t* scroll_view = SCROLL_VIEW(child);
list_view_h->scroll_view = child;
scroll_view->on_layout_children = list_view_h_on_scroll_view_layout_children;
}
return RET_CONTINUE;
}
widget_t* list_view_h_create(widget_t* parent, xy_t x, xy_t y, wh_t w, wh_t h) {
return widget_create(parent, TK_REF_VTABLE(list_view_h), x, y, w, h);
}
ret_t list_view_h_set_item_width(widget_t* widget, int32_t item_width) {
list_view_h_t* list_view_h = LIST_VIEW_H(widget);
ENSURE(list_view_h);
return_value_if_fail(widget != NULL, RET_BAD_PARAMS);
list_view_h->item_width = item_width;
return RET_OK;
}
ret_t list_view_h_set_spacing(widget_t* widget, int32_t spacing) {
list_view_h_t* list_view_h = LIST_VIEW_H(widget);
ENSURE(list_view_h);
return_value_if_fail(widget != NULL, RET_BAD_PARAMS);
list_view_h->spacing = spacing;
return RET_OK;
}
widget_t* list_view_h_cast(widget_t* widget) {
return_value_if_fail(WIDGET_IS_INSTANCE_OF(widget, list_view_h), NULL);
return widget;
}
|
0 |
repos/awtk/src/ext_widgets
|
repos/awtk/src/ext_widgets/scroll_view/children_layouter_list_view.c
|
/**
* File: children_layouter_list_view.c
* Author: AWTK Develop Team
* Brief: children layouter list view
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-05-22 Li XianJing <[email protected]> created
*
*/
#include "tkc/rect.h"
#include "tkc/utils.h"
#include "base/layout.h"
#include "base/widget.h"
#include "tkc/tokenizer.h"
#include "scroll_view/scroll_bar.h"
#include "scroll_view/scroll_view.h"
#include "scroll_view/list_view.h"
#include "scroll_view/list_view_h.h"
#include "scroll_view/children_layouter_list_view.h"
static const char* children_layouter_list_view_to_string(children_layouter_t* layouter) {
char temp[32];
str_t* str = &(layouter->params);
children_layouter_list_view_t* layout = (children_layouter_list_view_t*)layouter;
return_value_if_fail(layout != NULL, NULL);
memset(temp, 0, sizeof(temp));
str_set(str, "list_view(");
str_append(str, temp);
if (layout->item_height) {
tk_snprintf(temp, sizeof(temp) - 1, "item_height=%d,", (int)(layout->item_height));
}
str_append(str, temp);
if (layout->default_item_height) {
tk_snprintf(temp, sizeof(temp) - 1, "default_item_height=%d,",
(int)(layout->default_item_height));
}
str_append(str, temp);
if (layout->x_margin) {
tk_snprintf(temp, sizeof(temp) - 1, "x_margin=%d,", (int)(layout->x_margin));
str_append(str, temp);
}
if (layout->y_margin) {
tk_snprintf(temp, sizeof(temp) - 1, "y_margin=%d,", (int)(layout->y_margin));
str_append(str, temp);
}
if (layout->spacing) {
tk_snprintf(temp, sizeof(temp) - 1, "spacing=%d,", (int)(layout->spacing));
str_append(str, temp);
}
if (layout->cols > 1) {
tk_snprintf(temp, sizeof(temp) - 1, "cols=%d,", (int)(layout->cols));
str_append(str, temp);
}
if (!(layout->keep_disable)) {
str_append(str, "keep_disable=false,");
}
if (layout->keep_invisible) {
str_append(str, "keep_invisible=true,");
}
if (layout->hlayouter) {
str_append(str, "hlayouter=true,");
}
if (layout->animating_time) {
tk_snprintf(temp, sizeof(temp) - 1, "animating_time=%d,", layout->animating_time);
str_append(str, temp);
}
str_trim_right(str, ",");
str_append(str, ")");
return str->str;
}
static ret_t children_layouter_list_view_set_param(children_layouter_t* layouter, const char* name,
const value_t* v) {
int val = value_int(v);
children_layouter_list_view_t* l = (children_layouter_list_view_t*)layouter;
switch (*name) {
case 'x': {
l->x_margin = val;
break;
}
case 'y': {
l->y_margin = val;
break;
}
case 'm': {
l->x_margin = val;
l->y_margin = val;
break;
}
case 's': {
l->spacing = val;
break;
}
case 'i': {
l->item_height = val;
break;
}
case 'd': {
l->default_item_height = val;
break;
}
case 'c': {
l->cols = val;
break;
}
case 'k': {
if (strstr(name, "invisible") != NULL || name[1] == 'i') {
l->keep_invisible = value_bool(v);
} else if (strstr(name, "disable") != NULL || name[1] == 'd') {
l->keep_disable = value_bool(v);
}
break;
}
case 'h': {
if (strstr(name, "layouter") != NULL || name[1] == 'l') {
l->hlayouter = value_bool(v);
}
break;
}
case 'a': {
l->animating_time = (uint32_t)val;
break;
}
default:
break;
}
return RET_OK;
}
static ret_t children_layouter_list_view_get_param(children_layouter_t* layouter, const char* name,
value_t* v) {
children_layouter_list_view_t* l = (children_layouter_list_view_t*)layouter;
switch (*name) {
case 'x': {
value_set_int(v, l->x_margin);
return RET_OK;
}
case 'y': {
value_set_int(v, l->y_margin);
return RET_OK;
}
case 'm': {
value_set_int(v, l->x_margin);
return RET_OK;
}
case 's': {
value_set_int(v, l->spacing);
return RET_OK;
}
case 'i': {
value_set_int(v, l->item_height);
return RET_OK;
}
case 'd': {
value_set_int(v, l->default_item_height);
return RET_OK;
}
case 'c': {
value_set_int(v, l->cols);
return RET_OK;
}
case 'k': {
if (strstr(name, "invisible") != NULL || name[1] == 'i') {
value_set_bool(v, l->keep_invisible);
return RET_OK;
} else if (strstr(name, "disable") != NULL || name[1] == 'd') {
value_set_bool(v, l->keep_disable);
return RET_OK;
}
break;
}
case 'h': {
if (strstr(name, "layouter") != NULL || name[1] == 'l') {
value_set_bool(v, l->hlayouter);
return RET_OK;
}
break;
}
case 'a': {
value_set_uint32(v, l->animating_time);
return RET_OK;
}
default: {
assert(!"not support param");
break;
}
}
return RET_FAIL;
}
static ret_t children_layouter_list_view_for_list_view_children_layout_h(
darray_t* children_for_layout, int32_t item_height, int32_t default_item_height) {
int32_t i = 0;
int32_t h = 0;
int32_t n = 0;
widget_t** children = NULL;
return_value_if_fail(children_for_layout != NULL, RET_BAD_PARAMS);
n = children_for_layout->size;
children = (widget_t**)children_for_layout->elms;
for (i = 0; i < n; i++) {
widget_t* iter = children[i];
if (iter->w == 0) {
iter->w = iter->parent->w;
}
if (iter->h == 0) {
iter->h = item_height;
}
if (iter->self_layout != NULL || iter->auto_adjust_size) {
widget_layout(iter);
}
h = item_height;
if (h <= 0) {
h = iter->h;
}
if (h <= 0) {
h = default_item_height;
}
widget_resize(iter, iter->w, h);
}
return RET_OK;
}
static ret_t children_layouter_list_view_for_list_view_children_layout_w_with_animation(
children_layouter_t* layouter, darray_t* children_for_layout, int32_t w) {
ret_t ret = RET_OK;
int32_t i = 0;
int32_t y = 0;
uint32_t cols = 0;
char animate_y[16] = {0};
widget_t** children = NULL;
children_layouter_list_view_t* l = (children_layouter_list_view_t*)layouter;
return_value_if_fail(l != NULL && children_for_layout != NULL, RET_BAD_PARAMS);
y = l->y_margin;
cols = l->cols <= 1 ? 1 : l->cols;
children = (widget_t**)children_for_layout->elms;
tk_snprintf(animate_y, sizeof(animate_y), "%s%s", WIDGET_PROP_ANIMATE_PREFIX, WIDGET_PROP_Y);
if (cols <= 1) {
for (i = 0; i < children_for_layout->size; i++) {
widget_t* iter = children[i];
widget_move_resize(iter, l->x_margin, iter->y, w, iter->h);
widget_set_prop_int(iter, WIDGET_PROP_ANIMATE_ANIMATING_TIME, l->animating_time);
widget_set_prop_int(iter, animate_y, y);
widget_layout_children(iter);
y += (iter->h + l->spacing);
}
} else {
ret = RET_FAIL;
log_warn("Remove animation of multiple columns is not supported!\n");
}
return ret;
}
static ret_t children_layouter_list_view_for_list_view_children_layout_w(
children_layouter_t* layouter, darray_t* children_for_layout, int32_t scroll_view_w) {
int32_t i = 0;
int32_t w = 0;
int32_t x = 0;
int32_t y = 0;
uint32_t cols = 0;
widget_t* win = NULL;
widget_t** children = NULL;
children_layouter_list_view_t* l = (children_layouter_list_view_t*)layouter;
return_value_if_fail(l != NULL && children_for_layout != NULL, RET_BAD_PARAMS);
x = l->x_margin;
y = l->y_margin;
cols = l->cols <= 1 ? 1 : l->cols;
w = scroll_view_w - 2 * l->x_margin;
children = (widget_t**)children_for_layout->elms;
if (children_for_layout->size > 0 && children != NULL) {
win = widget_get_window(children[0]);
if (cols <= 1) {
if (l->animating_time && win && !win->loading) {
children_layouter_list_view_for_list_view_children_layout_w_with_animation(
layouter, children_for_layout, w);
} else {
for (i = 0; i < children_for_layout->size; i++) {
widget_t* iter = children[i];
widget_move_resize(iter, x, y, w, iter->h);
widget_layout_children(iter);
y += (iter->h + l->spacing);
}
}
} else {
int32_t j = 0;
int32_t n = 0;
int32_t h = 0;
int32_t size = children_for_layout->size;
uint32_t rows = (size % cols) ? (size / cols) + 1 : (size / cols);
w = (w - (cols - 1) * l->spacing) / cols;
for (i = 0; i < rows && n < size; i++) {
h = 0;
for (j = 0; j < cols && n < size; j++, n++) {
widget_t* iter = children[n];
int32_t tmp_x = x + j * (w + l->spacing);
widget_move_resize(iter, tmp_x, y, w, iter->h);
widget_layout_children(iter);
h = tk_max(h, iter->h);
}
y += (h + l->spacing);
}
}
}
return RET_OK;
}
static int32_t children_layouter_list_view_for_list_view_get_virtual_h(
darray_t* children_for_layout, uint32_t cols, int32_t y_margin, int32_t spacing) {
int32_t i = 0;
widget_t** children = NULL;
int32_t virtual_h = y_margin;
return_value_if_fail(children_for_layout != NULL, 0);
children = (widget_t**)children_for_layout->elms;
if (cols <= 1) {
for (i = 0; i < children_for_layout->size; i++) {
virtual_h += (children[i]->h + (i == 0 ? 0 : spacing));
}
} else {
int32_t j = 0;
int32_t h = 0;
int32_t num = 0;
int32_t n = children_for_layout->size;
uint32_t rows = (n % cols) ? (n / cols) + 1 : (n / cols);
for (i = 0; i < rows && num < children_for_layout->size; i++) {
for (j = 0, h = 0; j < cols && num < children_for_layout->size; j++, num++) {
h = tk_max(h, children[num]->h);
}
virtual_h += (h + (i == 0 ? 0 : spacing));
}
}
virtual_h += y_margin;
return virtual_h;
}
static int32_t children_layouter_list_view_for_list_view_get_scroll_view_w(list_view_t* list_view,
widget_t* scroll_view,
int32_t virtual_h) {
int32_t scroll_view_w = 0;
widget_t* scroll_bar = NULL;
return_value_if_fail(list_view != NULL && scroll_view != NULL, 0);
scroll_bar = list_view->scroll_bar;
if (list_view->floating_scroll_bar) {
scroll_view_w = scroll_view->w;
} else if (scroll_bar == NULL || scroll_bar_is_mobile(scroll_bar) ||
(!scroll_bar_is_mobile(scroll_bar) && list_view->auto_hide_scroll_bar &&
scroll_view->h >= virtual_h)) {
scroll_view_w = list_view->widget.w;
} else {
scroll_view_w = list_view->widget.w - scroll_bar->w;
}
return scroll_view_w;
}
static ret_t children_layouter_list_view_for_list_view_set_scroll_view_info(
children_layouter_t* layouter, widget_t* widget, widget_t* scroll_bar, int32_t virtual_h) {
int32_t yoffset = 0;
scroll_view_t* scroll_view = SCROLL_VIEW(widget);
children_layouter_list_view_t* l = (children_layouter_list_view_t*)layouter;
return_value_if_fail(scroll_view != NULL && l != NULL, RET_BAD_PARAMS);
if (scroll_bar_is_mobile(scroll_bar)) {
scroll_view_set_yslidable(widget, TRUE);
}
scroll_view_set_xslidable(widget, FALSE);
scroll_view_set_virtual_h(widget, virtual_h);
if (!scroll_view->dragged && scroll_view->wa == NULL) {
scroll_view->xoffset = 0;
yoffset = scroll_view->yoffset;
if (widget->h >= virtual_h) {
yoffset = 0;
}
if (yoffset + widget->h > scroll_view->virtual_h) {
yoffset = tk_max(scroll_view->virtual_h - widget->h, 0);
}
if (l->animating_time) {
char animate_yoffset[16] = {0};
tk_snprintf(animate_yoffset, sizeof(animate_yoffset), "%s%s", WIDGET_PROP_ANIMATE_PREFIX,
WIDGET_PROP_YOFFSET);
widget_set_prop_int(widget, WIDGET_PROP_ANIMATE_ANIMATING_TIME, l->animating_time);
widget_set_prop_int(widget, animate_yoffset, yoffset);
} else {
scroll_view->yoffset = yoffset;
}
if (scroll_view->on_scroll) {
scroll_view->on_scroll(widget, scroll_view->xoffset, scroll_view->yoffset);
}
}
return RET_OK;
}
static ret_t children_layouter_list_view_for_list_view_set_scroll_bar_info(widget_t* widget,
list_view_t* list_view,
widget_t* scroll_view,
int32_t virtual_h,
int32_t item_height) {
scroll_view_t* ascroll_view = SCROLL_VIEW(scroll_view);
return_value_if_fail(list_view != NULL && ascroll_view != NULL, RET_BAD_PARAMS);
scroll_bar_set_params(widget, virtual_h, item_height);
if (scroll_bar_is_mobile(widget)) {
if (widget->h > virtual_h) {
scroll_bar_set_params(widget, widget->h, item_height);
}
if (SCROLL_BAR(widget)->auto_hide && !ascroll_view->dragged && ascroll_view->wa == NULL) {
widget_set_sensitive(widget, FALSE);
widget_set_visible_only(widget, FALSE);
}
} else {
if (scroll_view->h >= virtual_h) {
scroll_bar_set_value(widget, 0);
if (list_view->auto_hide_scroll_bar) {
widget_set_sensitive(widget, FALSE);
widget_set_visible_only(widget, FALSE);
} else {
widget_set_sensitive(widget, FALSE);
widget_set_visible_only(widget, TRUE);
}
} else {
if (list_view->auto_hide_scroll_bar && list_view->floating_scroll_bar) {
widget_set_sensitive(widget, list_view->is_over);
widget_set_visible_only(widget, list_view->is_over);
} else {
widget_set_sensitive(widget, TRUE);
widget_set_visible_only(widget, TRUE);
}
}
}
return RET_OK;
}
static ret_t children_layouter_list_view_for_list_view_layout(children_layouter_t* layouter,
widget_t* widget) {
int32_t virtual_h = 0;
int32_t item_height = 0;
list_view_t* list_view = NULL;
int32_t default_item_height = 0;
scroll_view_t* scroll_view = SCROLL_VIEW(widget);
children_layouter_list_view_t* l = (children_layouter_list_view_t*)layouter;
return_value_if_fail(widget != NULL && scroll_view != NULL && l != NULL, RET_BAD_PARAMS);
list_view = LIST_VIEW(widget->parent);
return_value_if_fail(list_view != NULL, RET_BAD_PARAMS);
item_height = list_view->item_height ? list_view->item_height : l->item_height;
default_item_height =
list_view->default_item_height ? list_view->default_item_height : l->default_item_height;
if (widget->children != NULL) {
int32_t scroll_view_w = 0;
darray_t children_for_layout;
uint32_t cols = l->cols <= 1 ? 1 : l->cols;
widget_layout_floating_children(widget);
darray_init(&children_for_layout, widget->children->size, NULL, NULL);
return_value_if_fail(
widget_get_children_for_layout(widget, &children_for_layout, l->keep_disable,
l->keep_invisible) == RET_OK,
RET_BAD_PARAMS);
children_layouter_list_view_for_list_view_children_layout_h(&children_for_layout, item_height,
default_item_height);
virtual_h = children_layouter_list_view_for_list_view_get_virtual_h(&children_for_layout, cols,
l->y_margin, l->spacing);
scroll_view_w =
children_layouter_list_view_for_list_view_get_scroll_view_w(list_view, widget, virtual_h);
widget_move_resize_ex(widget, widget->x, widget->y, scroll_view_w, widget->h, FALSE);
children_layouter_list_view_for_list_view_children_layout_w(layouter, &children_for_layout,
scroll_view_w);
darray_deinit(&(children_for_layout));
}
children_layouter_list_view_for_list_view_set_scroll_view_info(layouter, widget,
list_view->scroll_bar, virtual_h);
if (list_view->scroll_bar != NULL) {
children_layouter_list_view_for_list_view_set_scroll_bar_info(
list_view->scroll_bar, list_view, widget, virtual_h,
item_height > 0 ? item_height : default_item_height);
}
return RET_OK;
}
static ret_t children_layouter_list_view_for_list_view_h_layout(children_layouter_t* layouter,
widget_t* widget) {
int32_t virtual_w = 0;
list_view_h_t* list_view_h = NULL;
scroll_view_t* scroll_view = SCROLL_VIEW(widget);
children_layouter_list_view_t* l = (children_layouter_list_view_t*)layouter;
return_value_if_fail(widget != NULL && scroll_view != NULL && l != NULL, RET_BAD_PARAMS);
list_view_h = LIST_VIEW_H(widget->parent);
return_value_if_fail(list_view_h != NULL, RET_BAD_PARAMS);
if (widget->children != NULL && l->cols > 0) {
int32_t i = 0;
int32_t nw = 0;
int32_t x = l->x_margin;
int32_t y = l->y_margin;
uint32_t cols = l->cols;
widget_t** children = NULL;
darray_t children_for_layout;
int32_t spacing = l->spacing;
int32_t h = widget->h - l->y_margin * 2;
int32_t w = widget->w - l->x_margin * 2;
int32_t oy = l->y_margin - l->item_height - spacing;
uint32_t item_w = (w - (cols - 1) * spacing) / cols;
widget_layout_floating_children(widget);
darray_init(&children_for_layout, widget->children->size, NULL, NULL);
return_value_if_fail(
widget_get_children_for_layout(widget, &children_for_layout, l->keep_disable,
l->keep_invisible) == RET_OK,
RET_BAD_PARAMS);
children = (widget_t**)(children_for_layout.elms);
y = oy;
virtual_w = w;
for (i = 0; i < children_for_layout.size; i++) {
widget_t* iter = children[i];
if (i % cols == 0) {
x = l->x_margin + w * nw;
y += l->item_height + spacing;
if (y + l->item_height + spacing > h) {
nw++;
x += w;
virtual_w += w;
y = oy + l->item_height + spacing;
}
} else {
x += item_w + spacing;
}
widget_move_resize(iter, x, y, item_w, l->item_height);
widget_layout(iter);
}
scroll_view_set_virtual_w(list_view_h->scroll_view, virtual_w);
darray_deinit(&children_for_layout);
}
return RET_OK;
}
static ret_t children_layouter_list_view_layout(children_layouter_t* layouter, widget_t* widget) {
children_layouter_list_view_t* l = (children_layouter_list_view_t*)layouter;
return_value_if_fail(l != NULL, RET_BAD_PARAMS);
if (l->hlayouter) {
return children_layouter_list_view_for_list_view_h_layout(layouter, widget);
} else {
return children_layouter_list_view_for_list_view_layout(layouter, widget);
}
}
static bool_t children_layouter_list_view_is_valid(children_layouter_t* layouter) {
return TRUE;
}
static ret_t children_layouter_list_view_destroy(children_layouter_t* layouter) {
children_layouter_list_view_t* l = (children_layouter_list_view_t*)layouter;
return_value_if_fail(l != NULL, RET_BAD_PARAMS);
str_reset(&(layouter->params));
TKMEM_FREE(l);
return RET_OK;
}
static children_layouter_t* children_layouter_list_view_clone(children_layouter_t* layouter) {
children_layouter_list_view_t* l = TKMEM_ZALLOC(children_layouter_list_view_t);
return_value_if_fail(l != NULL, NULL);
memcpy(l, layouter, sizeof(*l));
str_init(&(l->layouter.params), 0);
str_set(&(l->layouter.params), layouter->params.str);
return (children_layouter_t*)l;
}
static const children_layouter_vtable_t s_children_layouter_list_view_vtable = {
.type = CHILDREN_LAYOUTER_LIST_VIEW,
.clone = children_layouter_list_view_clone,
.to_string = children_layouter_list_view_to_string,
.get_param = children_layouter_list_view_get_param,
.set_param = children_layouter_list_view_set_param,
.layout = children_layouter_list_view_layout,
.is_valid = children_layouter_list_view_is_valid,
.destroy = children_layouter_list_view_destroy};
children_layouter_t* children_layouter_list_view_create(void) {
children_layouter_t* l = NULL;
children_layouter_list_view_t* layouter = NULL;
layouter = TKMEM_ZALLOC(children_layouter_list_view_t);
return_value_if_fail(layouter != NULL, NULL);
l = (children_layouter_t*)layouter;
layouter->keep_disable = TRUE;
str_init(&(l->params), 0);
l->vt = &s_children_layouter_list_view_vtable;
return (children_layouter_t*)layouter;
}
|
0 |
repos/awtk/src/ext_widgets
|
repos/awtk/src/ext_widgets/scroll_view/list_view.h
|
/**
* File: list_view.h
* Author: AWTK Develop Team
* Brief: list_view
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-07-04 Li XianJing <[email protected]> created
*
*/
#ifndef TK_LIST_VIEW_H
#define TK_LIST_VIEW_H
#include "base/widget.h"
BEGIN_C_DECLS
/**
* @class list_view_t
* @parent widget_t
* @annotation ["scriptable","design","widget"]
* 列表视图控件。
*
* 列表视图控件是一个可以垂直滚动的列表控件。
*
* 如果不需要滚动，可以用view控件配置适当的layout参数作为列表控件。
*
* 列表视图中的列表项可以固定高度，也可以使用不同高度。请参考[变高列表项](
*https://github.com/zlgopen/awtk/blob/master/design/default/ui/list_view_vh.xml)
*
* 列表视图控件的中可以有滚动条，也可以没有滚动条。
* 可以使用移动设备风格的滚动条，也可以使用桌面风格的滚动条。
*
* list\_view\_t是[widget\_t](widget_t.md)的子类控件，widget\_t的函数均适用于list\_view\_t控件。
*
* 在xml中使用"list\_view"标签创建列表视图控件。如：
*
* ```xml
* <list_view x="0" y="30" w="100%" h="-80" item_height="60">
* <scroll_view name="view" x="0" y="0" w="100%" h="100%">
* <list_item style="odd" children_layout="default(rows=1,cols=0)">
* <image draw_type="icon" w="30" image="earth"/>
* <label w="-30" text="1.Hello AWTK !">
* <switch x="r:10" y="m" w="60" h="20"/>
* </label>
* </list_item>
* ...
* </scroll_view>
* </list_view>
* ```
*
* > 注意：列表项不是作为列表视图控件的直接子控件，而是作为滚动视图的子控件。
*
*
* > 更多用法请参考：[list\_view\_m.xml](
*https://github.com/zlgopen/awtk/blob/master/design/default/ui/list_view_m.xml)
*
* 在c代码中使用函数list\_view\_create创建列表视图控件。如：
*
* ```c
* widget_t* list_view = list_view_create(win, 0, 0, 0, 0);
* ```
*
* 用代码构造列表视图是比较繁琐的事情，最好用XML来构造。
* 如果需要动态修改，可以使用widget\_clone来增加列表项，使用widget\_remove\_child来移出列表项。
*
* 可用通过style来设置控件的显示风格，如背景颜色和边框颜色等(一般情况不需要)。
*
* 备注：list_view 下的 scroll_view 控件不支持遍历所有子控件的效果。
*
* 下面是针对 scroll_bar_d （桌面版）有效果，scroll_bar_m（移动版）没有效果。
* 如果 floating_scroll_bar 属性为 TRUE 和 auto_hide_scroll_bar 属性为 TRUE， 如果 scroll_view 的高比虚拟高要小的话，鼠标在 list_view 上滚动条才显示，鼠标移开的就自动隐藏，scroll_view 宽为控件宽度。
* 如果 floating_scroll_bar 属性为 TRUE 和 auto_hide_scroll_bar 属性为 FALSE ，如果 scroll_view 的高比虚拟高要大的话，滚动条变成不可见，如果 scroll_view 的高比虚拟高要小的话，滚动条固定显示（不管鼠标是否悬停），scroll_view 宽为控件宽度。
* 如果 floating_scroll_bar 属性为 FALSE 和 auto_hide_scroll_bar 属性为 FALSE，如果 scroll_view 的高比虚拟高要大的话，滚动条变成不可用（滚动条固定显示，不管鼠标是否悬停），scroll_view 宽不会变。
* 如果 floating_scroll_bar 属性为 FALSE 和 auto_hide_scroll_bar 属性为 TRUE，如果 scroll_view 的高比虚拟高要大的话，滚动条变成不可见，scroll_view 宽会合并原来滚动条的宽，如果 scroll_view 的高比虚拟高要小的话，滚动条固定显示（不管鼠标是否悬停），scroll_view 宽会变为 list_view 宽度减去滚动条宽度。
*
*/
typedef struct _list_view_t {
widget_t widget;
/**
* @property {int32_t} item_height
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 列表项的高度。如果 item_height > 0，所有列表项使用固定高度，否则使用列表项自身的高度。
*/
int32_t item_height;
/**
* @property {int32_t} default_item_height
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 列表项的缺省高度。如果item_height <= 0 而且列表项自身的高度 <= 0，则使用缺省高度。
*/
int32_t default_item_height;
/**
* @property {bool_t} auto_hide_scroll_bar
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 如果不需要滚动条时，自动隐藏滚动条。
*/
bool_t auto_hide_scroll_bar;
/**
* @property {bool_t} floating_scroll_bar
* @annotation ["set_prop","get_prop","readable","persitent","design","scriptable"]
* 滚动条是否悬浮在 scroll_view 上面
*/
bool_t floating_scroll_bar;
/*private*/
bool_t is_over;
widget_t* scroll_view;
widget_t* scroll_bar;
} list_view_t;
/**
* @method list_view_create
* 创建list_view对象
* @annotation ["constructor", "scriptable"]
* @param {widget_t*} parent 父控件
* @param {xy_t} x x坐标
* @param {xy_t} y y坐标
* @param {wh_t} w 宽度
* @param {wh_t} h 高度
*
* @return {widget_t*} 对象。
*/
widget_t* list_view_create(widget_t* parent, xy_t x, xy_t y, wh_t w, wh_t h);
/**
* @method list_view_set_item_height
* 设置列表项的高度。
* @annotation ["scriptable"]
* @param {widget_t*} widget 控件对象。
* @param {int32_t} item_height 列表项的高度。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t list_view_set_item_height(widget_t* widget, int32_t item_height);
/**
* @method list_view_set_default_item_height
* 设置列表项的缺省高度。
* @annotation ["scriptable"]
* @param {widget_t*} widget 控件对象。
* @param {int32_t} default_item_height 列表项的高度。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t list_view_set_default_item_height(widget_t* widget, int32_t default_item_height);
/**
* @method list_view_set_auto_hide_scroll_bar
* 设置是否自动隐藏滚动条。
* @annotation ["scriptable"]
* @param {widget_t*} widget 控件对象。
* @param {bool_t} auto_hide_scroll_bar 是否自动隐藏滚动条。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t list_view_set_auto_hide_scroll_bar(widget_t* widget, bool_t auto_hide_scroll_bar);
/**
* @method list_view_set_floating_scroll_bar
* 设置滚动条是否悬浮在 scroll_view 上面。
* @annotation ["scriptable"]
* @param {widget_t*} widget 控件对象。
* @param {bool_t} floating_scroll_bar 滚动条是否悬浮在 scroll_view 上面。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t list_view_set_floating_scroll_bar(widget_t* widget, bool_t floating_scroll_bar);
/**
* @method list_view_cast
* 转换为list_view对象(供脚本语言使用)。
* @annotation ["cast", "scriptable"]
* @param {widget_t*} widget list_view对象。
*
* @return {widget_t*} list_view对象。
*/
widget_t* list_view_cast(widget_t* widget);
/**
* @method list_view_reinit
* list_view重新初始化。
* @annotation ["scriptable"]
* @param {widget_t*} widget list_view对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t list_view_reinit(widget_t* widget);
#define LIST_VIEW(widget) ((list_view_t*)(list_view_cast(WIDGET(widget))))
#define LIST_VIEW_PROP_FLOATING_SCROLL_BAR "floating_scroll_bar"
/*public for subclass and runtime type check*/
TK_EXTERN_VTABLE(list_view);
END_C_DECLS
#endif /*TK_LIST_VIEW_H*/
|
0 |
repos/awtk/src/ext_widgets
|
repos/awtk/src/ext_widgets/scroll_view/list_item.h
|
/**
* File: list_item.h
* Author: AWTK Develop Team
* Brief: list_item
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-07-05 Li XianJing <[email protected]> created
*
*/
#ifndef TK_LIST_ITEM_H
#define TK_LIST_ITEM_H
#include "base/widget.h"
BEGIN_C_DECLS
/**
* @class list_item_t
* @parent widget_t
* @annotation ["scriptable","design","widget"]
* 列表项控件。
*
* 列表项控件是一个简单的容器控件，一般作为列表视图中滚动视图的子控件。
*
* list\_item\_t是[widget\_t](widget_t.md)的子类控件，widget\_t的函数均适用于list\_item\_t控件。
*
* 在xml中使用"list\_item"标签创建列表项控件。如：
*
* ```xml
* <list_view x="0" y="30" w="100%" h="-80" item_height="60">
* <scroll_view name="view" x="0" y="0" w="100%" h="100%">
* <list_item style="odd" children_layout="default(rows=1,cols=0)">
* <image draw_type="icon" w="30" image="earth"/>
* <label w="-30" text="1.Hello AWTK !">
* <switch x="r:10" y="m" w="60" h="20"/>
* </label>
* </list_item>
* ...
* </scroll_view>
* </list_view>
* ```
*
* > 更多用法请参考：[list\_view\_m.xml](
*https://github.com/zlgopen/awtk/blob/master/design/default/ui/list_view_m.xml)
*
* 在c代码中使用函数list\_item\_create创建列表项控件。如：
*
* ```c
* widget_t* list_item = list_item_create(scroll_view, 0, 0, 0, 0);
* ```
*
* > 列表项控件大小一般由列表控制，不需指定xywh参数。
*
* 可以用style来实现可点击或不可点击的效果。如：
*
* ```xml
* <style name="odd_clickable" border_color="#a0a0a0" border="bottom" text_color="black">
* <normal bg_color="#f5f5f5" />
* <pressed bg_color="#c0c0c0" />
* <over bg_color="#f5f5f5" />
* </style>
* ```
*
* > 更多用法请参考：[theme default](
*https://github.com/zlgopen/awtk/blob/master/design/default/styles/default.xml#L372)
*
*/
typedef struct _list_item_t {
widget_t widget;
/*private*/
int32_t timer_id;
bool_t dragged;
bool_t pressed;
bool_t downed;
point_t down;
} list_item_t;
/**
* @event {pointer_event_t} EVT_CLICK
* 点击事件。
*/
/**
* @method list_item_create
* @annotation ["constructor", "scriptable"]
* 创建list_item对象
* @param {widget_t*} parent 父控件
* @param {xy_t} x x坐标
* @param {xy_t} y y坐标
* @param {wh_t} w 宽度
* @param {wh_t} h 高度
*
* @return {widget_t*} 对象。
*/
widget_t* list_item_create(widget_t* parent, xy_t x, xy_t y, wh_t w, wh_t h);
/**
* @method list_item_cast
* 转换为list_item对象(供脚本语言使用)。
* @annotation ["cast", "scriptable"]
* @param {widget_t*} widget list_item对象。
*
* @return {widget_t*} list_item对象。
*/
widget_t* list_item_cast(widget_t* widget);
#define LIST_ITEM(widget) ((list_item_t*)(list_item_cast(WIDGET(widget))))
/*public for subclass and runtime type check*/
TK_EXTERN_VTABLE(list_item);
#define TK_LIST_ITEM_STYLE_ODD "odd"
#define TK_LIST_ITEM_STYLE_EVEN "even"
#define TK_LIST_ITEM_STYLE_ODD_CLICKABLE "odd_clickable"
#define TK_LIST_ITEM_STYLE_EVEN_CLICKABLE "even_clickable"
END_C_DECLS
#endif /*TK_LIST_ITEM_H*/
|
0 |
repos/awtk/src/ext_widgets
|
repos/awtk/src/ext_widgets/scroll_view/list_item.c
|
/**
* File: list_item.h
* Author: AWTK Develop Team
* Brief: list_item
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-07-05 Li XianJing <[email protected]> created
*
*/
#include "tkc/mem.h"
#include "base/timer.h"
#include "scroll_view/list_item.h"
static ret_t list_item_on_paint_self(widget_t* widget, canvas_t* c) {
return widget_paint_helper(widget, c, NULL, NULL);
}
static ret_t list_item_on_parent_pointer_up(void* ctx, event_t* e) {
list_item_t* list_item = LIST_ITEM(ctx);
return_value_if_fail(list_item != NULL, RET_BAD_PARAMS);
list_item->dragged = FALSE;
list_item->pressed = FALSE;
list_item->downed = FALSE;
return RET_REMOVE;
}
static ret_t list_item_on_detach_parent(widget_t* widget, widget_t* parent) {
return_value_if_fail(widget != NULL && parent != NULL, RET_BAD_PARAMS);
widget_off_by_func(parent, EVT_POINTER_UP, list_item_on_parent_pointer_up, widget);
return RET_OK;
}
static ret_t list_item_on_timer(const timer_info_t* info) {
widget_t* widget = WIDGET(info->ctx);
list_item_t* list_item = LIST_ITEM(widget);
return_value_if_fail(widget != NULL && list_item != NULL, RET_BAD_PARAMS);
if (!list_item->dragged) {
widget_set_state(widget, WIDGET_STATE_PRESSED);
}
list_item->timer_id = TK_INVALID_ID;
return RET_REMOVE;
}
static ret_t list_item_remove_timer(widget_t* widget) {
list_item_t* list_item = LIST_ITEM(widget);
return_value_if_fail(list_item != NULL, RET_BAD_PARAMS);
if (list_item->timer_id != TK_INVALID_ID) {
timer_remove(list_item->timer_id);
list_item->timer_id = TK_INVALID_ID;
}
return RET_OK;
}
static ret_t list_item_on_event(widget_t* widget, event_t* e) {
ret_t ret = RET_OK;
uint16_t type = e->type;
list_item_t* list_item = LIST_ITEM(widget);
return_value_if_fail(list_item != NULL, RET_BAD_PARAMS);
switch (type) {
case EVT_POINTER_DOWN: {
pointer_event_t* evt = (pointer_event_t*)e;
list_item->downed = TRUE;
list_item->down.x = evt->x;
list_item->down.y = evt->y;
list_item->pressed = TRUE;
widget_grab(widget->parent, widget);
list_item->timer_id = timer_add(list_item_on_timer, widget, 30);
widget_invalidate_force(widget, NULL);
widget_off_by_func(widget->parent, EVT_POINTER_UP, list_item_on_parent_pointer_up, widget);
widget_on(widget->parent, EVT_POINTER_UP, list_item_on_parent_pointer_up, widget);
break;
}
case EVT_POINTER_DOWN_ABORT: {
list_item->dragged = FALSE;
list_item->pressed = FALSE;
list_item->downed = FALSE;
widget_ungrab(widget->parent, widget);
list_item_remove_timer(widget);
widget_invalidate_force(widget, NULL);
widget_set_state(widget, WIDGET_STATE_NORMAL);
break;
}
case EVT_POINTER_UP: {
list_item_remove_timer(widget);
widget_invalidate_force(widget, NULL);
widget_set_state(widget, WIDGET_STATE_NORMAL);
widget_ungrab(widget->parent, widget);
if (!list_item->dragged && list_item->pressed) {
pointer_event_t evt = *(pointer_event_t*)e;
evt.e = event_init(EVT_CLICK, widget);
evt.e.size = sizeof(pointer_event_t);
ret = widget_dispatch(widget, (event_t*)&evt);
}
list_item->dragged = FALSE;
list_item->pressed = FALSE;
list_item->downed = FALSE;
break;
}
case EVT_POINTER_MOVE: {
pointer_event_t* evt = (pointer_event_t*)e;
uint32_t dy = tk_abs(evt->y - list_item->down.y);
if (list_item->downed && evt->pressed && dy > TK_DRAG_THRESHOLD) {
list_item->dragged = TRUE;
list_item->pressed = FALSE;
widget_ungrab(widget->parent, widget);
list_item_remove_timer(widget);
widget_set_state(widget, WIDGET_STATE_NORMAL);
}
break;
}
case EVT_POINTER_LEAVE:
list_item_remove_timer(widget);
widget_set_state(widget, WIDGET_STATE_NORMAL);
break;
case EVT_POINTER_ENTER:
if (list_item->dragged) {
widget_set_state(widget, WIDGET_STATE_NORMAL);
} else {
widget_set_state(widget, WIDGET_STATE_OVER);
}
break;
default:
break;
}
return ret;
}
static ret_t list_item_on_destroy(widget_t* widget) {
list_item_t* list_item = LIST_ITEM(widget);
return_value_if_fail(list_item != NULL, RET_BAD_PARAMS);
if (list_item->timer_id != TK_INVALID_ID) {
timer_remove(list_item->timer_id);
list_item->timer_id = TK_INVALID_ID;
}
return RET_OK;
}
TK_DECL_VTABLE(list_item) = {.size = sizeof(list_item_t),
.type = WIDGET_TYPE_LIST_ITEM,
.space_key_to_activate = TRUE,
.return_key_to_activate = TRUE,
.get_parent_vt = TK_GET_PARENT_VTABLE(widget),
.create = list_item_create,
.on_event = list_item_on_event,
.on_paint_self = list_item_on_paint_self,
.on_detach_parent = list_item_on_detach_parent,
.on_destroy = list_item_on_destroy};
widget_t* list_item_create(widget_t* parent, xy_t x, xy_t y, wh_t w, wh_t h) {
widget_t* widget = widget_create(parent, TK_REF_VTABLE(list_item), x, y, w, h);
list_item_t* list_item = LIST_ITEM(widget);
return_value_if_fail(list_item != NULL, NULL);
list_item->timer_id = TK_INVALID_ID;
return widget;
}
widget_t* list_item_cast(widget_t* widget) {
return_value_if_fail(WIDGET_IS_INSTANCE_OF(widget, list_item), NULL);
return widget;
}
#include "list_item_seperator.inc"
|
0 |
repos/awtk/src
|
repos/awtk/src/window_animators/window_animator_builtins.h
|
/**
* File: window_animator_builtins.h
* Author: AWTK Develop Team
* Brief: builtins window animator
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2019-03-26 Li XianJing <[email protected]> created
*
*/
#include "base/window_animator.h"
#ifndef TK_WINDOW_ANIMATOR_BUILTINS_H
#define TK_WINDOW_ANIMATOR_BUILTINS_H
BEGIN_C_DECLS
ret_t window_animator_register_builtins(void);
END_C_DECLS
#endif /*TK_WINDOW_ANIMATOR_BUILTINS_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/window_animators/window_animator_slide_right.c
|
/**
* File: window_animator_slide_right.c
* Author: AWTK Develop Team
* Brief: slide_right window animator
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2019-03-28 Li XianJing <[email protected]> created
*
*/
#include "window_animators/window_animator_common.h"
#include "window_animators/window_animator_slide.h"
#include "window_animators/window_animator_slide_right.h"
static const window_animator_vtable_t s_window_animator_slide_right_vt = {
.overlap = TRUE,
.type = "slide_right",
.desc = "slide_right",
.size = sizeof(window_animator_slide_t),
.init = window_animator_slide_init,
.draw_prev_window = window_animator_slide_draw_prev,
.draw_curr_window = window_animator_to_right_draw_curr};
window_animator_t* window_animator_slide_right_create(bool_t open, tk_object_t* args) {
return window_animator_slide_create(open, args, &s_window_animator_slide_right_vt);
}
|
0 |
repos/awtk/src
|
repos/awtk/src/window_animators/window_animator_vtranslate.c
|
/**
* File: window_animator_vtranslate.c
* Author: AWTK Develop Team
* Brief: vertical translate window animator
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-04-22 Li XianJing <[email protected]> created
*
*/
#include "base/widget_vtable.h"
#include "base/window_manager.h"
#include "window_animators/window_animator_vtranslate.h"
typedef struct _window_animator_vtranslate_t {
window_animator_t window_animator;
uint32_t prev_win_y_range;
int32_t real_prev_win_index;
} window_animator_vtranslate_t;
static ret_t window_animator_vtranslate_update_percent(window_animator_t* wa) {
float_t percent = 0.2f + 0.8f * wa->easing(wa->time_percent);
if (wa->open) {
wa->percent = percent;
} else {
wa->percent = 1.0f - percent;
}
return RET_OK;
}
static ret_t window_animator_vtranslate_draw_prev(window_animator_t* wa) {
bool_t start = FALSE;
canvas_t* c = wa->canvas;
widget_t* win = wa->prev_win;
widget_t* curr_win = wa->curr_win;
widget_t* wm = window_manager();
window_animator_vtranslate_t* wav = (window_animator_vtranslate_t*)wa;
uint32_t range = wav->prev_win_y_range ? wav->prev_win_y_range : curr_win->h;
float_t percent = wa->percent;
float_t y = tk_roundi(range * percent);
#ifndef WITHOUT_WINDOW_ANIMATOR_CACHE
if (wav->real_prev_win_index >= 0) {
rectf_t src = rectf_init(win->x, win->y, win->w, win->h);
rectf_t dst = rectf_init(win->x, win->y, win->w, win->h);
ret_t ret = lcd_draw_image(c->lcd, &(wa->prev_img), rectf_scale(&src, wa->ratio), &dst);
if (ret == RET_OK) {
/* 非普通窗口应该需要重绘，因为可能会叠在 system_bar 上面，同时非普通窗口可能是半透明的 */
WIDGET_FOR_EACH_CHILD_BEGIN(wm, iter, i)
if (iter == wa->curr_win) {
break;
}
if (iter == wa->prev_win) {
start = TRUE;
}
if (i == wav->real_prev_win_index) {
canvas_translate(c, 0, -y);
widget_paint(iter, c);
canvas_untranslate(c, 0, -y);
continue;
}
if (start) {
widget_paint(iter, c);
}
WIDGET_FOR_EACH_CHILD_END()
}
return ret;
} else {
float_t h = win->h - y;
rectf_t src = rectf_init(win->x, y + win->y, win->w, h);
rectf_t dst = rectf_init(win->x, win->y, win->w, h);
return lcd_draw_image(c->lcd, &(wa->prev_img), rectf_scale(&src, wa->ratio), &dst);
}
#else
if (wav->real_prev_win_index >= 0) {
WIDGET_FOR_EACH_CHILD_BEGIN(wm, iter, i)
if (iter == wa->curr_win) {
break;
}
if (iter == wa->prev_win) {
start = TRUE;
}
if (i == wav->real_prev_win_index) {
canvas_translate(c, 0, -y);
widget_paint(iter, c);
canvas_untranslate(c, 0, -y);
continue;
}
if (start) {
widget_paint(iter, c);
if (widget_is_normal_window(iter)) {
/* 限制普通窗口不能覆盖在 system_bar 上面 */
rect_t rect = rect_init(iter->x, iter->y, iter->w, iter->h);
widget_paint_with_clip(iter, &rect, c, widget_paint);
} else {
widget_paint(iter, c);
}
}
WIDGET_FOR_EACH_CHILD_END()
} else {
rect_t rect = rect_init(win->x, win->y, win->w, win->h);
canvas_translate(c, 0, -y);
widget_paint_with_clip(win, &rect, c, widget_paint);
canvas_untranslate(c, 0, -y);
}
return RET_OK;
#endif /*WITHOUT_WINDOW_ANIMATOR_CACHE*/
}
static ret_t window_animator_vtranslate_draw_prev_window_on_highlighter(window_animator_t* wa) {
window_animator_vtranslate_t* wav = (window_animator_vtranslate_t*)wa;
if (wav->real_prev_win_index >= 0) {
canvas_t* c = wa->canvas;
uint32_t range = wav->prev_win_y_range ? wav->prev_win_y_range : wa->curr_win->h;
float_t y = tk_roundi(range * wa->percent);
widget_t* win = widget_get_child(window_manager(), wav->real_prev_win_index);
canvas_translate(c, 0, -y);
widget_paint(win, c);
canvas_untranslate(c, 0, -y);
}
return RET_OK;
}
static ret_t window_animator_vtranslate_draw_curr(window_animator_t* wa) {
canvas_t* c = wa->canvas;
widget_t* win = wa->curr_win;
float_t percent = wa->percent;
float_t h = tk_roundi(win->h * percent);
float_t y = win->parent->h - h;
#ifndef WITHOUT_WINDOW_ANIMATOR_CACHE
rectf_t src = rectf_init(win->x, win->y, win->w, h);
rectf_t dst = rectf_init(win->x, y, win->w, h);
return lcd_draw_image(c->lcd, &(wa->curr_img), rectf_scale(&src, wa->ratio), &dst);
#else
y = win->h * (1 - percent);
canvas_translate(c, 0, y);
widget_paint(win, c);
canvas_untranslate(c, 0, y);
return RET_OK;
#endif /*WITHOUT_WINDOW_ANIMATOR_CACHE*/
}
static const window_animator_vtable_t s_window_animator_vtranslate_vt = {
.overlap = FALSE,
.type = "vtranslate",
.desc = "vtranslate",
.size = sizeof(window_animator_vtranslate_t),
.update_percent = window_animator_vtranslate_update_percent,
.draw_prev_window = window_animator_vtranslate_draw_prev,
.draw_curr_window = window_animator_vtranslate_draw_curr,
.draw_prev_window_on_highlighter = window_animator_vtranslate_draw_prev_window_on_highlighter};
window_animator_t* window_animator_vtranslate_create(bool_t open, tk_object_t* args) {
window_animator_t* wa = window_animator_create(open, &s_window_animator_vtranslate_vt);
window_animator_vtranslate_t* wav = (window_animator_vtranslate_t*)wa;
return_value_if_fail(wa != NULL, NULL);
/* 真正触发窗口动画的窗口 index */
wav->real_prev_win_index =
tk_object_get_prop_int32(args, WINDOW_ANIMATOR_VTRANSLATE_PROP_PREV_WIN_INDEX, -1);
/*主要用于弹出软键盘，此时前面窗口移动的位置由编辑器的位置决定，而不是软键盘的高度*/
wav->prev_win_y_range =
tk_object_get_prop_uint32(args, WINDOW_ANIMATOR_VTRANSLATE_PROP_PREV_WIN_Y_RANGE, 0);
return wa;
}
|
0 |
repos/awtk/src
|
repos/awtk/src/window_animators/window_animator_fade.c
|
/**
* File: window_animator_fade.c
* Author: AWTK Develop Team
* Brief: fade window animator
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-04-22 Li XianJing <[email protected]> created
*
*/
#include "window_animators/window_animator_fade.h"
static ret_t window_animator_fade_draw_curr(window_animator_t* wa) {
ret_t ret = RET_OK;
canvas_t* c = wa->canvas;
widget_t* win = wa->curr_win;
uint8_t global_alpha = wa->percent * 0xff;
#ifndef WITHOUT_WINDOW_ANIMATOR_CACHE
rectf_t dst = rectf_init(win->x, win->y, win->w, win->h);
rectf_t src = rectf_init(win->x, win->y, win->w, win->h);
lcd_set_global_alpha(c->lcd, global_alpha);
ret = lcd_draw_image(c->lcd, &(wa->curr_img), rectf_scale(&src, wa->ratio), &dst);
#else
lcd_set_global_alpha(c->lcd, global_alpha);
ret = widget_paint(win, c);
#endif /*WITHOUT_WINDOW_ANIMATOR_CACHE*/
lcd_set_global_alpha(c->lcd, 0xff);
return ret;
}
static const window_animator_vtable_t s_window_animator_fade_vt = {
.overlap = TRUE,
.type = "fade",
.desc = "fade",
.size = sizeof(window_animator_t),
.draw_prev_window = window_animator_overlap_default_draw_prev,
.draw_curr_window = window_animator_fade_draw_curr};
window_animator_t* window_animator_fade_create(bool_t open, tk_object_t* args) {
window_animator_t* wa = window_animator_create(open, &s_window_animator_fade_vt);
return_value_if_fail(wa != NULL, NULL);
wa->easing = easing_get(EASING_QUADRATIC_IN);
return wa;
}
|
0 |
repos/awtk/src
|
repos/awtk/src/window_animators/window_animator_popdown.c
|
/**
* File: window_animator_popdown.c
* Author: AWTK Develop Team
* Brief: popdown window animator
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-04-22 Li XianJing <[email protected]> created
*
*/
#include "window_animators/window_animator_common.h"
#include "window_animators/window_animator_popdown.h"
static const window_animator_vtable_t s_window_animator_popdown_vt = {
.overlap = TRUE,
.type = "popdown",
.desc = "popdown",
.size = sizeof(window_animator_t),
.draw_prev_window = window_animator_overlap_default_draw_prev,
.draw_curr_window = window_animator_to_bottom_draw_curr};
window_animator_t* window_animator_popdown_create(bool_t open, tk_object_t* args) {
return window_animator_create(open, &s_window_animator_popdown_vt);
}
|
0 |
repos/awtk/src
|
repos/awtk/src/window_animators/window_animator_vtranslate.h
|
/**
* File: window_animator_vtranslate.h
* Author: AWTK Develop Team
* Brief: vertical translate window animator
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-04-22 Li XianJing <[email protected]> created
*
*/
#include "base/window_animator.h"
#ifndef TK_WINDOW_ANIMATOR_VTRANSLATE_H
#define TK_WINDOW_ANIMATOR_VTRANSLATE_H
BEGIN_C_DECLS
#define WINDOW_ANIMATOR_VTRANSLATE_PROP_PREV_WIN_INDEX "prev_win_index"
#define WINDOW_ANIMATOR_VTRANSLATE_PROP_PREV_WIN_Y_RANGE "prev_win_y_range"
window_animator_t* window_animator_vtranslate_create(bool_t open, tk_object_t* args);
END_C_DECLS
#endif /*TK_WINDOW_ANIMATOR_VTRANSLATE_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/window_animators/window_animator_htranslate.c
|
/**
* File: window_animator_htranslate.c
* Author: AWTK Develop Team
* Brief: horizontal translate window animator
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-04-22 Li XianJing <[email protected]> created
*
*/
#include "base/window_manager.h"
#include "window_animators/window_animator_htranslate.h"
static ret_t window_animator_htranslate_update_percent(window_animator_t* wa) {
float_t percent = 0.2f + 0.8f * wa->easing(wa->time_percent);
if (wa->open) {
wa->percent = percent;
} else {
wa->percent = 1.0f - percent;
}
return RET_OK;
}
static ret_t window_animator_htranslate_draw_prev(window_animator_t* wa) {
bool_t start = FALSE;
canvas_t* c = wa->canvas;
widget_t* win = wa->prev_win;
widget_t* wm = window_manager();
float_t percent = wa->percent;
float_t x = tk_roundi(win->w * percent);
float_t w = win->w - x;
#ifndef WITHOUT_WINDOW_ANIMATOR_CACHE
rectf_t src = rectf_init(x, win->y, w, win->h);
rectf_t dst = rectf_init(0.0f, win->y, w, win->h);
ret_t ret = lcd_draw_image(c->lcd, &(wa->prev_img), rectf_scale(&src, wa->ratio), &dst);
if (ret == RET_OK) {
/* 非普通窗口应该需要重绘，因为可能会叠在 system_bar 上面，同时非普通窗口可能是半透明的 */
canvas_translate(c, -x, 0);
WIDGET_FOR_EACH_CHILD_BEGIN(wm, iter, i)
if (iter == wa->curr_win) {
break;
}
if (iter == wa->prev_win) {
start = TRUE;
continue;
}
if (start) {
widget_paint(iter, c);
}
WIDGET_FOR_EACH_CHILD_END()
canvas_untranslate(c, -x, 0);
}
return ret;
#else
canvas_translate(c, -x, 0);
WIDGET_FOR_EACH_CHILD_BEGIN(wm, iter, i)
if (iter == wa->curr_win) {
break;
}
if (iter == wa->prev_win) {
start = TRUE;
}
if (start) {
widget_paint(iter, c);
}
WIDGET_FOR_EACH_CHILD_END()
canvas_untranslate(c, -x, 0);
return RET_OK;
#endif /*WITHOUT_WINDOW_ANIMATOR_CACHE*/
}
static ret_t window_animator_htranslate_draw_curr(window_animator_t* wa) {
canvas_t* c = wa->canvas;
widget_t* win = wa->curr_win;
float_t percent = wa->percent;
float_t x = tk_roundi(win->w * (1 - percent));
float_t w = win->w - x;
#ifndef WITHOUT_WINDOW_ANIMATOR_CACHE
rectf_t src = rectf_init(0.0f, win->y, w, win->h);
rectf_t dst = rectf_init(x, win->y, w, win->h);
return lcd_draw_image(c->lcd, &(wa->curr_img), rectf_scale(&src, wa->ratio), &dst);
#else
canvas_translate(c, x, 0);
widget_paint(win, c);
canvas_untranslate(c, x, 0);
return RET_OK;
#endif /*WITHOUT_WINDOW_ANIMATOR_CACHE*/
}
static const window_animator_vtable_t s_window_animator_htranslate_vt = {
.overlap = FALSE,
.type = "htranslate",
.desc = "htranslate",
.size = sizeof(window_animator_t),
.update_percent = window_animator_htranslate_update_percent,
.draw_prev_window = window_animator_htranslate_draw_prev,
.draw_curr_window = window_animator_htranslate_draw_curr};
window_animator_t* window_animator_htranslate_create(bool_t open, tk_object_t* args) {
return window_animator_create(open, &s_window_animator_htranslate_vt);
}
|
0 |
repos/awtk/src
|
repos/awtk/src/window_animators/window_animator_popup.h
|
/**
* File: window_animator_popup.h
* Author: AWTK Develop Team
* Brief: popup window animator
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-04-22 Li XianJing <[email protected]> created
*
*/
#include "base/window_animator.h"
#ifndef TK_WINDOW_ANIMATOR_POPUP_H
#define TK_WINDOW_ANIMATOR_POPUP_H
BEGIN_C_DECLS
window_animator_t* window_animator_popup_create(bool_t open, tk_object_t* args);
END_C_DECLS
#endif /*TK_WINDOW_ANIMATOR_POPUP_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/window_animators/window_animator_common.c
|
/**
* File: window_animator_common.c
* Author: AWTK Develop Team
* Brief: window animator common used functions.
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2019-03-28 Li XianJing <[email protected]> created
*
*/
#ifdef AWTK_WEB
#include <emscripten.h>
#endif /*AWTK_WEB*/
#include "base/window_manager.h"
#include "base/window_animator.h"
#include "base/dialog_highlighter_factory.h"
#include "window_manager/window_manager_default.h"
#include "window_animators/window_animator_common.h"
ret_t window_animator_to_bottom_draw_curr(window_animator_t* wa) {
canvas_t* c = wa->canvas;
widget_t* win = wa->curr_win;
float_t percent = wa->percent;
#ifndef WITHOUT_WINDOW_ANIMATOR_CACHE
int32_t y = win->y;
int32_t h = tk_roundi(win->h * percent);
rectf_t src = rectf_init(win->x, win->y + win->h - h, win->w, h);
rectf_t dst = rectf_init(win->x, y, win->w, h);
if (h == 0) {
return RET_OK;
}
return lcd_draw_image(c->lcd, &(wa->curr_img), rectf_scale(&src, wa->ratio), &dst);
#else
int32_t y = -win->h * (1 - percent);
canvas_translate(c, 0, y);
widget_paint(win, c);
canvas_untranslate(c, 0, y);
return RET_OK;
#endif /*WITHOUT_WINDOW_ANIMATOR_CACHE*/
}
ret_t window_animator_to_top_draw_curr(window_animator_t* wa) {
canvas_t* c = wa->canvas;
widget_t* win = wa->curr_win;
float_t percent = wa->percent;
#ifndef WITHOUT_WINDOW_ANIMATOR_CACHE
int32_t y = win->y + tk_roundi(win->h * (1 - percent));
int32_t h = win->y + win->h - y;
rectf_t src = rectf_init(win->x, win->y, win->w, h);
rectf_t dst = rectf_init(win->x, y, win->w, h);
if (h == 0) {
return RET_OK;
}
return lcd_draw_image(c->lcd, &(wa->curr_img), rectf_scale(&src, wa->ratio), &dst);
#else
int32_t y = win->h * (1 - percent);
canvas_translate(c, 0, y);
widget_paint(win, c);
canvas_untranslate(c, 0, y);
return RET_OK;
#endif /*WITHOUT_WINDOW_ANIMATOR_CACHE*/
}
ret_t window_animator_to_left_draw_curr(window_animator_t* wa) {
canvas_t* c = wa->canvas;
widget_t* win = wa->curr_win;
float_t percent = wa->percent;
#ifndef WITHOUT_WINDOW_ANIMATOR_CACHE
int32_t x = win->x + tk_roundi(win->w * (1 - percent));
int32_t w = win->x + win->w - x;
rectf_t src = rectf_init(win->x, win->y, w, win->h);
rectf_t dst = rectf_init(x, win->y, w, win->h);
if (w == 0) {
return RET_OK;
}
return lcd_draw_image(c->lcd, &(wa->curr_img), rectf_scale(&src, wa->ratio), &dst);
#else
int32_t x = -win->w * (1 - percent);
canvas_translate(c, x, 0);
widget_paint(win, c);
canvas_untranslate(c, x, 0);
return RET_OK;
#endif /*WITHOUT_WINDOW_ANIMATOR_CACHE*/
}
ret_t window_animator_to_right_draw_curr(window_animator_t* wa) {
canvas_t* c = wa->canvas;
widget_t* win = wa->curr_win;
float_t percent = wa->percent;
#ifndef WITHOUT_WINDOW_ANIMATOR_CACHE
int32_t x = win->x;
int32_t w = tk_roundi(win->w * percent);
rectf_t src = rectf_init(win->x + win->w - w, win->y, w, win->h);
rectf_t dst = rectf_init(x, win->y, w, win->h);
if (w == 0) {
return RET_OK;
}
return lcd_draw_image(c->lcd, &(wa->curr_img), rectf_scale(&src, wa->ratio), &dst);
#else
int32_t x = win->w * (1 - percent);
canvas_translate(c, x, 0);
widget_paint(win, c);
canvas_untranslate(c, x, 0);
return RET_OK;
#endif /*WITHOUT_WINDOW_ANIMATOR_CACHE*/
}
static ret_t window_animator_update_percent(window_animator_t* wa);
static ret_t window_animator_draw_prev_window(window_animator_t* wa);
static ret_t window_animator_draw_curr_window(window_animator_t* wa);
static ret_t window_animator_open_destroy(window_animator_t* wa) {
#ifndef WITHOUT_WINDOW_ANIMATOR_CACHE
if (wa->dialog_highlighter == NULL) {
bitmap_destroy(&(wa->prev_img));
}
bitmap_destroy(&(wa->curr_img));
#endif /*WITHOUT_WINDOW_ANIMATOR_CACHE*/
memset(wa, 0x00, sizeof(window_animator_t));
TKMEM_FREE(wa);
return RET_OK;
}
static ret_t window_animator_close_destroy(window_animator_t* wa) {
widget_invalidate_force(wa->prev_win, NULL);
widget_destroy(wa->curr_win);
return window_animator_open_destroy(wa);
}
ret_t window_animator_update(window_animator_t* wa, uint64_t time_ms) {
return_value_if_fail(wa != NULL, RET_FAIL);
if (wa->start_time == 0) {
wa->start_time = time_ms;
}
wa->time_percent = (time_ms - wa->start_time) / (float_t)(wa->duration);
if (wa->time_percent >= 1) {
wa->time_percent = 1;
}
ENSURE(window_animator_update_percent(wa) == RET_OK);
ENSURE(window_animator_draw_prev_window(wa) == RET_OK);
ENSURE(window_animator_draw_curr_window(wa) == RET_OK);
return wa->time_percent >= 1 ? RET_DONE : RET_OK;
}
ret_t window_animator_destroy(window_animator_t* wa) {
return_value_if_fail(wa != NULL, RET_FAIL);
if (wa->open) {
return window_animator_open_destroy(wa);
} else {
return window_animator_close_destroy(wa);
}
}
/******************helper******************/
#ifndef WITHOUT_WINDOW_ANIMATORS
static ret_t window_animator_init(window_animator_t* wa) {
ret_t ret = RET_NOT_IMPL;
return_value_if_fail(wa != NULL && wa->vt != NULL, RET_BAD_PARAMS);
if (wa->vt->init != NULL) {
ret = wa->vt->init(wa);
}
return ret;
}
ret_t window_animator_prepare(window_animator_t* wa, canvas_t* c, widget_t* prev_win,
widget_t* curr_win) {
widget_t* wm = prev_win->parent;
wa->canvas = c;
wa->prev_win = prev_win;
wa->curr_win = curr_win;
wa->ratio = c->lcd->ratio;
wa->duration = wa->duration ? wa->duration : 500;
window_animator_init(wa);
#ifndef WITHOUT_WINDOW_ANIMATOR_CACHE
window_manager_snap_prev_window(wm, prev_win, &(wa->prev_img));
window_manager_snap_curr_window(wm, curr_win, &(wa->curr_img));
wa->dialog_highlighter = window_manager_get_dialog_highlighter(wm);
#endif /*WITHOUT_WINDOW_ANIMATOR_CACHE*/
return RET_OK;
}
#else
ret_t window_animator_prepare(window_animator_t* wa, canvas_t* c, widget_t* prev_win,
widget_t* curr_win) {
return RET_OK;
}
#endif /*WITHOUT_WINDOW_ANIMATORS*/
window_animator_t* window_animator_create(bool_t open, const window_animator_vtable_t* vt) {
window_animator_t* wa = NULL;
return_value_if_fail(vt != NULL && vt->size >= sizeof(window_animator_t), NULL);
wa = (window_animator_t*)TKMEM_ALLOC(vt->size);
return_value_if_fail(wa != NULL, NULL);
memset(wa, 0, vt->size);
wa->vt = vt;
wa->open = open;
wa->easing = easing_get(EASING_CUBIC_OUT);
return wa;
}
static ret_t window_animator_update_percent_default(window_animator_t* wa) {
if (wa->open) {
wa->percent = wa->easing(wa->time_percent);
} else {
wa->percent = 1.0f - wa->easing(wa->time_percent);
}
return RET_OK;
}
static ret_t window_animator_update_percent(window_animator_t* wa) {
ret_t ret = RET_OK;
return_value_if_fail(wa != NULL && wa->vt != NULL, RET_BAD_PARAMS);
if (wa->vt->update_percent != NULL) {
ret = wa->vt->update_percent(wa);
} else {
ret = window_animator_update_percent_default(wa);
}
if (wa->percent >= 1) {
wa->percent = 0.999f;
} else if (wa->percent < 0) {
wa->percent = 0.0f;
}
return ret;
}
static ret_t window_animator_draw_prev_window(window_animator_t* wa) {
return_value_if_fail(wa != NULL && wa->vt != NULL && wa->vt->draw_prev_window, RET_BAD_PARAMS);
if (wa->dialog_highlighter != NULL) {
ret_t ret = dialog_highlighter_draw(wa->dialog_highlighter, wa->percent);
if (ret == RET_OK && wa->vt->draw_prev_window_on_highlighter != NULL) {
ret = wa->vt->draw_prev_window_on_highlighter(wa);
}
return ret;
} else {
return wa->vt->draw_prev_window(wa);
}
}
static ret_t window_animator_draw_curr_window(window_animator_t* wa) {
return_value_if_fail(wa != NULL && wa->vt != NULL && wa->vt->draw_curr_window, RET_BAD_PARAMS);
return wa->vt->draw_curr_window(wa);
}
ret_t window_animator_overlap_default_draw_prev(window_animator_t* wa) {
bool_t start = FALSE;
canvas_t* c = wa->canvas;
widget_t* wm = window_manager();
#ifndef WITHOUT_WINDOW_ANIMATOR_CACHE
widget_t* win = wa->prev_win;
rectf_t src = rectf_init(win->x, win->y, win->w, win->h);
rectf_t dst = rectf_init(win->x, win->y, win->w, win->h);
lcd_draw_image(c->lcd, &(wa->prev_img), rectf_scale(&src, wa->ratio), &dst);
WIDGET_FOR_EACH_CHILD_BEGIN(wm, iter, i)
if (iter == wa->curr_win) {
break;
}
if (iter == wa->prev_win) {
start = TRUE;
}
if (start) {
/* 非普通窗口应该需要重绘，因为可能会叠在 system_bar 上面 */
src = rectf_init(iter->x, iter->y, iter->w, iter->h);
dst = rectf_init(iter->x, iter->y, iter->w, iter->h);
lcd_draw_image(c->lcd, &(wa->prev_img), rectf_scale(&src, wa->ratio), &dst);
}
WIDGET_FOR_EACH_CHILD_END()
#else
WIDGET_FOR_EACH_CHILD_BEGIN(wm, iter, i)
if (iter == wa->curr_win) {
break;
}
if (iter == wa->prev_win) {
start = TRUE;
}
if (start) {
widget_paint(iter, c);
}
WIDGET_FOR_EACH_CHILD_END()
#endif /*WITHOUT_WINDOW_ANIMATOR_CACHE*/
return RET_OK;
}
ret_t window_animator_begin_frame(window_animator_t* wa) {
return_value_if_fail(wa != NULL && wa->vt != NULL, RET_OK);
ENSURE(canvas_begin_frame(wa->canvas, NULL, LCD_DRAW_ANIMATION) == RET_OK);
/* 把 system_bar 绘制到底部，然后再被截图覆盖在上面，应该截图中的对话框等窗口有可能叠在 system_bar 上面 */
if (wa->is_paint_system_bar_top) {
window_manager_paint_system_bar_top(wa->curr_win->parent, wa->canvas);
}
if (wa->is_paint_system_bar_bottom) {
window_manager_paint_system_bar_bottom(wa->curr_win->parent, wa->canvas);
}
return RET_OK;
}
ret_t window_animator_end_frame(window_animator_t* wa) {
return_value_if_fail(wa != NULL && wa->vt != NULL, RET_OK);
return canvas_end_frame(wa->canvas);
}
|
0 |
repos/awtk/src
|
repos/awtk/src/window_animators/window_animator_slide.c
|
/**
* File: window_animator_slide_up.h
* Author: AWTK Develop Team
* Brief: slide window animator
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2019-03-28 Li XianJing <[email protected]> created
*
*/
#include "window_animators/window_animator_slide.h"
static ret_t window_animator_slide_draw_mask(window_animator_t* wa, uint8_t alpha) {
if (alpha > 1) {
canvas_t* c = wa->canvas;
widget_t* win = wa->prev_win;
color_t mask = color_init(0, 0, 0, alpha);
canvas_set_fill_color(c, mask);
canvas_fill_rect(c, win->x, win->y, win->w, win->h);
}
return RET_OK;
}
static ret_t on_prev_window_paint_done(void* ctx, event_t* e) {
window_animator_t* wa = (window_animator_t*)ctx;
window_animator_slide_t* was = (window_animator_slide_t*)wa;
window_animator_slide_draw_mask(wa, was->start_alpha);
return RET_REMOVE;
}
ret_t window_animator_slide_init(window_animator_t* wa) {
window_animator_slide_t* was = (window_animator_slide_t*)wa;
if (was->start_alpha == was->end_alpha) {
widget_on(wa->prev_win, EVT_PAINT_DONE, on_prev_window_paint_done, wa);
}
return RET_OK;
}
ret_t window_animator_slide_draw_prev(window_animator_t* wa) {
float_t percent = wa->percent;
window_animator_slide_t* was = (window_animator_slide_t*)wa;
window_animator_overlap_default_draw_prev(wa);
/*
* only if was->start_alpha != was->end_alpha, we draw mask layer very time.
*/
if (was->start_alpha != was->end_alpha) {
uint8_t a = ((was->end_alpha - was->start_alpha) * percent) + was->start_alpha;
window_animator_slide_draw_mask(wa, a);
}
return RET_OK;
}
window_animator_t* window_animator_slide_create(bool_t open, tk_object_t* args,
const window_animator_vtable_t* vt) {
value_t v;
window_animator_t* wa = window_animator_create(open, vt);
window_animator_slide_t* was = (window_animator_slide_t*)wa;
return_value_if_fail(was != NULL, NULL);
was->end_alpha = 0;
was->start_alpha = 0;
if (tk_object_get_prop(args, WINDOW_ANIMATOR_SLIDE_ARG_ALPHA, &v) == RET_OK) {
was->start_alpha = value_int(&v);
was->end_alpha = value_int(&v);
}
if (tk_object_get_prop(args, WINDOW_ANIMATOR_SLIDE_ARG_START_ALPHA, &v) == RET_OK) {
was->start_alpha = value_int(&v);
}
if (tk_object_get_prop(args, WINDOW_ANIMATOR_SLIDE_ARG_END_ALPHA, &v) == RET_OK) {
was->end_alpha = value_int(&v);
}
return wa;
}
|
0 |
repos/awtk/src
|
repos/awtk/src/window_animators/window_animator_slide_right.h
|
/**
* File: window_animator_slide_right.h
* Author: AWTK Develop Team
* Brief: slide_right window animator
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2019-03-28 Li XianJing <[email protected]> created
*
*/
#include "base/window_animator.h"
#ifndef TK_WINDOW_ANIMATOR_SLIDE_RIGHT_H
#define TK_WINDOW_ANIMATOR_SLIDE_RIGHT_H
BEGIN_C_DECLS
window_animator_t* window_animator_slide_right_create(bool_t open, tk_object_t* args);
END_C_DECLS
#endif /*TK_WINDOW_ANIMATOR_SLIDE_RIGHT_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/window_animators/window_animator_slide_down.c
|
/**
* File: window_animator_slide_down.c
* Author: AWTK Develop Team
* Brief: slide_down window animator
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2019-03-28 Li XianJing <[email protected]> created
*
*/
#include "window_animators/window_animator_common.h"
#include "window_animators/window_animator_slide.h"
#include "window_animators/window_animator_slide_down.h"
static const window_animator_vtable_t s_window_animator_slide_down_vt = {
.overlap = TRUE,
.type = "slide_down",
.desc = "slide_down",
.size = sizeof(window_animator_slide_t),
.init = window_animator_slide_init,
.draw_prev_window = window_animator_slide_draw_prev,
.draw_curr_window = window_animator_to_bottom_draw_curr};
window_animator_t* window_animator_slide_down_create(bool_t open, tk_object_t* args) {
return window_animator_slide_create(open, args, &s_window_animator_slide_down_vt);
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.