981 lines
38 KiB
C
981 lines
38 KiB
C
#include "include.h"
|
|
|
|
//转场速度控制
|
|
#define SWITCHING_TICK_AUTO 180 //快速松手视为自动模式(ms)
|
|
#define SWITCHING_TICK_EXPIRE 18 //松手后自动切换单位时间(ms)
|
|
|
|
#define SWITCHING_FADE_STEP 20 //淡入淡出速度
|
|
|
|
#define SWITCHING_MENU_STEP (GUI_SCREEN_WIDTH / 8) //上下菜单松手后自动切换单位时间步进
|
|
#define SWITCHING_MENU_DRAG_THRESHOLD (GUI_SCREEN_WIDTH / 7) //上下拖动松手自动的判断阈值(需要拉多少距离才能自动完成)
|
|
|
|
#define SWITCHING_LR_STEP (GUI_SCREEN_WIDTH / 12) //左右转场松手后自动切换单位步进
|
|
#define SWITCHING_LR_DRAG_THRESHOLD (GUI_SCREEN_WIDTH / 3) //左右转场松手自动的判断阈值(需要拉多少距离才能自动完成)
|
|
|
|
#define SWITCHING_UD_STEP (GUI_SCREEN_HEIGHT / 12) //上下转场松手后自动切换单位步进
|
|
#define SWITCHING_UD_DRAG_THRESHOLD (GUI_SCREEN_HEIGHT / 3) //上下转场松手自动的判断阈值(需要拉多少距离才能自动完成)
|
|
|
|
#define SWITCHING_ZOOM_ROLL_STEP (GUI_SCREEN_WIDTH / 10) //滚动步进
|
|
#define SWITCHING_ZOOM_ROLL_KICK_CNT 6 //滚动步进分几次动画
|
|
#define SWITCHING_ZOOM_ROLL_STEP_PER (SWITCHING_ZOOM_ROLL_STEP / SWITCHING_ZOOM_ROLL_KICK_CNT)
|
|
#define SWITCHING_ZOOM_ROLL_TICK_EXPIRE 300 //滚动超时
|
|
#define SWITCHING_ZOOM_STEP (GUI_SCREEN_WIDTH / 10) //进出应用自动切换单位
|
|
#define SWITCHING_ZOOM_EXIT_THRESHOLD (GUI_SCREEN_WIDTH / 2) //退出应用自动切换判断阈值(需要拉多少距离才能自动退出)
|
|
#define SWITCHING_ZOOM_RATE 320 //放大倍数速度，越大越快
|
|
|
|
#define SWITCHING_ZOOM_FADE_RATE 280 //放大倍数速度，越大越快
|
|
#define SWITCHING_ZOOM_FADE_MAX 0x1A000 //最大放大到多少
|
|
#define SWITCHING_ZOOM_FADE_1 (0x10000 + (SWITCHING_ZOOM_FADE_MAX - 0x10000) / 4)
|
|
#define SWITCHING_ZOOM_FADE_2 (0x10000 + (SWITCHING_ZOOM_FADE_MAX - 0x10000) * 3 / 4)
|
|
|
|
//左右转场的起始宽度
|
|
#define SWITCHING_LR_WIDTH (GUI_SCREEN_WIDTH / 2)
|
|
#define SWITCHING_LR_HEIGHT (GUI_SCREEN_HEIGHT / 2)
|
|
|
|
//上下转场的起始宽度
|
|
#define SWITCHING_UD_WIDTH (GUI_SCREEN_WIDTH / 2)
|
|
#define SWITCHING_UD_HEIGHT (GUI_SCREEN_HEIGHT / 2)
|
|
|
|
//转场的起始Alpha
|
|
#define SWITCHING_LR_ALPHA 64
|
|
#define SWITCHING_UD_ALPHA 64
|
|
#define SWITCHING_ZOOM_ALPHA_BMAX 192
|
|
#define SWITCHING_ZOOM_ALPHA 24
|
|
|
|
//左右两个场景的中心距离
|
|
#define SWITCHING_LR_DISTANCE ((GUI_SCREEN_WIDTH + SWITCHING_LR_WIDTH) / 2 + (GUI_SCREEN_WIDTH / 8))
|
|
|
|
//上下两个场景的中心距离
|
|
#define SWITCHING_UD_DISTANCE ((GUI_SCREEN_HEIGHT + SWITCHING_UD_HEIGHT) / 2 + (GUI_SCREEN_HEIGHT / 8))
|
|
|
|
enum {
|
|
FLAG_POS_NORM, //中间转场过程
|
|
FLAG_POS_START, //退回到起点
|
|
FLAG_POS_END, //完成到结束
|
|
};
|
|
|
|
//手动场景切换中强制退出条件
|
|
static bool func_switching_abort_need(void)
|
|
{
|
|
return func_cb.sta == FUN_DIAL_PUSH;
|
|
}
|
|
|
|
//手动场景切换中消息处理
|
|
static void func_switching_message(size_msg_t msg)
|
|
{
|
|
evt_message(msg);
|
|
}
|
|
|
|
//单独淡入淡出
|
|
static bool func_switching_fade(u16 switch_mode, bool flag_auto)
|
|
{
|
|
compo_form_t *frm_cur = compo_pool_get_top();
|
|
u8 flag_pos; //当前状态
|
|
s32 cur_alpha;
|
|
u32 tick = tick_get();
|
|
|
|
switch (switch_mode) {
|
|
case FUNC_SWITCH_FADE_OUT:
|
|
cur_alpha = 255;
|
|
break;
|
|
|
|
default:
|
|
halt(HALT_FUNC_SWITCH_ZOOM_MODE);
|
|
return false;
|
|
}
|
|
compo_form_set_alpha(frm_cur, cur_alpha);
|
|
for (;;) {
|
|
flag_pos = FLAG_POS_NORM;
|
|
if (tick_check_expire(tick, SWITCHING_TICK_EXPIRE)) {
|
|
tick = tick_get();
|
|
switch (switch_mode) {
|
|
case FUNC_SWITCH_FADE_OUT:
|
|
//淡出
|
|
cur_alpha -= SWITCHING_FADE_STEP;
|
|
if (cur_alpha <= 0) {
|
|
cur_alpha = 0;
|
|
flag_pos = FLAG_POS_END;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
halt(HALT_FUNC_SWITCH_ZOOM_MODE);
|
|
break;
|
|
}
|
|
compo_form_set_alpha(frm_cur, cur_alpha);
|
|
}
|
|
func_process();
|
|
if (!flag_auto) {
|
|
func_switching_message(msg_dequeue());
|
|
if (func_switching_abort_need()) {
|
|
return false;
|
|
}
|
|
}
|
|
if (flag_pos != FLAG_POS_NORM) {
|
|
break;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
//左右切换任务
|
|
static bool func_switching_lr(u16 switch_mode, bool flag_auto)
|
|
{
|
|
compo_form_t *frm_last = compo_pool_get_bottom();
|
|
compo_form_t *frm_cur = compo_pool_get_top();
|
|
bool flag_press = !flag_auto;
|
|
u8 flag_pos; //当前坐标状态
|
|
bool flag_change;
|
|
s32 dx = 0;
|
|
int dx_auto;
|
|
u32 tick = tick_get();
|
|
s32 xpos1 = GUI_SCREEN_CENTER_X;
|
|
s32 xpos2, xpos2_start;
|
|
s32 x_distance;
|
|
if (frm_last == NULL || frm_cur == NULL) {
|
|
halt(HALT_FUNC_SWITCH_LR_PTR);
|
|
}
|
|
|
|
if (switch_mode == FUNC_SWITCH_LR_ZOOM_LEFT || switch_mode == FUNC_SWITCH_LR_ZOOM_RIGHT) {
|
|
x_distance = SWITCHING_LR_DISTANCE; //带缩放的切换，两个场景中心距离要稍微近一点
|
|
} else {
|
|
x_distance = GUI_SCREEN_WIDTH; //平移切换，按屏幕宽度做中心距离
|
|
}
|
|
switch (switch_mode) {
|
|
case FUNC_SWITCH_LR_LEFT:
|
|
case FUNC_SWITCH_LR_ZOOM_LEFT:
|
|
//左划，右侧任务向左移入
|
|
xpos2_start = GUI_SCREEN_CENTER_X + x_distance;
|
|
dx_auto = -SWITCHING_LR_STEP;
|
|
break;
|
|
|
|
case FUNC_SWITCH_LR_RIGHT:
|
|
case FUNC_SWITCH_LR_ZOOM_RIGHT:
|
|
//右划，左侧任务向右移入
|
|
xpos2_start = GUI_SCREEN_CENTER_X - x_distance;
|
|
dx_auto = SWITCHING_LR_STEP;
|
|
break;
|
|
|
|
default:
|
|
halt(HALT_FUNC_SWITCH_LR_MODE);
|
|
return false;
|
|
}
|
|
compo_form_set_pos(frm_cur, xpos2_start, GUI_SCREEN_CENTER_Y);
|
|
compo_form_scale_to(frm_cur, SWITCHING_LR_WIDTH, SWITCHING_LR_HEIGHT);
|
|
compo_form_set_alpha(frm_cur, SWITCHING_LR_ALPHA);
|
|
for (;;) {
|
|
flag_pos = FLAG_POS_NORM;
|
|
flag_change = false;
|
|
if (flag_press) {
|
|
s32 dy;
|
|
flag_press = ctp_get_dxy(&dx, &dy);
|
|
if (flag_press) {
|
|
if (tick_check_expire(tick, SWITCHING_TICK_AUTO)) {
|
|
switch (switch_mode) {
|
|
case FUNC_SWITCH_LR_LEFT:
|
|
case FUNC_SWITCH_LR_ZOOM_LEFT:
|
|
//下拉往上, 上拉往上
|
|
if (dx <= -SWITCHING_LR_DRAG_THRESHOLD) {
|
|
dx_auto = -SWITCHING_LR_STEP;
|
|
} else {
|
|
dx_auto = SWITCHING_LR_STEP;
|
|
}
|
|
break;
|
|
|
|
case FUNC_SWITCH_LR_RIGHT:
|
|
case FUNC_SWITCH_LR_ZOOM_RIGHT:
|
|
//下拉往下, 上拉往下
|
|
if (dx >= SWITCHING_LR_DRAG_THRESHOLD) {
|
|
dx_auto = SWITCHING_LR_STEP;
|
|
} else {
|
|
dx_auto = -SWITCHING_LR_STEP;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
halt(HALT_FUNC_SWITCH_MENU_MODE);
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
flag_change = true;
|
|
} else if (tick_check_expire(tick, SWITCHING_TICK_EXPIRE)) {
|
|
tick = tick_get();
|
|
dx += dx_auto;
|
|
flag_change = true;
|
|
}
|
|
|
|
if (flag_change) {
|
|
switch (switch_mode) {
|
|
case FUNC_SWITCH_LR_LEFT:
|
|
case FUNC_SWITCH_LR_ZOOM_LEFT:
|
|
//左划，右侧任务向左移入
|
|
if (dx >= 0) {
|
|
dx = 0;
|
|
flag_pos = FLAG_POS_START;
|
|
} else if (dx <= -x_distance) {
|
|
dx = -x_distance;
|
|
flag_pos = FLAG_POS_END;
|
|
}
|
|
break;
|
|
|
|
case FUNC_SWITCH_LR_RIGHT:
|
|
case FUNC_SWITCH_LR_ZOOM_RIGHT:
|
|
//右划，左侧任务向右移入
|
|
if (dx <= 0) {
|
|
dx = 0;
|
|
flag_pos = FLAG_POS_START;
|
|
} else if (dx >= x_distance) {
|
|
dx = x_distance;
|
|
flag_pos = FLAG_POS_END;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
halt(HALT_FUNC_SWITCH_LR_MODE);
|
|
return false;
|
|
}
|
|
xpos1 = GUI_SCREEN_CENTER_X + dx;
|
|
xpos2 = xpos2_start + dx;
|
|
compo_form_set_pos(frm_last, xpos1, GUI_SCREEN_CENTER_Y);
|
|
compo_form_set_pos(frm_cur, xpos2, GUI_SCREEN_CENTER_Y);
|
|
if (switch_mode == FUNC_SWITCH_LR_ZOOM_LEFT || switch_mode == FUNC_SWITCH_LR_ZOOM_RIGHT) {
|
|
s32 abs_dx = abs_s(dx);
|
|
s32 dw = (GUI_SCREEN_WIDTH - SWITCHING_LR_WIDTH) * abs_dx / x_distance;
|
|
s32 xw1 = GUI_SCREEN_WIDTH - dw;
|
|
s32 xw2 = SWITCHING_LR_WIDTH + dw;
|
|
s32 dh = (GUI_SCREEN_HEIGHT - SWITCHING_LR_HEIGHT) * abs_dx / x_distance;
|
|
s32 xh1 = GUI_SCREEN_HEIGHT - dh;
|
|
s32 xh2 = SWITCHING_LR_HEIGHT + dh;
|
|
u8 da = (255 - SWITCHING_LR_ALPHA) * abs_dx / x_distance;
|
|
u8 xa1 = 255 - da;
|
|
u8 xa2 = SWITCHING_LR_ALPHA + da;
|
|
compo_form_scale_to(frm_last, xw1, xh1);
|
|
compo_form_scale_to(frm_cur, xw2, xh2);
|
|
compo_form_set_alpha(frm_last, xa1);
|
|
compo_form_set_alpha(frm_cur, xa2);
|
|
}
|
|
}
|
|
func_process();
|
|
if (!flag_auto) {
|
|
func_switching_message(msg_dequeue());
|
|
if (func_switching_abort_need()) {
|
|
return false;
|
|
}
|
|
}
|
|
if (!flag_press && flag_pos != FLAG_POS_NORM) {
|
|
break;
|
|
}
|
|
}
|
|
return (flag_pos == FLAG_POS_END);
|
|
}
|
|
|
|
//上下切换任务
|
|
static bool func_switching_ud(u16 switch_mode, bool flag_auto)
|
|
{
|
|
compo_form_t *frm_last = compo_pool_get_bottom();
|
|
compo_form_t *frm_cur = compo_pool_get_top();
|
|
bool flag_press = !flag_auto;
|
|
u8 flag_pos; //当前坐标状态
|
|
bool flag_change;
|
|
s32 dy = 0;
|
|
int dy_auto;
|
|
u32 tick = tick_get();
|
|
s32 ypos1 = GUI_SCREEN_CENTER_Y;
|
|
s32 ypos2, ypos2_start;
|
|
s32 y_distance;
|
|
if (frm_last == NULL || frm_cur == NULL) {
|
|
halt(HALT_FUNC_SWITCH_UD_PTR);
|
|
}
|
|
|
|
if (switch_mode == FUNC_SWITCH_UD_ZOOM_UP || switch_mode == FUNC_SWITCH_UD_ZOOM_DOWN) {
|
|
y_distance = SWITCHING_UD_DISTANCE; //带缩放的切换，两个场景中心距离要稍微近一点
|
|
} else {
|
|
y_distance = GUI_SCREEN_HEIGHT; //平移切换，按屏幕高度做中心距离
|
|
}
|
|
switch (switch_mode) {
|
|
case FUNC_SWITCH_UD_UP:
|
|
case FUNC_SWITCH_UD_ZOOM_UP:
|
|
//上划，下面任务向上移动
|
|
ypos2_start = GUI_SCREEN_CENTER_Y + y_distance;
|
|
dy_auto = -SWITCHING_UD_STEP;
|
|
break;
|
|
|
|
case FUNC_SWITCH_UD_DOWN:
|
|
case FUNC_SWITCH_UD_ZOOM_DOWN:
|
|
//下划，上面任务向下移动
|
|
ypos2_start = GUI_SCREEN_CENTER_Y - y_distance;
|
|
dy_auto = SWITCHING_UD_STEP;
|
|
break;
|
|
|
|
default:
|
|
halt(HALT_FUNC_SWITCH_UD_MODE);
|
|
return false;
|
|
}
|
|
compo_form_set_pos(frm_cur, GUI_SCREEN_CENTER_X, ypos2_start);
|
|
if (switch_mode == FUNC_SWITCH_UD_ZOOM_UP || switch_mode == FUNC_SWITCH_UD_ZOOM_DOWN) {
|
|
compo_form_scale_to(frm_cur, SWITCHING_UD_WIDTH, SWITCHING_UD_HEIGHT);
|
|
} else {
|
|
compo_form_scale_to(frm_cur, GUI_SCREEN_WIDTH, GUI_SCREEN_HEIGHT);
|
|
}
|
|
compo_form_set_alpha(frm_cur, SWITCHING_UD_ALPHA);
|
|
for (;;) {
|
|
flag_pos = FLAG_POS_NORM;
|
|
flag_change = false;
|
|
if (flag_press) {
|
|
s32 dx;
|
|
flag_press = ctp_get_dxy(&dx, &dy);
|
|
if (flag_press) {
|
|
if (tick_check_expire(tick, SWITCHING_TICK_AUTO)) {
|
|
switch (switch_mode) {
|
|
case FUNC_SWITCH_UD_UP:
|
|
case FUNC_SWITCH_UD_ZOOM_UP:
|
|
if (dy <= -SWITCHING_UD_DRAG_THRESHOLD) {
|
|
dy_auto = -SWITCHING_UD_STEP;
|
|
} else {
|
|
dy_auto = SWITCHING_UD_STEP;
|
|
}
|
|
break;
|
|
|
|
case FUNC_SWITCH_UD_DOWN:
|
|
case FUNC_SWITCH_UD_ZOOM_DOWN:
|
|
if (dy >= SWITCHING_UD_DRAG_THRESHOLD) {
|
|
dy_auto = SWITCHING_UD_STEP;
|
|
} else {
|
|
dy_auto = -SWITCHING_UD_STEP;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
halt(HALT_FUNC_SWITCH_MENU_MODE);
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
flag_change = true;
|
|
} else if (tick_check_expire(tick, SWITCHING_TICK_EXPIRE)) {
|
|
tick = tick_get();
|
|
dy += dy_auto;
|
|
flag_change = true;
|
|
}
|
|
|
|
if (flag_change) {
|
|
switch (switch_mode) {
|
|
case FUNC_SWITCH_UD_UP:
|
|
case FUNC_SWITCH_UD_ZOOM_UP:
|
|
if (dy >= 0) {
|
|
dy = 0;
|
|
flag_pos = FLAG_POS_START;
|
|
} else if (dy <= -y_distance) {
|
|
dy = -y_distance;
|
|
flag_pos = FLAG_POS_END;
|
|
}
|
|
break;
|
|
|
|
case FUNC_SWITCH_UD_DOWN:
|
|
case FUNC_SWITCH_UD_ZOOM_DOWN:
|
|
if (dy <= 0) {
|
|
dy = 0;
|
|
flag_pos = FLAG_POS_START;
|
|
} else if (dy >= y_distance) {
|
|
dy = y_distance;
|
|
flag_pos = FLAG_POS_END;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
halt(HALT_FUNC_SWITCH_UD_MODE);
|
|
return false;
|
|
}
|
|
ypos1 = GUI_SCREEN_CENTER_Y + dy;
|
|
ypos2 = ypos2_start + dy;
|
|
compo_form_set_pos(frm_last, GUI_SCREEN_CENTER_X, ypos1);
|
|
compo_form_set_pos(frm_cur, GUI_SCREEN_CENTER_X, ypos2);
|
|
if (switch_mode == FUNC_SWITCH_UD_ZOOM_UP || switch_mode == FUNC_SWITCH_UD_ZOOM_DOWN) {
|
|
s32 abs_dy = abs_s(dy);
|
|
s32 dw = (GUI_SCREEN_WIDTH - SWITCHING_UD_WIDTH) * abs_dy / y_distance;
|
|
s32 xw1 = GUI_SCREEN_WIDTH - dw;
|
|
s32 xw2 = SWITCHING_UD_WIDTH + dw;
|
|
s32 dh = (GUI_SCREEN_HEIGHT - SWITCHING_UD_HEIGHT) * abs_dy / y_distance;
|
|
s32 xh1 = GUI_SCREEN_HEIGHT - dh;
|
|
s32 xh2 = SWITCHING_UD_HEIGHT + dh;
|
|
u8 da = (255 - SWITCHING_UD_ALPHA) * abs_dy / y_distance;
|
|
u8 xa1 = 255 - da;
|
|
u8 xa2 = SWITCHING_UD_ALPHA + da;
|
|
compo_form_scale_to(frm_last, xw1, xh1);
|
|
compo_form_scale_to(frm_cur, xw2, xh2);
|
|
compo_form_set_alpha(frm_last, xa1);
|
|
compo_form_set_alpha(frm_cur, xa2);
|
|
}
|
|
}
|
|
func_process();
|
|
if (!flag_auto) {
|
|
func_switching_message(msg_dequeue());
|
|
if (func_switching_abort_need()) {
|
|
return false;
|
|
}
|
|
}
|
|
if (!flag_press && flag_pos != FLAG_POS_NORM) {
|
|
break;
|
|
}
|
|
}
|
|
return (flag_pos == FLAG_POS_END);
|
|
}
|
|
|
|
//上下帘菜单等切换
|
|
static bool func_switching_menu(u16 switch_mode, bool flag_auto)
|
|
{
|
|
compo_form_t *sub_frm = compo_pool_get_top();
|
|
bool flag_press = !flag_auto;
|
|
u8 flag_pos; //当前坐标状态
|
|
bool flag_change;
|
|
s32 dx = 0;
|
|
s32 dy = 0;
|
|
int dx_auto = 0;
|
|
int dy_auto = 0;
|
|
u32 tick = tick_get();
|
|
int xpos = GUI_SCREEN_CENTER_X;
|
|
int ypos = GUI_SCREEN_CENTER_Y;
|
|
if (sub_frm == NULL) {
|
|
halt(HALT_FUNC_SWITCH_MENU_PTR);
|
|
}
|
|
switch (switch_mode) {
|
|
case FUNC_SWITCH_MENU_DROPDOWN_UP:
|
|
case FUNC_SWITCH_MENU_PULLUP_UP:
|
|
//下拉往上, 上拉往上
|
|
dy_auto = -SWITCHING_MENU_STEP;
|
|
break;
|
|
|
|
case FUNC_SWITCH_MENU_DROPDOWN_DOWN:
|
|
case FUNC_SWITCH_MENU_PULLUP_DOWN:
|
|
//下拉往下, 上拉往下
|
|
dy_auto = SWITCHING_MENU_STEP;
|
|
break;
|
|
|
|
case FUNC_SWITCH_MENU_SIDE_POP:
|
|
//边菜单往右拉出
|
|
dx_auto = SWITCHING_MENU_STEP;
|
|
break;
|
|
|
|
case FUNC_SWITCH_MENU_SIDE_BACK:
|
|
//边菜单往左退回
|
|
dx_auto = -SWITCHING_MENU_STEP;
|
|
break;
|
|
|
|
default:
|
|
halt(HALT_FUNC_SWITCH_MENU_MODE);
|
|
break;
|
|
}
|
|
for (;;) {
|
|
flag_pos = FLAG_POS_NORM;
|
|
flag_change = false;
|
|
if (flag_press) {
|
|
flag_press = ctp_get_dxy(&dx, &dy);
|
|
if (flag_press) {
|
|
if (tick_check_expire(tick, SWITCHING_TICK_AUTO)) {
|
|
switch (switch_mode) {
|
|
case FUNC_SWITCH_MENU_DROPDOWN_UP:
|
|
case FUNC_SWITCH_MENU_PULLUP_UP:
|
|
//下拉往上, 上拉往上
|
|
if (dy <= -SWITCHING_MENU_DRAG_THRESHOLD) {
|
|
dy_auto = -SWITCHING_MENU_STEP;
|
|
} else {
|
|
dy_auto = SWITCHING_MENU_STEP;
|
|
}
|
|
break;
|
|
|
|
case FUNC_SWITCH_MENU_DROPDOWN_DOWN:
|
|
case FUNC_SWITCH_MENU_PULLUP_DOWN:
|
|
//下拉往下, 上拉往下
|
|
if (dy >= SWITCHING_MENU_DRAG_THRESHOLD) {
|
|
dy_auto = SWITCHING_MENU_STEP;
|
|
} else {
|
|
dy_auto = -SWITCHING_MENU_STEP;
|
|
}
|
|
break;
|
|
|
|
case FUNC_SWITCH_MENU_SIDE_POP:
|
|
//边菜单往右拉出
|
|
if (dx >= SWITCHING_MENU_DRAG_THRESHOLD) {
|
|
dx_auto = SWITCHING_MENU_STEP;
|
|
} else {
|
|
dx_auto = -SWITCHING_MENU_STEP;
|
|
}
|
|
break;
|
|
|
|
case FUNC_SWITCH_MENU_SIDE_BACK:
|
|
//边菜单往左退回
|
|
if (dx <= -SWITCHING_MENU_DRAG_THRESHOLD) {
|
|
dx_auto = -SWITCHING_MENU_STEP;
|
|
} else {
|
|
dx_auto = SWITCHING_MENU_STEP;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
halt(HALT_FUNC_SWITCH_MENU_MODE);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
flag_change = true;
|
|
} else if (tick_check_expire(tick, SWITCHING_TICK_EXPIRE)) {
|
|
tick = tick_get();
|
|
dx += dx_auto;
|
|
dy += dy_auto;
|
|
flag_change = true;
|
|
}
|
|
if (flag_change) {
|
|
switch (switch_mode) {
|
|
case FUNC_SWITCH_MENU_DROPDOWN_UP:
|
|
case FUNC_SWITCH_MENU_PULLUP_UP:
|
|
//下拉往上, 上拉往上
|
|
if (dy >= 0) {
|
|
dy = 0;
|
|
flag_pos = FLAG_POS_START;
|
|
ypos = GUI_SCREEN_CENTER_Y;
|
|
} else if (dy <= -GUI_SCREEN_HEIGHT) {
|
|
dy = -GUI_SCREEN_HEIGHT;
|
|
flag_pos = FLAG_POS_END;
|
|
ypos = GUI_SCREEN_CENTER_Y - GUI_SCREEN_HEIGHT;
|
|
}
|
|
ypos = flag_pos == FLAG_POS_NORM ? GUI_SCREEN_CENTER_Y + dy : ypos;
|
|
if (switch_mode == FUNC_SWITCH_MENU_PULLUP_UP) {
|
|
ypos += GUI_SCREEN_HEIGHT;
|
|
}
|
|
break;
|
|
|
|
case FUNC_SWITCH_MENU_DROPDOWN_DOWN:
|
|
case FUNC_SWITCH_MENU_PULLUP_DOWN:
|
|
//下拉往下, 上拉往下
|
|
if (dy <= 0) {
|
|
dy = 0;
|
|
flag_pos = FLAG_POS_START;
|
|
ypos = GUI_SCREEN_CENTER_Y - GUI_SCREEN_HEIGHT;
|
|
} else if (dy >= GUI_SCREEN_HEIGHT) {
|
|
dy = GUI_SCREEN_HEIGHT;
|
|
flag_pos = FLAG_POS_END;
|
|
ypos = GUI_SCREEN_CENTER_Y;
|
|
}
|
|
ypos = flag_pos == FLAG_POS_NORM ? -GUI_SCREEN_CENTER_Y + dy : ypos;
|
|
if (switch_mode == FUNC_SWITCH_MENU_PULLUP_DOWN) {
|
|
ypos += GUI_SCREEN_HEIGHT;
|
|
}
|
|
break;
|
|
|
|
case FUNC_SWITCH_MENU_SIDE_POP:
|
|
//边菜单往右拉出
|
|
if (dx <= 0) {
|
|
dx = 0;
|
|
flag_pos = FLAG_POS_START;
|
|
} else if (dx >= GUI_SIDE_MENU_WIDTH) {
|
|
dx = GUI_SIDE_MENU_WIDTH;
|
|
flag_pos = FLAG_POS_END;
|
|
}
|
|
xpos = -(GUI_SIDE_MENU_WIDTH / 2) + dx;
|
|
break;
|
|
|
|
case FUNC_SWITCH_MENU_SIDE_BACK:
|
|
//边菜单往左退回
|
|
if (dx >= 0) {
|
|
dx = 0;
|
|
flag_pos = FLAG_POS_START;
|
|
} else if (dx <= -GUI_SIDE_MENU_WIDTH) {
|
|
dx = -GUI_SIDE_MENU_WIDTH;
|
|
flag_pos = FLAG_POS_END;
|
|
}
|
|
xpos = (GUI_SIDE_MENU_WIDTH / 2) + dx;
|
|
break;
|
|
|
|
default:
|
|
halt(HALT_FUNC_SWITCH_MENU_MODE);
|
|
break;
|
|
}
|
|
compo_form_set_pos(sub_frm, xpos, ypos);
|
|
}
|
|
func_process();
|
|
if (!flag_auto) {
|
|
func_switching_message(msg_dequeue());
|
|
if (func_switching_abort_need()) {
|
|
return false;
|
|
}
|
|
}
|
|
if (!flag_press && flag_pos != FLAG_POS_NORM) {
|
|
break;
|
|
}
|
|
}
|
|
return (flag_pos == FLAG_POS_END);
|
|
}
|
|
|
|
//缩放进出
|
|
#define RATE_FIX0 12/13
|
|
#define RATE_FIX1 13/12
|
|
static bool func_switching_zoom(u16 switch_mode, bool flag_auto, widget_icon_t *icon)
|
|
{
|
|
compo_form_t *frm_back = compo_pool_get_bottom();
|
|
compo_form_t *frm_cur = compo_pool_get_top();
|
|
bool flag_press, flag_rolling, flag_roll;
|
|
u8 flag_pos; //当前状态
|
|
bool flag_change;
|
|
s32 dx = 0;
|
|
s32 dx_target = 0;
|
|
int dx_auto;
|
|
rect_t area;
|
|
s32 cur_rate_start, cur_rate, cur_x, cur_y, cur_wid, cur_hei, cur_alpha, cur_show_hei;
|
|
s32 cur_show_hei_delta_h, cur_show_hei_delta_s;
|
|
s32 back_rate, back_x, back_y, back_wid, back_hei, back_alpha, back_hide_hei;
|
|
s32 d_rate;
|
|
u32 tick = tick_get();
|
|
|
|
if (icon == NULL) {
|
|
halt(HALT_FUNC_SWITCH_ZOOM_PTR);
|
|
}
|
|
widget_page_update();
|
|
area = widget_get_absolute(icon);
|
|
area.x -= GUI_SCREEN_CENTER_X;
|
|
area.y -= GUI_SCREEN_CENTER_Y;
|
|
if (!widget_is_icon(icon)) {
|
|
halt(HALT_FUNC_SWITCH_ZOOM_PARAM);
|
|
}
|
|
if (area.wid <= 0 || area.hei <= 0) {
|
|
return false;
|
|
}
|
|
|
|
cur_show_hei = (area.hei * 3) >> 1; //图标与应用显示分界
|
|
back_hide_hei = area.hei * 2;
|
|
|
|
cur_show_hei_delta_h = back_hide_hei - area.hei;
|
|
cur_show_hei_delta_s = GUI_SCREEN_HEIGHT - cur_show_hei;
|
|
flag_press = false;
|
|
flag_roll = false;
|
|
flag_rolling = false;
|
|
// printf("func_switching_zoom switch_mode = %d flag_auto = %d %d %d\n",switch_mode,flag_auto,cur_show_hei,back_hide_hei);
|
|
switch (switch_mode) {
|
|
case FUNC_SWITCH_ZOOM_ENTER:
|
|
flag_rolling = flag_roll = !flag_auto; //手动滚动进入
|
|
dx_target = dx + SWITCHING_ZOOM_ROLL_STEP;
|
|
dx_auto = flag_auto ? SWITCHING_ZOOM_STEP : -SWITCHING_ZOOM_STEP;
|
|
cur_rate = cur_rate_start = (area.hei << 16) / GUI_SCREEN_HEIGHT * RATE_FIX0;
|
|
back_rate = 0x10000;
|
|
d_rate = (GUI_SCREEN_HEIGHT << 16) / (GUI_SCREEN_HEIGHT - area.hei);
|
|
cur_alpha = 0;
|
|
back_alpha = 255;
|
|
break;
|
|
|
|
case FUNC_SWITCH_ZOOM_EXIT:
|
|
flag_press = !flag_auto; //手动滑动退出
|
|
dx_auto = flag_auto ? SWITCHING_ZOOM_STEP : -SWITCHING_ZOOM_STEP;
|
|
cur_rate = 0x10000;
|
|
back_rate = (GUI_SCREEN_HEIGHT << 16) / area.hei * RATE_FIX1;
|
|
d_rate = (GUI_SCREEN_HEIGHT << 16) / (GUI_SCREEN_HEIGHT - area.hei);
|
|
cur_alpha = 255;
|
|
back_alpha = 0;
|
|
break;
|
|
|
|
default:
|
|
halt(HALT_FUNC_SWITCH_ZOOM_MODE);
|
|
return false;
|
|
}
|
|
cur_x = muls_shift16(muls_shift16(area.x, 0x10000 - cur_rate), d_rate);
|
|
cur_y = muls_shift16(muls_shift16(area.y, 0x10000 - cur_rate), d_rate);
|
|
back_x = muls_shift16(muls_shift16(area.x, 0x10000 - back_rate), d_rate);
|
|
back_y = muls_shift16(muls_shift16(area.y, 0x10000 - back_rate), d_rate);
|
|
cur_wid = muls_shift16(GUI_SCREEN_WIDTH, cur_rate);
|
|
cur_hei = muls_shift16(GUI_SCREEN_HEIGHT, cur_rate);
|
|
back_wid = muls_shift16(GUI_SCREEN_WIDTH, back_rate);
|
|
back_hei = muls_shift16(GUI_SCREEN_HEIGHT, back_rate);
|
|
compo_form_set_pos(frm_cur, GUI_SCREEN_CENTER_X + cur_x, GUI_SCREEN_CENTER_Y + cur_y);
|
|
compo_form_set_pos(frm_back, GUI_SCREEN_CENTER_X + back_x, GUI_SCREEN_CENTER_Y + back_y);
|
|
compo_form_scale_to(frm_cur, cur_wid, cur_hei);
|
|
compo_form_scale_to(frm_back, back_wid, back_hei);
|
|
compo_form_set_alpha(frm_cur, cur_alpha);
|
|
widget_set_alpha(icon, back_alpha);
|
|
// printf("func_switching_zoom1 %d %d %d %d\n",cur_wid,cur_hei,back_wid,back_hei);
|
|
for (;;) {
|
|
flag_pos = FLAG_POS_NORM;
|
|
flag_change = false;
|
|
if (flag_press) {
|
|
s32 dy;
|
|
if (switch_mode == FUNC_SWITCH_ZOOM_EXIT) {
|
|
flag_press = ctp_get_dxy(&dx, &dy);
|
|
if (flag_press) {
|
|
if (dx <= SWITCHING_ZOOM_EXIT_THRESHOLD) {
|
|
dx_auto = -SWITCHING_ZOOM_STEP;
|
|
} else {
|
|
dx_auto = SWITCHING_ZOOM_STEP;
|
|
}
|
|
}
|
|
}
|
|
flag_change = true;
|
|
} else if (flag_rolling) {
|
|
if (dx != dx_target) {
|
|
if (tick_check_expire(tick, SWITCHING_TICK_EXPIRE)) {
|
|
tick = tick_get();
|
|
dx_auto = (dx_target - dx);
|
|
if (dx_auto > SWITCHING_ZOOM_ROLL_STEP_PER) {
|
|
dx_auto = (dx_target - dx) / SWITCHING_ZOOM_ROLL_KICK_CNT;
|
|
if (dx_auto < SWITCHING_ZOOM_ROLL_STEP_PER) {
|
|
dx_auto = SWITCHING_ZOOM_ROLL_STEP_PER;
|
|
}
|
|
} else if (dx_auto < -SWITCHING_ZOOM_ROLL_STEP_PER) {
|
|
dx_auto = (dx_target - dx) / SWITCHING_ZOOM_ROLL_KICK_CNT;
|
|
if (dx_auto > -SWITCHING_ZOOM_ROLL_STEP_PER) {
|
|
dx_auto = -SWITCHING_ZOOM_ROLL_STEP_PER;
|
|
}
|
|
}
|
|
dx += dx_auto;
|
|
flag_change = true;
|
|
if (dx >= GUI_SCREEN_WIDTH / 2) {
|
|
flag_roll = false;
|
|
flag_rolling = false;
|
|
dx_auto = SWITCHING_ZOOM_ROLL_STEP_PER * 2;
|
|
}
|
|
}
|
|
}
|
|
if (tick_check_expire(tick, SWITCHING_ZOOM_ROLL_TICK_EXPIRE)) {
|
|
dx_auto = -SWITCHING_ZOOM_ROLL_STEP * 2 / SWITCHING_ZOOM_ROLL_KICK_CNT;
|
|
flag_rolling = false;
|
|
}
|
|
} else if (tick_check_expire(tick, SWITCHING_TICK_EXPIRE)) {
|
|
tick = tick_get();
|
|
dx += dx_auto;
|
|
flag_change = true;
|
|
}
|
|
if (flag_change) {
|
|
switch (switch_mode) {
|
|
case FUNC_SWITCH_ZOOM_ENTER:
|
|
//图标放大
|
|
|
|
if (dx <= 0) {
|
|
dx = 0;
|
|
flag_pos = FLAG_POS_START;
|
|
flag_roll = false;
|
|
// } else if (dx >= GUI_SCREEN_WIDTH) {
|
|
// dx = GUI_SCREEN_WIDTH;
|
|
// flag_pos = FLAG_POS_END;
|
|
// flag_roll = false;
|
|
}
|
|
if (dx == 0) {
|
|
cur_rate = cur_rate_start;
|
|
back_rate = 0x10000;
|
|
} else {
|
|
cur_rate = cur_rate_start + (dx << 16) / GUI_SCREEN_WIDTH;
|
|
back_rate = (GUI_SCREEN_HEIGHT * cur_rate) / area.hei * RATE_FIX1;
|
|
if (cur_rate >= 0x10000) {
|
|
cur_rate = 0x10000;
|
|
back_rate = (GUI_SCREEN_HEIGHT << 16) / area.hei;
|
|
flag_pos = FLAG_POS_END;
|
|
}
|
|
}
|
|
// printf("cur_rate_start = %d,cur_rate = %d dx = %d\n",cur_rate_start,cur_rate,dx);
|
|
break;
|
|
|
|
case FUNC_SWITCH_ZOOM_EXIT:
|
|
//图标缩小
|
|
if (dx <= 0) {
|
|
dx = 0;
|
|
flag_pos = FLAG_POS_START;
|
|
} else if (dx >= GUI_SCREEN_WIDTH) {
|
|
dx = GUI_SCREEN_WIDTH;
|
|
flag_pos = FLAG_POS_END;
|
|
}
|
|
cur_rate = 0x10000 - (dx << 16) / GUI_SCREEN_WIDTH;
|
|
back_rate = (GUI_SCREEN_HEIGHT * cur_rate) / area.hei * RATE_FIX1;
|
|
if (back_rate <= 0x10000) {
|
|
back_rate = 0x10000;
|
|
cur_rate = (area.hei << 16) / GUI_SCREEN_HEIGHT;
|
|
flag_pos = FLAG_POS_END;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
halt(HALT_FUNC_SWITCH_ZOOM_MODE);
|
|
break;
|
|
}
|
|
cur_x = muls_shift16(muls_shift16(area.x, 0x10000 - cur_rate), d_rate);
|
|
cur_y = muls_shift16(muls_shift16(area.y, 0x10000 - cur_rate), d_rate);
|
|
back_x = muls_shift16(muls_shift16(area.x, 0x10000 - back_rate), d_rate);
|
|
back_y = muls_shift16(muls_shift16(area.y, 0x10000 - back_rate), d_rate);
|
|
cur_wid = muls_shift16(GUI_SCREEN_WIDTH, cur_rate);
|
|
cur_hei = muls_shift16(GUI_SCREEN_HEIGHT, cur_rate);
|
|
back_wid = muls_shift16(GUI_SCREEN_WIDTH, back_rate);
|
|
back_hei = muls_shift16(GUI_SCREEN_HEIGHT, back_rate);
|
|
if (cur_hei >= cur_show_hei) {
|
|
cur_alpha = SWITCHING_ZOOM_ALPHA + (255 - SWITCHING_ZOOM_ALPHA) * (cur_hei - cur_show_hei) / cur_show_hei_delta_s;
|
|
} else {
|
|
cur_alpha = 0;
|
|
}
|
|
if (cur_hei >= back_hide_hei) {
|
|
back_alpha = 0;
|
|
} else if (cur_hei > area.hei) {
|
|
back_alpha = SWITCHING_ZOOM_ALPHA_BMAX - (SWITCHING_ZOOM_ALPHA_BMAX - SWITCHING_ZOOM_ALPHA) * (cur_hei - area.hei) / cur_show_hei_delta_h;
|
|
} else {
|
|
back_alpha = 255;
|
|
}
|
|
compo_form_set_pos(frm_cur, GUI_SCREEN_CENTER_X + cur_x, GUI_SCREEN_CENTER_Y + cur_y);
|
|
compo_form_set_pos(frm_back, GUI_SCREEN_CENTER_X + back_x, GUI_SCREEN_CENTER_Y + back_y);
|
|
compo_form_scale_to(frm_cur, cur_wid, cur_hei);
|
|
compo_form_scale_to(frm_back, back_wid, back_hei);
|
|
compo_form_set_alpha(frm_cur, cur_alpha);
|
|
widget_set_alpha(icon, back_alpha);
|
|
// printf("func_switching_zoom2 %d, %d , %d , %d , %d , %d , %d\n",cur_x,cur_y,cur_rate,cur_wid,cur_hei,back_wid,back_hei);
|
|
}
|
|
func_process();
|
|
if (!flag_auto) {
|
|
if (flag_roll) {
|
|
//获取滚动消息
|
|
size_msg_t msg = msg_dequeue();
|
|
switch (msg) {
|
|
case MSG_QDEC_FORWARD:
|
|
tick = tick_get();
|
|
flag_rolling = true;
|
|
dx_target += SWITCHING_ZOOM_ROLL_STEP;
|
|
break;
|
|
|
|
case MSG_QDEC_BACKWARD:
|
|
tick = tick_get();
|
|
flag_rolling = true;
|
|
dx_target -= SWITCHING_ZOOM_ROLL_STEP;
|
|
break;
|
|
|
|
default:
|
|
func_switching_message(msg);
|
|
if (func_switching_abort_need()) {
|
|
return false;
|
|
}
|
|
break;
|
|
}
|
|
} else {
|
|
func_switching_message(msg_dequeue());
|
|
if (func_switching_abort_need()) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
if (flag_pos != FLAG_POS_NORM) {
|
|
break;
|
|
}
|
|
}
|
|
return (flag_pos == FLAG_POS_END);
|
|
}
|
|
|
|
//缩放淡入淡出
|
|
static bool func_switching_zoom_fade(u16 switch_mode, bool flag_auto)
|
|
{
|
|
compo_form_t *frm_back = compo_pool_get_bottom();
|
|
compo_form_t *frm_cur = compo_pool_get_top();
|
|
u8 flag_pos; //当前状态
|
|
s32 back_rate, back_wid, back_hei;
|
|
s32 cur_alpha, back_alpha;
|
|
s32 zoom_rate;
|
|
u32 tick = tick_get();
|
|
|
|
//cur_show_hei = area.hei * 2; //图标与应用显示分界
|
|
switch (switch_mode) {
|
|
case FUNC_SWITCH_ZOOM_FADE_ENTER:
|
|
back_rate = 0x10000;
|
|
zoom_rate = SWITCHING_ZOOM_FADE_RATE;
|
|
cur_alpha = 0;
|
|
back_alpha = 255;
|
|
break;
|
|
|
|
case FUNC_SWITCH_ZOOM_FADE_EXIT:
|
|
back_rate = SWITCHING_ZOOM_FADE_MAX;
|
|
zoom_rate = (256 * 256 / SWITCHING_ZOOM_FADE_RATE);
|
|
cur_alpha = 255;
|
|
back_alpha = 0;
|
|
break;
|
|
|
|
default:
|
|
halt(HALT_FUNC_SWITCH_ZOOM_MODE);
|
|
return false;
|
|
}
|
|
|
|
back_wid = muls_shift16(GUI_SCREEN_WIDTH, back_rate);
|
|
back_hei = muls_shift16(GUI_SCREEN_HEIGHT, back_rate);
|
|
compo_form_scale_to(frm_back, back_wid, back_hei);
|
|
compo_form_set_alpha(frm_cur, cur_alpha);
|
|
compo_form_set_alpha(frm_back, back_alpha);
|
|
for (;;) {
|
|
flag_pos = FLAG_POS_NORM;
|
|
if (tick_check_expire(tick, SWITCHING_TICK_EXPIRE)) {
|
|
tick = tick_get();
|
|
switch (switch_mode) {
|
|
case FUNC_SWITCH_ZOOM_FADE_ENTER:
|
|
//图标放大
|
|
back_rate = (back_rate * zoom_rate) >> 8;
|
|
if (back_rate >= SWITCHING_ZOOM_FADE_MAX) {
|
|
back_rate = SWITCHING_ZOOM_FADE_MAX;
|
|
flag_pos = FLAG_POS_END;
|
|
}
|
|
break;
|
|
|
|
case FUNC_SWITCH_ZOOM_FADE_EXIT:
|
|
//图标缩小
|
|
back_rate = (back_rate * zoom_rate) >> 8;
|
|
if (back_rate <= 0x10000) {
|
|
back_rate = 0x10000;
|
|
flag_pos = FLAG_POS_END;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
halt(HALT_FUNC_SWITCH_ZOOM_MODE);
|
|
break;
|
|
}
|
|
back_wid = muls_shift16(GUI_SCREEN_WIDTH, back_rate);
|
|
back_hei = muls_shift16(GUI_SCREEN_HEIGHT, back_rate);
|
|
if (back_rate > SWITCHING_ZOOM_FADE_1) {
|
|
cur_alpha = 255 * (back_rate - SWITCHING_ZOOM_FADE_1) / (SWITCHING_ZOOM_FADE_MAX - SWITCHING_ZOOM_FADE_1);
|
|
} else {
|
|
cur_alpha = 0;
|
|
}
|
|
if (back_rate < SWITCHING_ZOOM_FADE_2) {
|
|
back_alpha = 255 - 255 * (back_rate - 0x10000) / (SWITCHING_ZOOM_FADE_2 - 0x10000);
|
|
} else {
|
|
back_alpha = 0;
|
|
}
|
|
compo_form_scale_to(frm_back, back_wid, back_hei);
|
|
compo_form_set_alpha(frm_cur, cur_alpha);
|
|
compo_form_set_alpha(frm_back, back_alpha);
|
|
}
|
|
func_process();
|
|
if (!flag_auto) {
|
|
func_switching_message(msg_dequeue());
|
|
if (func_switching_abort_need()) {
|
|
return false;
|
|
}
|
|
}
|
|
if (flag_pos != FLAG_POS_NORM) {
|
|
break;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
//切换场景
|
|
bool func_switching(u16 switch_mode, void *param)
|
|
{
|
|
if (switch_mode == FUNC_SWITCH_DIRECT) {
|
|
return true;
|
|
}
|
|
if (switch_mode == FUNC_SWITCH_CANCEL) {
|
|
halt(HALT_FUNC_SWITCH_MODE);
|
|
}
|
|
bool flag_auto = ((switch_mode & FUNC_SWITCH_AUTO) != 0);
|
|
switch_mode = switch_mode & 0x7FFF;
|
|
if (switch_mode < FUNC_SWITCH_LR) {
|
|
return func_switching_fade(switch_mode, flag_auto); //淡入淡出
|
|
} else if (switch_mode < FUNC_SWITCH_UD) {
|
|
return func_switching_lr(switch_mode, flag_auto); //左右切换任务
|
|
} else if (switch_mode < FUNC_SWITCH_MENU) {
|
|
return func_switching_ud(switch_mode, flag_auto); //上下切换任务
|
|
} else if (switch_mode < FUNC_SWITCH_ZOOM) {
|
|
return func_switching_menu(switch_mode, flag_auto); //切换上下帘及边栏
|
|
} else if (switch_mode < FUNC_SWITCH_ZOOM_FADE) {
|
|
return func_switching_zoom(switch_mode, flag_auto, param); //缩放进出
|
|
} else {
|
|
return func_switching_zoom_fade(switch_mode, flag_auto); //缩放加淡入淡出
|
|
}
|
|
}
|