#include "include.h"
#include "func.h"
#include "spirit_island_api.h"
#if TRACE_EN
#define TRACE(...)              printf(__VA_ARGS__)
#else
#define TRACE(...)
#endif

static void func_stopwatch_record_pos_update(void);

#define NUM_REC_COLOR                       make_color(9, 9, 9)
#define NUM_REC_COLOR_LAST                  make_color(131, 131, 131)

#define LINE_REC_COLOR                      make_color(160, 160, 160)
#define LINE_REC_COLOR_LAST                 make_color(192, 192, 192)

#define BIG_SECONDS_CLOCK_X                 GUI_SCREEN_CENTER_X
#define BIG_SECONDS_CLOCK_Y                 140
#define BIG_SECONDS_WIDTH                   204
#define BIG_SECONDS_HEIGHT                  204
#define BIG_SECONDS_POINTER_WIDTH           12
#define BIG_SECONDS_POINTER_HEIGHT          117
#define BIG_SECONDS_POINTER_OFFSET_X        6
#define BIG_SECONDS_POINTER_OFFSET_Y        100
#define MINUTE_POINTER_OFFSET_X             4
#define MINUTE_POINTER_OFFSET_Y             30

#define MINUTE_CLOCK_X                      48
#define SMALL_CLOCK_WIDTH                   60
#define SMALL_CLOCK_HEIGHT                  60
#define SECONDS_CLOCK_X                     GUI_SCREEN_CENTER_X
#define SMALL_CLOCK_Y                       100
#define SECONDS_POINTER_WIDTH               8
#define SECONDS_HEIGHT                      32
#define MILLSECONDS_CLOCK_X                 194
#define SMALL_CLOCK_Y                       100
#define SMALL_CLOCK_Y2                      75
#define SMALL_CLOCK_Y3                      35

#define RECODE_LINE_HEIGHT                  2
#define RECODE_FIRST_LINE_X                 20
#define RECODE_LAST_LINE_X                  220

#define RECODE_FIRST_LINE_Y                 136
#define RECODE_CENTRE_LINE_Y                168
#define RECODE_LAST_LINE_Y                  296

#define RECODE_ITEM_HEIGHT                  34
#define RECODE_LIST_HEIGHT                  100
#define RECODE_LIST_ROLL_MIN                3

#define RECODE_LIST_BG_X                    RECODE_FIRST_LINE_X
#define RECODE_LIST_BG_W                    RECODE_LAST_LINE_X - RECODE_LIST_BG_X
#define RECODE_LIST_NUM_X                   RECODE_FIRST_LINE_X
#define RECODE_LIST_NUM_W                   100
#define RECODE_LIST_DATA_X                  RECODE_LIST_NUM_X + RECODE_LIST_NUM_W
#define RECODE_LIST_DATA_W                  RECODE_LIST_BG_W - RECODE_LIST_NUM_W

#define SPRING_Y_MAX                        0                               // 回弹到顶部时的ofs_y
#define SPRING_Y_MIN                        (-2 * GUI_SCREEN_HEIGHT)        // 回弹到底部时的ofs_y
#define DRAG_Y_MAX                          (SPRING_Y_MAX)                  // 拖动到顶部时的ofs_y
#define DRAG_Y_MIN                          (SPRING_Y_MIN)

#define TIME_BG_X                           GUI_SCREEN_CENTER_X             // 时钟背景
#define TIME_BG_Y                           168
#define TIME_BG_W                           220
#define TIME_BG_H                           TIME_BG_W
#define TIME_BG_Y2                          130
#define TIME_BG_Y3                          95
#define TIME_BG_MAX_H                       42
#define TIME_BG_ZOOM_RATIO                  230                             // (2.3)放大100倍

#define FOCUS_AUTO_TICK_EXPIRE              18                              // 松手后自动对齐焦点单位时间(ms)
#define FOCUS_AUTO_STEP                     12                              // 松手后自动对齐焦点单位时间步进
#define FOCUS_AUTO_STEP_DIV                 8
#define FOCUS_AUTO_EXCESS                   4                               // 回弹延迟距离
#define DRAG_AUTO_SPEED                     1                               // 拖动松手后的速度(惯性)
#define GUI_PAGE_TIME_WIDTH                 (GUI_SCREEN_WIDTH * 2 / 5 - 8)
#define GUI_PAGE_NUM                        (3)

//组件ID
enum
{
    /* 记录列表 */
    COMPO_ID_LIST_RECORD_BG = 0x01,
    COMPO_ID_LIST_RECORD_BG_MAX     = COMPO_ID_LIST_RECORD_BG + STOPWATCH_REC_NUM_MAX,

    COMPO_ID_LIST_RECORD_NUM,
    COMPO_ID_LIST_RECORD_NUM_MAX    = COMPO_ID_LIST_RECORD_NUM + STOPWATCH_REC_NUM_MAX,

    COMPO_ID_LIST_RECORD_DATA,
    COMPO_ID_LIST_RECORD_DATA_MAX   = COMPO_ID_LIST_RECORD_DATA + STOPWATCH_REC_NUM_MAX,

    COMPO_ID_RECT_BG_UP,                // 遮住列表上方矩形区域

    COMPO_ID_BIG_SECONDS_CLOCK,         // 大秒钟模拟时钟
    COMPO_ID_BIG_SECONDS_CLOCK_REC,     // 记录指针
    COMPO_ID_BIG_SECONDS_CLOCK_POINTER, // 指针
    COMPO_ID_MINUTE_CLOCK,              // 分钟模拟时钟
    COMPO_ID_MINUTE_CLOCK_POINTER,      // 指针
    COMPO_ID_SECONDS_CLOCK,             // 秒钟模拟时钟
    COMPO_ID_SECONDS_CLOCK_POINTER,     // 秒钟指针
    COMPO_ID_MILLSECONDS_CLOCK,         // 毫秒模拟时钟
    COMPO_ID_MILLSECONDS_CLOCK_POINTER, // 指针
    COMPO_ID_BTN_RECORD,                // 记录当前时间
    COMPO_ID_BTN_AFRESH,                // 重新开始
    COMPO_ID_BTN_START_REC,             // 开始计时
    COMPO_ID_NUM_STOPWATCH_TIME,        // 当前计时
    COMPO_ID_PAGE_INDEX_1,              // 当前计时
    COMPO_ID_PAGE_INDEX_2,              // 当前计时
    COMPO_ID_PAGE_INDEX_3,              // 当前计时
};

typedef struct f_stopwatch_t_ {
    compo_listbox_t *listbox;
    u8 min;                 //分
    u8 sec;                 //秒
    u16 msec;               //毫秒

    /* 分段记录 */
    bool list_drag;
    s16  list_offset;
    s16  list_offset_temp;
    s16  list_start_pos;
    u32  list_pos_tick;

    s32  last_move_y;
    s32  last_move_x;
    s32  auto_move_y;
    u32  tick;
    s32  ofs_y;
    s32  ofs_y_drag;
    s8   focus_card;        // 靠近屏幕中央的卡片序号
    bool page_drag_flag;    // 开始拖动
    bool flag_move_auto;    // 自动移到坐标
    s32  moveto_y;          // 设定自动移到的坐标
} f_stopwatch_t;

/* 页面总体位置偏移 */
static s32 stopwatch_ofs_y = 0;

//限制滑动偏移位置
static s16 func_stopwatch_limit_y(s16 ofs_y)
{
    ofs_y = MIN(DRAG_Y_MAX, MAX(DRAG_Y_MIN, ofs_y));
    // printf("func_stopwatch_limit_y[%d,%d,%d]\n",DRAG_Y_MIN,DRAG_Y_MAX,ofs_y);
    return ofs_y;
}

//根据偏移位置把最近的卡片对齐到屏幕中央
static s16 func_stopwatch_align_y(s16 ofs_y)
{
    if (ofs_y > DRAG_Y_MIN / 4)
    {
        ofs_y = 0;
    }
    else if ((ofs_y >= DRAG_Y_MIN / 2) && (ofs_y < DRAG_Y_MIN / 4))
    {
        ofs_y = DRAG_Y_MIN / 2;
    }
    else if ((ofs_y >= DRAG_Y_MIN * 3 / 4) && (ofs_y < DRAG_Y_MIN / 2))
    {
        ofs_y = DRAG_Y_MIN / 2;
    }
    else if ((ofs_y < DRAG_Y_MIN * 3 / 4))
    {
        ofs_y = DRAG_Y_MIN;
    }

    return (ofs_y);
}

//更新组件位置和大小
static void func_stopwatch_compo_update(s32 ofs_y, bool creating)
{
    f_stopwatch_t *f_stopwatch = (f_stopwatch_t *)func_cb.f_cb;

    u8 transparent = 0;
    s16 x = 0, y = 0, w = 0, h = 0;

    compo_shape_t *rect_bg;
    compo_cardbox_t *cardbox;
    compo_picturebox_t *pic;

    component_t *compo = (component_t *)compo_pool_get_top();

    while (compo != NULL)
    {
        // 获取初始值
        switch (compo->id)
        {
        case COMPO_ID_BIG_SECONDS_CLOCK: // 时钟
            x = BIG_SECONDS_CLOCK_X;
            if ((ofs_y >= DRAG_Y_MIN / 2) && (ofs_y <= 0))
            {
                y = SMALL_CLOCK_Y2 + (GUI_SCREEN_HEIGHT + ofs_y) * (BIG_SECONDS_CLOCK_Y - SMALL_CLOCK_Y2) / GUI_SCREEN_HEIGHT;
                w = SMALL_CLOCK_WIDTH + (GUI_SCREEN_HEIGHT + ofs_y) * (BIG_SECONDS_WIDTH - SMALL_CLOCK_WIDTH) / GUI_SCREEN_HEIGHT;
                h = w;
                transparent = (GUI_SCREEN_HEIGHT + ofs_y) * (255) / GUI_SCREEN_HEIGHT;
                //   printf("ofs_y1 = %d,y = %d,w = %d,h = %d\n",ofs_y,y,w,h);
            }
            else if ((ofs_y >= DRAG_Y_MIN) && (ofs_y < DRAG_Y_MIN / 2))
            {
                y = SMALL_CLOCK_Y2;
                w = SMALL_CLOCK_WIDTH;
                h = w;
                transparent = 0;
                //   printf("ofs_y2 = %d,y = %d,w = %d,h = %d\n",ofs_y,y,w,h);
            }
            pic = (compo_picturebox_t *)compo;
            compo_picturebox_set_alpha(pic, transparent);
            compo_picturebox_set_pos(pic, x, y);
            compo_picturebox_set_size(pic, w, h);
            break;
        case COMPO_ID_BIG_SECONDS_CLOCK_REC: // 时钟
            x = BIG_SECONDS_CLOCK_X;
            if ((ofs_y >= DRAG_Y_MIN / 2) && (ofs_y <= 0))
            {
                y = SMALL_CLOCK_Y2 + (GUI_SCREEN_HEIGHT + ofs_y) * (BIG_SECONDS_CLOCK_Y - SMALL_CLOCK_Y2) / GUI_SCREEN_HEIGHT;
                w = SECONDS_POINTER_WIDTH + (GUI_SCREEN_HEIGHT + ofs_y) * (BIG_SECONDS_POINTER_WIDTH - SECONDS_POINTER_WIDTH) / GUI_SCREEN_HEIGHT;
                h = SECONDS_HEIGHT + (GUI_SCREEN_HEIGHT + ofs_y) * (BIG_SECONDS_POINTER_HEIGHT - SECONDS_HEIGHT) / GUI_SCREEN_HEIGHT;
                transparent = (GUI_SCREEN_HEIGHT + ofs_y) * (255) / GUI_SCREEN_HEIGHT;
                //    printf("ofs_y1 = %d,y = %d,w = %d,h = %d\n",ofs_y,y,w,h);
            }
            else if ((ofs_y >= DRAG_Y_MIN) && (ofs_y < DRAG_Y_MIN / 2))
            {
                y = SMALL_CLOCK_Y2;
                w = SECONDS_POINTER_WIDTH;
                h = SECONDS_HEIGHT;
                transparent = 0;
                //    printf("ofs_y2 = %d,y = %d,w = %d,h = %d\n",ofs_y,y,w,h);
            }
            pic = (compo_picturebox_t *)compo;
            compo_picturebox_set_alpha(pic, transparent);
            compo_picturebox_set_pos(pic, x, y);
            compo_picturebox_set_size(pic, w, h);
            break;
        case COMPO_ID_BIG_SECONDS_CLOCK_POINTER: // 时钟
            x = BIG_SECONDS_CLOCK_X;
            if ((ofs_y >= DRAG_Y_MIN / 2) && (ofs_y <= 0))
            {
                y = SMALL_CLOCK_Y2 + (GUI_SCREEN_HEIGHT + ofs_y) * (BIG_SECONDS_CLOCK_Y - SMALL_CLOCK_Y2) / GUI_SCREEN_HEIGHT;
                w = SECONDS_POINTER_WIDTH + (GUI_SCREEN_HEIGHT + ofs_y) * (BIG_SECONDS_POINTER_WIDTH - SECONDS_POINTER_WIDTH) / GUI_SCREEN_HEIGHT;
                h = SECONDS_HEIGHT + (GUI_SCREEN_HEIGHT + ofs_y) * (BIG_SECONDS_POINTER_HEIGHT - SECONDS_HEIGHT) / GUI_SCREEN_HEIGHT;
                transparent = (GUI_SCREEN_HEIGHT + ofs_y) * (255) / GUI_SCREEN_HEIGHT;
            } 
            else if ((ofs_y >= DRAG_Y_MIN) && (ofs_y < DRAG_Y_MIN / 2))
            {
                y = SMALL_CLOCK_Y2;
                w = SECONDS_POINTER_WIDTH;
                h = SECONDS_HEIGHT;
                transparent = 0;
            }
            pic = (compo_picturebox_t *)compo;
            compo_picturebox_set_alpha(pic, transparent);
            compo_picturebox_set_pos(pic, x, y);
            compo_picturebox_set_size(pic, w, h);
            break;
        case COMPO_ID_MINUTE_CLOCK: // 时钟
            if ((ofs_y >= DRAG_Y_MIN / 2) && (ofs_y <= 0))
            {
                x = MINUTE_CLOCK_X + (GUI_SCREEN_HEIGHT + ofs_y) * (BIG_SECONDS_CLOCK_X - MINUTE_CLOCK_X) / GUI_SCREEN_HEIGHT;
                y = SMALL_CLOCK_Y2 + (GUI_SCREEN_HEIGHT + ofs_y) * (SMALL_CLOCK_Y - SMALL_CLOCK_Y2) / GUI_SCREEN_HEIGHT;
                w = SMALL_CLOCK_WIDTH;
                h = w;
                transparent = 255;
                //   printf("ofs_y3 = %d,y = %d,w = %d,h = %d\n",ofs_y,y,w,h);
            }
            else if ((ofs_y >= DRAG_Y_MIN) && (ofs_y < DRAG_Y_MIN / 2))
            {
                x = MINUTE_CLOCK_X;
                y = SMALL_CLOCK_Y3 + (2 * GUI_SCREEN_HEIGHT + ofs_y) * (SMALL_CLOCK_Y2 - SMALL_CLOCK_Y3) / GUI_SCREEN_HEIGHT;
                w = SMALL_CLOCK_WIDTH;
                h = w;
                transparent = (2 * GUI_SCREEN_HEIGHT + ofs_y) * (128) / GUI_SCREEN_HEIGHT;
                // printf("ofs_y4 = %d,y = %d,transparent = %d,h = %d\n", ofs_y, y, transparent, h);
            }
            pic = (compo_picturebox_t *)compo;
            compo_picturebox_set_alpha(pic, transparent);
            compo_picturebox_set_pos(pic, x, y);
            compo_picturebox_set_size(pic, w, h);
            break;
        case COMPO_ID_MINUTE_CLOCK_POINTER: // 时钟
            if ((ofs_y >= DRAG_Y_MIN / 2) && (ofs_y <= 0))
            {
                x = MINUTE_CLOCK_X + (GUI_SCREEN_HEIGHT + ofs_y) * (BIG_SECONDS_CLOCK_X - MINUTE_CLOCK_X) / GUI_SCREEN_HEIGHT;
                y = SMALL_CLOCK_Y2 + (GUI_SCREEN_HEIGHT + ofs_y) * (SMALL_CLOCK_Y - SMALL_CLOCK_Y2) / GUI_SCREEN_HEIGHT;
                transparent = 255;
            }
            else if ((ofs_y >= DRAG_Y_MIN) && (ofs_y < DRAG_Y_MIN / 2))
            {
                x = MINUTE_CLOCK_X;
                y = SMALL_CLOCK_Y3 + (2 * GUI_SCREEN_HEIGHT + ofs_y) * (SMALL_CLOCK_Y2 - SMALL_CLOCK_Y3) / GUI_SCREEN_HEIGHT;
                transparent = (2 * GUI_SCREEN_HEIGHT + ofs_y) * (128) / GUI_SCREEN_HEIGHT;
            }
            pic = (compo_picturebox_t *)compo;
            compo_picturebox_set_alpha(pic, transparent);
            compo_picturebox_set_pos(pic, x, y);
            break;
        case COMPO_ID_SECONDS_CLOCK: // 秒钟
            if ((ofs_y >= DRAG_Y_MIN / 2) && (ofs_y <= 0))
            {
                x = GUI_SCREEN_CENTER_X;
                y = SMALL_CLOCK_Y2 + (GUI_SCREEN_HEIGHT + ofs_y) * (SMALL_CLOCK_Y - SMALL_CLOCK_Y2) / GUI_SCREEN_HEIGHT;
                w = SMALL_CLOCK_WIDTH;
                h = w;
                transparent = 255;
            }
            else if ((ofs_y >= DRAG_Y_MIN) && (ofs_y < DRAG_Y_MIN / 2))
            {
                x = GUI_SCREEN_CENTER_X;
                y = SMALL_CLOCK_Y3 + (2 * GUI_SCREEN_HEIGHT + ofs_y) * (SMALL_CLOCK_Y2 - SMALL_CLOCK_Y3) / GUI_SCREEN_HEIGHT;
                transparent = (2 * GUI_SCREEN_HEIGHT + ofs_y) * (128) / GUI_SCREEN_HEIGHT;
                w = SMALL_CLOCK_WIDTH;
                h = w;
            }
            pic = (compo_picturebox_t *)compo;
            compo_picturebox_set_alpha(pic, transparent);
            compo_picturebox_set_pos(pic, x, y);
            compo_picturebox_set_size(pic, w, h);
            break;
        case COMPO_ID_SECONDS_CLOCK_POINTER: // 时钟
            if ((ofs_y >= DRAG_Y_MIN / 2) && (ofs_y <= 0))
            {
                x = GUI_SCREEN_CENTER_X;
                y = SMALL_CLOCK_Y2 + (GUI_SCREEN_HEIGHT + ofs_y) * (SMALL_CLOCK_Y - SMALL_CLOCK_Y2) / GUI_SCREEN_HEIGHT;
                transparent = 255;
            }
            else if ((ofs_y >= DRAG_Y_MIN) && (ofs_y < DRAG_Y_MIN / 2))
            {
                x = GUI_SCREEN_CENTER_X;
                y = SMALL_CLOCK_Y3 + (2 * GUI_SCREEN_HEIGHT + ofs_y) * (SMALL_CLOCK_Y2 - SMALL_CLOCK_Y3) / GUI_SCREEN_HEIGHT;
                transparent = (2 * GUI_SCREEN_HEIGHT + ofs_y) * (128) / GUI_SCREEN_HEIGHT;
                //    w = SMALL_CLOCK_WIDTH;
                //    h = w;
                //   printf("ofs_y4 = %d,y = %d,w = %d,h = %d\n",ofs_y,y,w,h);
            }
            pic = (compo_picturebox_t *)compo;
            compo_picturebox_set_alpha(pic, transparent);
            compo_picturebox_set_pos(pic, x, y);
            // compo_picturebox_set_size(pic, w, h);
            break;
        case COMPO_ID_MILLSECONDS_CLOCK: // 时钟

            if ((ofs_y >= DRAG_Y_MIN / 2) && (ofs_y <= 0))
            {

                x = MILLSECONDS_CLOCK_X - (GUI_SCREEN_HEIGHT + ofs_y) * (MILLSECONDS_CLOCK_X - BIG_SECONDS_CLOCK_X) / GUI_SCREEN_HEIGHT;
                y = SMALL_CLOCK_Y2 + (GUI_SCREEN_HEIGHT + ofs_y) * (SMALL_CLOCK_Y - SMALL_CLOCK_Y2) / GUI_SCREEN_HEIGHT;
                w = SMALL_CLOCK_WIDTH;
                h = w;
                transparent = 255;
            }
            else if ((ofs_y >= DRAG_Y_MIN) && (ofs_y < DRAG_Y_MIN / 2))
            {
                x = MILLSECONDS_CLOCK_X;
                y = SMALL_CLOCK_Y3 + (2 * GUI_SCREEN_HEIGHT + ofs_y) * (SMALL_CLOCK_Y2 - SMALL_CLOCK_Y3) / GUI_SCREEN_HEIGHT;
                transparent = (2 * GUI_SCREEN_HEIGHT + ofs_y) * (128) / GUI_SCREEN_HEIGHT;
                w = SMALL_CLOCK_WIDTH;
                h = w;
                //    printf("ofs_y6 = %d,y = %d,w = %d,h = %d\n",ofs_y,y,w,h);
            }
            pic = (compo_picturebox_t *)compo;
            compo_picturebox_set_alpha(pic, transparent);
            compo_picturebox_set_pos(pic, x, y);
            compo_picturebox_set_size(pic, w, h);
            break;
        case COMPO_ID_MILLSECONDS_CLOCK_POINTER: // 时钟

            if ((ofs_y >= DRAG_Y_MIN / 2) && (ofs_y <= 0))
            {
                x = MILLSECONDS_CLOCK_X - (GUI_SCREEN_HEIGHT + ofs_y) * (MILLSECONDS_CLOCK_X - BIG_SECONDS_CLOCK_X) / GUI_SCREEN_HEIGHT;
                y = SMALL_CLOCK_Y2 + (GUI_SCREEN_HEIGHT + ofs_y) * (SMALL_CLOCK_Y - SMALL_CLOCK_Y2) / GUI_SCREEN_HEIGHT;
                transparent = 255;
            }
            else if ((ofs_y >= DRAG_Y_MIN) && (ofs_y < DRAG_Y_MIN / 2))
            {
                x = MILLSECONDS_CLOCK_X;
                y = SMALL_CLOCK_Y3 + (2 * GUI_SCREEN_HEIGHT + ofs_y) * (SMALL_CLOCK_Y2 - SMALL_CLOCK_Y3) / GUI_SCREEN_HEIGHT;
                transparent = (2 * GUI_SCREEN_HEIGHT + ofs_y) * (128) / GUI_SCREEN_HEIGHT;
            }
            pic = (compo_picturebox_t *)compo;
            compo_picturebox_set_alpha(pic, transparent);
            compo_picturebox_set_pos(pic, x, y);
            // compo_picturebox_set_size(pic, w, h);
            break;
        case COMPO_ID_NUM_STOPWATCH_TIME: // 时钟
            cardbox = (compo_cardbox_t *)compo;

            if ((ofs_y >= DRAG_Y_MIN / 2) && (ofs_y <= 0))
            {
                y = TIME_BG_Y2 + (GUI_SCREEN_HEIGHT + ofs_y) * (TIME_BG_Y - TIME_BG_Y2) / GUI_SCREEN_HEIGHT;
            }
            else if ((ofs_y >= DRAG_Y_MIN) && (ofs_y < DRAG_Y_MIN / 2))
            {
                y = TIME_BG_Y3 + (2 * GUI_SCREEN_HEIGHT + ofs_y) * (TIME_BG_Y2 - TIME_BG_Y3) / GUI_SCREEN_HEIGHT;
            }

            /* 根据Y轴坐标计算文本显示大小（与Y轴成反比关系） */
            if (y > TIME_BG_Y2)
                h = w = TIME_BG_W - (((y - TIME_BG_Y2) * TIME_BG_ZOOM_RATIO) / 100);
            else
                h = w = TIME_BG_W;

            compo_cardbox_set_location(cardbox, TIME_BG_X, y, w, h);
            break;
        case COMPO_ID_PAGE_INDEX_1: // 时钟
            pic = (compo_picturebox_t *)compo;
            if (ofs_y > DRAG_Y_MIN / 4)
                compo_picturebox_set(pic, UI_BUF_STOPWATCH_SELECT_BIN);
            else
                compo_picturebox_set(pic, UI_BUF_STOPWATCH_UNSELECT_BIN);
            break;
        case COMPO_ID_PAGE_INDEX_2: // 时钟
            pic = (compo_picturebox_t *)compo;
            if ((ofs_y >= DRAG_Y_MIN * 3 / 4) && (ofs_y < DRAG_Y_MIN / 4))
                compo_picturebox_set(pic, UI_BUF_STOPWATCH_SELECT_BIN);
            else
                compo_picturebox_set(pic, UI_BUF_STOPWATCH_UNSELECT_BIN);
            break;
        case COMPO_ID_PAGE_INDEX_3: // 时钟
            pic = (compo_picturebox_t *)compo;
            if (ofs_y < DRAG_Y_MIN * 3 / 4)
                compo_picturebox_set(pic, UI_BUF_STOPWATCH_SELECT_BIN);
            else
                compo_picturebox_set(pic, UI_BUF_STOPWATCH_UNSELECT_BIN);
            break;

            /* 打点记录 */
        case COMPO_ID_LIST_RECORD_BG:
            if ((ofs_y >= DRAG_Y_MIN / 2) && (ofs_y <= 0))
            {
                y = RECODE_CENTRE_LINE_Y + (GUI_SCREEN_HEIGHT + ofs_y) * (RECODE_LAST_LINE_Y - RECODE_CENTRE_LINE_Y) / GUI_SCREEN_HEIGHT;
                f_stopwatch->list_start_pos = y;
                func_stopwatch_record_pos_update();
            }
            else if ((ofs_y >= DRAG_Y_MIN) && (ofs_y < DRAG_Y_MIN / 2))
            {
                y = RECODE_FIRST_LINE_Y + (2 * GUI_SCREEN_HEIGHT + ofs_y) * (RECODE_CENTRE_LINE_Y - RECODE_FIRST_LINE_Y) / GUI_SCREEN_HEIGHT;
                f_stopwatch->list_start_pos = y;
                func_stopwatch_record_pos_update();
            }
            break;
        case COMPO_ID_RECT_BG_UP:
            rect_bg = (compo_shape_t *)compo;
            compo_shape_set_location(rect_bg, 0, 0, GUI_SCREEN_WIDTH, f_stopwatch->list_start_pos);
            break;
        default:
            break;
        }

        compo = compo_get_next(compo); // 遍历组件
    }
}

//设置页面偏移位置
static void func_stopwatch_set_offs(s16 ofs_y)
{
    f_stopwatch_t *f_stopwatch = (f_stopwatch_t *)func_cb.f_cb;
    stopwatch_ofs_y = ofs_y;
    func_stopwatch_compo_update(stopwatch_ofs_y, false);
}

static u32 func_stopwatch_tick_get(void)
{
    return sys_cb.stopwatch_tick;
}

static void func_stopwatch_tick_reset(void)
{
    sys_cb.stopwatch_tick = 0;
}

/* 判定页面与记录列表拖动事件 */
static void func_stopwatch_record_list_drag_check(void)
{
    f_stopwatch_t *f_stopwatch = (f_stopwatch_t *)func_cb.f_cb;

    if (f_stopwatch == NULL) {
        return;
    }

    int32_t diff_x, diff_y;

    /* 未在拖动前判定是否处于列表可拖动区域 */
    if (ctp_get_dxy(&diff_x, &diff_y) &&
        stopwatch_ofs_y == DRAG_Y_MIN &&
        sys_cb.stopwatch_rec_cnt > RECODE_LIST_ROLL_MIN &&
        ctp_get_sxy().x >= RECODE_FIRST_LINE_X && ctp_get_sxy().x <= RECODE_LAST_LINE_X &&
        ctp_get_sxy().y >= f_stopwatch->list_start_pos && ctp_get_sxy().y <= RECODE_LAST_LINE_Y)
    {   
        f_stopwatch->list_drag = true;
        f_stopwatch->page_drag_flag = false;
    }
    else if (f_stopwatch->list_drag && !ctp_get_dxy(&diff_x, &diff_y))
    {
        f_stopwatch->list_drag = false;
        f_stopwatch->page_drag_flag = false;
    }
}

/* 记录列表位置超出自动恢复 */
static void func_stopwatch_record_self_moving(void)
{
    f_stopwatch_t *f_stopwatch = (f_stopwatch_t *)func_cb.f_cb;

    if (f_stopwatch == NULL) {
        return;
    }

    if (sys_cb.stopwatch_rec_cnt > RECODE_LIST_ROLL_MIN)
    {
        if (tick_check_expire(f_stopwatch->list_pos_tick, 5))
        {
            if (f_stopwatch->list_offset < 0)
            {
                f_stopwatch->list_offset += 1;
                func_stopwatch_record_pos_update();
            }
            else if ((sys_cb.stopwatch_rec_cnt * RECODE_ITEM_HEIGHT) - f_stopwatch->list_offset < (RECODE_ITEM_HEIGHT * 2))
            {
                f_stopwatch->list_offset -= 1;
                func_stopwatch_record_pos_update();
            }
        }
    }
}

static void func_stopwatch_record_data_update(void)
{
    u8 min = 0;
    u8 sec = 0;
    u16 msec = 0;
    char buf[16] = {0};

    compo_shape_t *record_bg = NULL;
    compo_textbox_t *record_num = NULL;
    compo_textbox_t *record_data = NULL;

    compo_picturebox_t *rec_ss_pointer = compo_getobj_byid(COMPO_ID_BIG_SECONDS_CLOCK_REC);

    if (!sys_cb.stopwatch_rec_cnt) {
        for (u8 i = 0; i < STOPWATCH_REC_NUM_MAX; i++) {
            record_bg   = compo_getobj_byid(COMPO_ID_LIST_RECORD_BG + i);
            record_num  = compo_getobj_byid(COMPO_ID_LIST_RECORD_NUM + i);
            record_data = compo_getobj_byid(COMPO_ID_LIST_RECORD_DATA + i);

            if (record_bg == NULL || record_num == NULL || record_data == NULL)  break;

            compo_shape_set_visible(record_bg, false);
            compo_textbox_set_visible(record_num, false);
            compo_textbox_set_visible(record_data, false);
        }
        compo_picturebox_set_visible(rec_ss_pointer, false);
    }
    else
    {
        for (u8 i = 0; i < sys_cb.stopwatch_rec_cnt; i++) {
            record_bg   = compo_getobj_byid(COMPO_ID_LIST_RECORD_BG + i);
            record_num  = compo_getobj_byid(COMPO_ID_LIST_RECORD_NUM + i);
            record_data = compo_getobj_byid(COMPO_ID_LIST_RECORD_DATA + i);

            if (record_bg == NULL || record_num == NULL || record_data == NULL)  break;

            min = ((sys_cb.stopwatch_rec_view[i] / 1000) % 3600) / 60;
            sec = (sys_cb.stopwatch_rec_view[i] / 1000) % 60;
            msec = sys_cb.stopwatch_rec_view[i] % 1000;

            sprintf(buf, i18n[STR_STOPWATCH_SPLIT], sys_cb.stopwatch_rec_cnt - i);
            compo_textbox_set(record_num, buf);

            memset(buf, 0, sizeof(buf));
            sprintf(buf, "%02d:%02d.%02d",  min, sec, msec / 10);
            compo_textbox_set(record_data, buf);

            compo_shape_set_visible(record_bg, true);
            compo_textbox_set_visible(record_num, true);
            compo_textbox_set_visible(record_data, true);
        }
        compo_picturebox_set_visible(rec_ss_pointer, true);
    }
}

/* 列表触摸滑动 */
static void func_stopwatch_record_touch(void)
{
    f_stopwatch_t *f_stopwatch = (f_stopwatch_t *)func_cb.f_cb;

    if (f_stopwatch == NULL) {
        return;
    }

    int32_t diff_x, diff_y;
    ctp_get_dxy(&diff_x, &diff_y);

    if (f_stopwatch->list_drag)
    {
        diff_y = (diff_y * 13) / 10; // 触摸滑动倍增，根据需要调整
        f_stopwatch->list_offset = f_stopwatch->list_offset_temp - diff_y;

        /* 上下最大滑动范围限制 */
        if (f_stopwatch->list_offset < (RECODE_ITEM_HEIGHT * 2) - RECODE_LIST_HEIGHT)
            f_stopwatch->list_offset = (RECODE_ITEM_HEIGHT * 2) - RECODE_LIST_HEIGHT;
        if ((sys_cb.stopwatch_rec_cnt * RECODE_ITEM_HEIGHT) - f_stopwatch->list_offset < RECODE_ITEM_HEIGHT)
            f_stopwatch->list_offset = (sys_cb.stopwatch_rec_cnt * RECODE_ITEM_HEIGHT) - RECODE_ITEM_HEIGHT;
        func_stopwatch_record_pos_update();
    }
    else
    {
        f_stopwatch->list_offset_temp = f_stopwatch->list_offset;
    }
}

static void func_stopwatch_record_pos_update(void)
{
    f_stopwatch_t *f_stopwatch = (f_stopwatch_t *)func_cb.f_cb;

    if (f_stopwatch == NULL) {
        return;
    }

    compo_shape_t *record_bg = NULL;
    compo_textbox_t *record_num = NULL;
    compo_textbox_t *record_data = NULL;

    if (!f_stopwatch->list_start_pos) {
        f_stopwatch->list_start_pos = GUI_SCREEN_HEIGHT;
    }

    /* 计算透明度 */
    uint8_t alpha = 0;
    if (f_stopwatch->list_start_pos > RECODE_CENTRE_LINE_Y) {
        alpha = ((255 * 100) - ((f_stopwatch->list_start_pos - RECODE_CENTRE_LINE_Y) * ((255 * 100) / (RECODE_LAST_LINE_Y - RECODE_CENTRE_LINE_Y)))) / 100;
    } else {
        alpha = 255;
    }

    for (u8 i = 0; i < sys_cb.stopwatch_rec_cnt; i++) {
        record_bg   = compo_getobj_byid(COMPO_ID_LIST_RECORD_BG + i);
        record_num  = compo_getobj_byid(COMPO_ID_LIST_RECORD_NUM + i);
        record_data = compo_getobj_byid(COMPO_ID_LIST_RECORD_DATA + i);

        if (record_bg == NULL || record_num == NULL || record_data == NULL) break;

        if (i == 0) {
            compo_shape_set_location(record_bg, RECODE_LIST_BG_X - 5, (f_stopwatch->list_start_pos + RECODE_ITEM_HEIGHT * i), RECODE_LIST_BG_W + 10, RECODE_LINE_HEIGHT);
        } else {
            compo_shape_set_location(record_bg, RECODE_LIST_BG_X, (f_stopwatch->list_start_pos + RECODE_ITEM_HEIGHT * i) - f_stopwatch->list_offset, RECODE_LIST_BG_W, RECODE_LINE_HEIGHT);
        }

        compo_textbox_set_location(record_num, RECODE_LIST_NUM_X, ((f_stopwatch->list_start_pos + 6) + RECODE_ITEM_HEIGHT * i) - f_stopwatch->list_offset, RECODE_LIST_NUM_W, RECODE_ITEM_HEIGHT);
        compo_textbox_set_location(record_data, RECODE_LIST_DATA_X, ((f_stopwatch->list_start_pos + 6) + RECODE_ITEM_HEIGHT * i) - f_stopwatch->list_offset, RECODE_LIST_DATA_W, RECODE_ITEM_HEIGHT);

        compo_shape_set_alpha(record_bg, alpha);
        compo_textbox_set_alpha(record_num, alpha);
        compo_textbox_set_alpha(record_data, alpha);
    }

    f_stopwatch->list_pos_tick = tick_get();
}

//创建秒表窗体，创建窗体中不要使用功能结构体 func_cb.f_cb
compo_form_t *func_stopwatch_form_create(void)
{
    // 新建窗体和背景
    compo_form_t *frm = compo_form_create(true);
    compo_shape_t *shape_bg = compo_radius_shape_create(frm, COMPO_SHAPE_TYPE_ROUNDED_RECTANGLE, 26);
    compo_shape_set_color(shape_bg, make_color(212, 212, 212));
    compo_shape_set_location(shape_bg, GUI_SCREEN_CENTER_X, GUI_SCREEN_CENTER_Y, GUI_SCREEN_WIDTH, GUI_SCREEN_HEIGHT);

    /* 分段记录 */
    compo_shape_t *line = NULL;
    for (u8 i = 0; i < STOPWATCH_REC_NUM_MAX; i++)
    {
        if (i > 0) {
            line = compo_shape_create(frm, COMPO_SHAPE_TYPE_RECTANGLE);
            compo_setid(line, COMPO_ID_LIST_RECORD_BG + i);
            compo_shape_set_align_center(line, false);
            compo_shape_set_visible(line, false);
        }

        compo_textbox_t *txt_num = compo_textbox_create(frm, 6);
        compo_setid(txt_num, COMPO_ID_LIST_RECORD_NUM + i);
        compo_textbox_set_font(txt_num, UI_BUF_0FONT_FONT_STOPWATCH_16_BIN);
        compo_textbox_set_autosize(txt_num, false);
        compo_textbox_set_align_center(txt_num, false);
        compo_textbox_set_location(txt_num, RECODE_LIST_NUM_X, (RECODE_FIRST_LINE_Y + 6) + RECODE_ITEM_HEIGHT * i, RECODE_LIST_NUM_W, RECODE_ITEM_HEIGHT);
        compo_textbox_set_visible(txt_num, false);

        compo_textbox_t *txt_record = compo_textbox_create(frm, 8);
        compo_setid(txt_record, COMPO_ID_LIST_RECORD_DATA + i);
        compo_textbox_set_font(txt_record, UI_BUF_0FONT_FONT_STOPWATCH_16_BIN);
        compo_textbox_set_autosize(txt_record, false);
        compo_textbox_set_right_align(txt_record, true);
        compo_textbox_set_align_center(txt_record, false);
        compo_textbox_set_location(txt_record, RECODE_LIST_DATA_X, (RECODE_FIRST_LINE_Y + 6) + RECODE_ITEM_HEIGHT * i, RECODE_LIST_DATA_W, RECODE_ITEM_HEIGHT);
        compo_textbox_set_visible(txt_record, false);

        if (i == 0) {
            compo_textbox_set_forecolor(txt_num, NUM_REC_COLOR);
            compo_textbox_set_forecolor(txt_record, NUM_REC_COLOR);
        } else {
            compo_shape_set_color(line, LINE_REC_COLOR_LAST);
            compo_shape_set_location(line, RECODE_LIST_BG_X, RECODE_FIRST_LINE_Y + RECODE_ITEM_HEIGHT * i, RECODE_LIST_BG_W, RECODE_LINE_HEIGHT);

            compo_textbox_set_forecolor(txt_num, NUM_REC_COLOR_LAST);
            compo_textbox_set_forecolor(txt_record, NUM_REC_COLOR_LAST);
        }
    }
    line = compo_shape_create(frm, COMPO_SHAPE_TYPE_RECTANGLE);
    compo_setid(line, COMPO_ID_LIST_RECORD_BG);
    compo_shape_set_color(line, LINE_REC_COLOR);
    compo_shape_set_location(line, RECODE_LIST_BG_X - 5, RECODE_FIRST_LINE_Y, RECODE_LIST_BG_W + 10, RECODE_LINE_HEIGHT);
    compo_shape_set_align_center(line, false);
    compo_shape_set_visible(line, false);

    compo_shape_t *shape_up = compo_radius_shape_create(frm, COMPO_SHAPE_TYPE_ROUNDED_RECTANGLE, 26);
    compo_setid(shape_up, COMPO_ID_RECT_BG_UP);
    compo_shape_set_color(shape_up, make_color(212, 212, 212));
    compo_shape_set_location(shape_up, 0, 0, GUI_SCREEN_WIDTH, RECODE_FIRST_LINE_Y);
    compo_shape_set_align_center(shape_up, false);

    /* 秒表数据部分 */
    compo_textbox_t *time = compo_textbox_create(frm, 8); // 时间
    compo_bonddata(time, COMPO_BOND_TIME);
    compo_textbox_set_location(time, GUI_SCREEN_WIDTH - GUI_PAGE_TIME_WIDTH + 16, GUI_SCREEN_HEIGHT / 8 - FORM_TITLE_HEIGHT + 10, GUI_PAGE_TIME_WIDTH, FORM_TITLE_HEIGHT);
    compo_textbox_set_font(time, UI_BUF_FONT_FORM_TIME);
    compo_textbox_set_forecolor(time, COLOR_BLACK);
    compo_textbox_set_right_align(time, true);

    compo_picturebox_t *target_pic = compo_picturebox_create(frm, UI_BUF_STOPWATCH_MS_BIN); // 毫秒圆盘
    compo_setid(target_pic, COMPO_ID_MILLSECONDS_CLOCK);
    compo_picturebox_set_pos(target_pic, BIG_SECONDS_CLOCK_X, SMALL_CLOCK_Y);
    target_pic = compo_picturebox_create(frm, UI_BUF_STOPWATCH_M_POINTER_BIN); // 毫秒指针
    compo_setid(target_pic, COMPO_ID_MILLSECONDS_CLOCK_POINTER);
    compo_picturebox_set_pos(target_pic, BIG_SECONDS_CLOCK_X, SMALL_CLOCK_Y);
    compo_picturebox_set_rotation_center(target_pic, 4, 30);

    target_pic = compo_picturebox_create(frm, UI_BUF_STOPWATCH_SS_BIN); // 分钟圆盘
    compo_setid(target_pic, COMPO_ID_SECONDS_CLOCK);
    compo_picturebox_set_pos(target_pic, BIG_SECONDS_CLOCK_X, SMALL_CLOCK_Y);

    target_pic = compo_picturebox_create(frm, UI_BUF_STOPWATCH_M_POINTER_BIN); // 分钟指针
    compo_setid(target_pic, COMPO_ID_SECONDS_CLOCK_POINTER);
    compo_picturebox_set_pos(target_pic, BIG_SECONDS_CLOCK_X, SMALL_CLOCK_Y);
    compo_picturebox_set_rotation_center(target_pic, 4, 30);

    target_pic = compo_picturebox_create(frm, UI_BUF_STOPWATCH_BS_BIN); // 大圆
    compo_setid(target_pic, COMPO_ID_BIG_SECONDS_CLOCK);
    compo_picturebox_set_pos(target_pic, BIG_SECONDS_CLOCK_X, BIG_SECONDS_CLOCK_Y);

    target_pic = compo_picturebox_create(frm, UI_BUF_STOPWATCH_MM_BIN); // 分钟圆盘
    compo_setid(target_pic, COMPO_ID_MINUTE_CLOCK);
    compo_picturebox_set_pos(target_pic, BIG_SECONDS_CLOCK_X, SMALL_CLOCK_Y);

    target_pic = compo_picturebox_create(frm, UI_BUF_STOPWATCH_S_POINTER_BIN); // 大圆指针
    compo_setid(target_pic, COMPO_ID_BIG_SECONDS_CLOCK_POINTER);
    compo_picturebox_set_pos(target_pic, BIG_SECONDS_CLOCK_X, BIG_SECONDS_CLOCK_Y);
    compo_picturebox_set_rotation_center(target_pic, BIG_SECONDS_POINTER_OFFSET_X, BIG_SECONDS_POINTER_OFFSET_Y);
    compo_picturebox_set_rotation(target_pic, 0);
    target_pic = compo_picturebox_create(frm, UI_BUF_STOPWATCH_SUBSECTION_POINTER_BIN);
    compo_setid(target_pic, COMPO_ID_BIG_SECONDS_CLOCK_REC);
    compo_picturebox_set_pos(target_pic, BIG_SECONDS_CLOCK_X, BIG_SECONDS_CLOCK_Y);
    compo_picturebox_set_visible(target_pic, false);
    compo_picturebox_set_rotation_center(target_pic, BIG_SECONDS_POINTER_OFFSET_X, BIG_SECONDS_POINTER_OFFSET_Y);
    compo_picturebox_set_rotation(target_pic, 0);

    target_pic = compo_picturebox_create(frm, UI_BUF_STOPWATCH_M_POINTER_BIN); // 分钟指针
    compo_setid(target_pic, COMPO_ID_MINUTE_CLOCK_POINTER);
    compo_picturebox_set_pos(target_pic, BIG_SECONDS_CLOCK_X, SMALL_CLOCK_Y);
    compo_picturebox_set_rotation_center(target_pic, 4, 30);
    compo_picturebox_set_rotation(target_pic, 0);

    compo_picturebox_t *page_index_pic = compo_picturebox_create(frm, UI_BUF_STOPWATCH_SELECT_BIN);
    compo_setid(page_index_pic, COMPO_ID_PAGE_INDEX_1);
    compo_picturebox_set_pos(page_index_pic, 232, 87);

    page_index_pic = compo_picturebox_create(frm, UI_BUF_STOPWATCH_UNSELECT_BIN);
    compo_setid(page_index_pic, COMPO_ID_PAGE_INDEX_2);
    compo_picturebox_set_pos(page_index_pic, 232, 97);

    page_index_pic = compo_picturebox_create(frm, UI_BUF_STOPWATCH_UNSELECT_BIN);
    compo_setid(page_index_pic, COMPO_ID_PAGE_INDEX_3);
    compo_picturebox_set_pos(page_index_pic, 232, 107);

    char str_buff[15] = {0};
    u8 min, sec;
    u16 msec;
    min = ((sys_cb.stopwatch_total_msec / 1000) % 3600) / 60;
    sec = (sys_cb.stopwatch_total_msec / 1000) % 60;
    msec = sys_cb.stopwatch_total_msec % 1000;

    // 数字秒表文本
    uint16_t size = TIME_BG_W - (((TIME_BG_Y - TIME_BG_Y2) * TIME_BG_ZOOM_RATIO) / 100);
    compo_cardbox_t *cardbox = compo_cardbox_create(frm, 0, 0, 1, TIME_BG_W, TIME_BG_H);
    compo_setid(cardbox, COMPO_ID_NUM_STOPWATCH_TIME);
    compo_cardbox_set_location(cardbox, TIME_BG_X, TIME_BG_Y, size, size);
    compo_cardbox_text_set_color(cardbox, 0, COLOR_BLACK);
    compo_cardbox_text_set_align_center(cardbox, 0, true);
    compo_cardbox_text_set_autosize(cardbox, 0, true);
    compo_cardbox_text_set_font(cardbox, 0, UI_BUF_0FONT_FONT_NUM_38_BIN);
    snprintf(str_buff, sizeof(str_buff), "%02d:%02d.%02d", min, sec, msec / 10);
    compo_cardbox_text_set(cardbox, 0, str_buff);

    u32 res_addr;
    compo_button_t *btn;
    res_addr = sys_cb.stopwatch_sta ? UI_BUF_STOPWATCH_SUSPEND_BIN : UI_BUF_STOPWATCH_START_BIN; // 开始/暂停
    btn = compo_button_create_by_image(frm, res_addr);
    compo_setid(btn, COMPO_ID_BTN_START_REC);
    compo_button_set_pos(btn, 202, 253);

    btn = compo_button_create_by_image(frm, UI_BUF_STOPWATCH_RESET_BIN); // 复位
    compo_setid(btn, COMPO_ID_BTN_AFRESH);
    compo_button_set_pos(btn, 37, 253);
    compo_button_set_visible(btn, sys_cb.stopwatch_total_msec > 0 && !sys_cb.stopwatch_sta);

    btn = compo_button_create_by_image(frm, UI_BUF_STOPWATCH_DEFAULT_BIN); // 计次
    compo_setid(btn, COMPO_ID_BTN_RECORD);
    compo_button_set_pos(btn, 37, 253);
    compo_button_set_alpha(btn, sys_cb.stopwatch_sta ? 255 : 120);
    compo_button_set_visible(btn, sys_cb.stopwatch_total_msec == 0 || sys_cb.stopwatch_sta);

    return frm;
}

//释放按钮效果处理
static void func_stopwatch_button_release_handle(void)
{
    // 获取按钮组件的地址
    compo_button_t *btn_start = compo_getobj_byid(COMPO_ID_BTN_START_REC);
    compo_button_t *btn_afresh = compo_getobj_byid(COMPO_ID_BTN_AFRESH);
    compo_button_t *btn_record = compo_getobj_byid(COMPO_ID_BTN_RECORD);

    u32  res_addr = sys_cb.stopwatch_sta ? UI_BUF_STOPWATCH_SUSPEND_BIN : UI_BUF_STOPWATCH_START_BIN; // 开始/暂停
    compo_button_set_bgimg(btn_start, res_addr);

    compo_button_set_bgimg(btn_afresh, UI_BUF_STOPWATCH_RESET_BIN); // 复位
    compo_button_set_visible(btn_afresh, sys_cb.stopwatch_total_msec > 0 && !sys_cb.stopwatch_sta);

    compo_button_set_bgimg(btn_record, UI_BUF_STOPWATCH_DEFAULT_BIN); // 计次
    compo_button_set_alpha(btn_record, sys_cb.stopwatch_sta ? 255 : 120);
    compo_button_set_visible(btn_record, sys_cb.stopwatch_total_msec == 0 || sys_cb.stopwatch_sta);

    func_stopwatch_record_data_update();
}

static void stopwatch_data_reset(void)
{
    f_stopwatch_t *f_stopwatch = (f_stopwatch_t *)func_cb.f_cb;

    compo_cardbox_t    *num_time        = compo_getobj_byid(COMPO_ID_NUM_STOPWATCH_TIME);
    compo_picturebox_t *mm_pointer      = compo_getobj_byid(COMPO_ID_MINUTE_CLOCK_POINTER);
    compo_picturebox_t *ss_pointer      = compo_getobj_byid(COMPO_ID_SECONDS_CLOCK_POINTER);
    compo_picturebox_t *ms_pointer      = compo_getobj_byid(COMPO_ID_MILLSECONDS_CLOCK_POINTER);
    compo_picturebox_t *rec_ss_pointer  = compo_getobj_byid(COMPO_ID_BIG_SECONDS_CLOCK_REC);
    compo_picturebox_t *big_ss_pointer  = compo_getobj_byid(COMPO_ID_BIG_SECONDS_CLOCK_POINTER);

    func_stopwatch_tick_reset();

    f_stopwatch->min = 0;
    f_stopwatch->sec = 0;
    f_stopwatch->msec = 0;

    memset(sys_cb.stopwatch_rec_view, 0, sizeof(sys_cb.stopwatch_rec_view));
    sys_cb.stopwatch_rec_cnt = 0;
    sys_cb.stopwatch_rec_cnt = 0;
    sys_cb.stopwatch_temp_msec = 0;
    sys_cb.stopwatch_total_msec = 0;

    compo_cardbox_text_set(num_time, 0, "00:00.00");

    /* 指针复位 */
    compo_picturebox_set_rotation(ss_pointer, 0);
    compo_picturebox_set_rotation(mm_pointer, 0);
    compo_picturebox_set_rotation(ms_pointer, 0);
    compo_picturebox_set_rotation(big_ss_pointer, 0);
    compo_picturebox_set_rotation(rec_ss_pointer, 0);
    compo_picturebox_set_visible(rec_ss_pointer, false);


}

//单击按钮
static void func_stopwatch_button_click(void)
{
    int id = compo_get_button_id();
    f_stopwatch_t *f_stopwatch = (f_stopwatch_t *)func_cb.f_cb;

    switch (id)
    {
    case COMPO_ID_BTN_AFRESH:
        if (sys_cb.stopwatch_sta == 0)
        {
            stopwatch_data_reset();
        }
        else
        {
            /* 插入记录到头部 */
            sys_cb.stopwatch_rec_cnt += (sys_cb.stopwatch_rec_cnt < STOPWATCH_REC_NUM_MAX);

            for (u8 i = sys_cb.stopwatch_rec_cnt - 1; i > 0; i--)
            {
                sys_cb.stopwatch_rec_view[i] = sys_cb.stopwatch_rec_view[i - 1];
            }
            sys_cb.stopwatch_rec_view[0] = sys_cb.stopwatch_total_msec;
            sys_cb.record_msec = sys_cb.stopwatch_total_msec;
            func_stopwatch_record_data_update();

            f_stopwatch->list_offset = 0;
            func_stopwatch_record_pos_update();
            compo_picturebox_t *rec_ss_pointer = compo_getobj_byid(COMPO_ID_BIG_SECONDS_CLOCK_REC);
            compo_picturebox_set_visible(rec_ss_pointer, true);
        }
        break;

    case COMPO_ID_BTN_START_REC:
        func_stopwatch_tick_reset();

        sys_cb.stopwatch_sta = !sys_cb.stopwatch_sta;
        sys_cb.stopwatch_temp_msec = sys_cb.stopwatch_total_msec;
        break;
    }

    func_stopwatch_button_release_handle();
}

//秒表功能事件处理
static void func_stopwatch_process(void)
{
    f_stopwatch_t *f_stopwatch = (f_stopwatch_t *)func_cb.f_cb;

    if (f_stopwatch == NULL)
        return;

    /* 记录列表事件 */
    func_stopwatch_record_list_drag_check();
    func_stopwatch_record_touch();
    func_stopwatch_record_self_moving();

    /* 整体页面拖动事件, 列表拖动时页面不需要移动 */
    if (f_stopwatch->page_drag_flag && !f_stopwatch->list_drag)
    {
        s32 dx, dy;
        f_stopwatch->page_drag_flag = ctp_get_dxy(&dx, &dy);

        if (f_stopwatch->page_drag_flag)
        {
            // 拖动页面
            f_stopwatch->ofs_y_drag = func_stopwatch_limit_y(stopwatch_ofs_y + dy);
            func_stopwatch_compo_update(f_stopwatch->ofs_y_drag, false);
        }
        else
        {
            // 抬手
            stopwatch_ofs_y = f_stopwatch->ofs_y_drag;
            s16 last_dy = ctp_get_last_dxy().y;
            s16 to_y = stopwatch_ofs_y;

            f_stopwatch->moveto_y = func_stopwatch_align_y(to_y);
            f_stopwatch->flag_move_auto = true;
            f_stopwatch->tick = tick_get();
        }
    }
    else if (f_stopwatch->flag_move_auto)
    {
        // 自动移动
        if (stopwatch_ofs_y == f_stopwatch->moveto_y)
        {
            if (stopwatch_ofs_y < SPRING_Y_MIN)
            {
                f_stopwatch->moveto_y = SPRING_Y_MIN;
            }
            else if (stopwatch_ofs_y > SPRING_Y_MAX)
            {
                f_stopwatch->moveto_y = SPRING_Y_MAX;
            }
            else
            {
                f_stopwatch->flag_move_auto = false; // 移动完成
            }
        }
        else if (tick_check_expire(f_stopwatch->tick, FOCUS_AUTO_TICK_EXPIRE))
        {
            s16 dy;
            f_stopwatch->tick = tick_get();
            dy = f_stopwatch->moveto_y - stopwatch_ofs_y;
            if (dy > 0)
            {
                if (dy > FOCUS_AUTO_STEP * FOCUS_AUTO_STEP_DIV)
                {
                    dy = dy / FOCUS_AUTO_STEP_DIV;
                }
                else if (dy > FOCUS_AUTO_STEP)
                {
                    dy = FOCUS_AUTO_STEP;
                }
            }
            else if (dy < 0)
            {
                if (dy < -FOCUS_AUTO_STEP * FOCUS_AUTO_STEP_DIV)
                {
                    dy = dy / FOCUS_AUTO_STEP_DIV;
                }
                else if (dy < -FOCUS_AUTO_STEP)
                {
                    dy = -FOCUS_AUTO_STEP;
                }
            }
            func_stopwatch_set_offs(stopwatch_ofs_y + dy);
        }
    }

    if (sys_cb.stopwatch_sta)
    {
        /* 10ms刷新时间 */
        sys_cb.stopwatch_total_msec = sys_cb.stopwatch_temp_msec + func_stopwatch_tick_get();
        u8 min = ((sys_cb.stopwatch_total_msec / 1000) % 3600) / 60;
        u8 sec = (sys_cb.stopwatch_total_msec / 1000) % 60;
        u16 msec = sys_cb.stopwatch_total_msec % 1000;

        u8 rec_sec = ((sys_cb.stopwatch_total_msec - sys_cb.record_msec) / 1000) % 60;
        u16 rec_msec = (sys_cb.stopwatch_total_msec - sys_cb.record_msec) % 1000;
        char str_buff[9];

        // 获取数字组件的地址
        compo_cardbox_t *num_time = compo_getobj_byid(COMPO_ID_NUM_STOPWATCH_TIME);

        if (f_stopwatch->msec != msec || f_stopwatch->sec != sec || f_stopwatch->min != min)
        {
            f_stopwatch->min = min;
            f_stopwatch->sec = sec;
            f_stopwatch->msec = msec;

            snprintf(str_buff, sizeof(str_buff), "%02d:%02d.%02d", min, sec, msec / 10);
            compo_cardbox_text_set(num_time, 0, str_buff);

            compo_picturebox_t *rec_ss_pointer = compo_getobj_byid(COMPO_ID_BIG_SECONDS_CLOCK_REC);
            compo_picturebox_t *big_ss_pointer = compo_getobj_byid(COMPO_ID_BIG_SECONDS_CLOCK_POINTER);
            compo_picturebox_t *mm_pointer = compo_getobj_byid(COMPO_ID_MINUTE_CLOCK_POINTER);
            compo_picturebox_t *ss_pointer = compo_getobj_byid(COMPO_ID_SECONDS_CLOCK_POINTER);
            compo_picturebox_t *ms_pointer = compo_getobj_byid(COMPO_ID_MILLSECONDS_CLOCK_POINTER);
            //  printf("rotate sec[%d]\n",msec / 10);
            compo_picturebox_set_rotation(rec_ss_pointer, (rec_sec * 60 + rec_msec / 100 * 6));
            compo_picturebox_set_rotation(big_ss_pointer, (sec * 60 + msec / 100 * 6));
            compo_picturebox_set_rotation(ss_pointer, (sec * 60 + msec / 100 * 6));
            compo_picturebox_set_rotation(mm_pointer, min * 120 % 3600);
            compo_picturebox_set_rotation(ms_pointer, msec / 10 * 36);
        }
    }

    func_process();
}

//秒表功能消息处理
static void func_stopwatch_message(size_msg_t msg)
{
    f_stopwatch_t *f_stopwatch = (f_stopwatch_t *)func_cb.f_cb;

    switch (msg) {
    case MSG_CTP_TOUCH:
        f_stopwatch->page_drag_flag = true;
        break;

    case MSG_CTP_CLICK:
        func_stopwatch_button_click();
        break;

    case KU_LEFT:
    case KU_RIGHT:
        break;

    case KU_BACK:
        if (sys_cb.stopwatch_sta) {
            sys_cb.stopwatch_sta = !sys_cb.stopwatch_sta;
            func_stopwatch_button_release_handle();
        } else {
            func_message(msg);

            /* 用户主动操作按键退出重置数据 */
            if (func_cb.sta != FUNC_STOPWATCH) {
                stopwatch_data_reset();
                /* 页面位置偏移 */
                stopwatch_ofs_y = 0;
            }
        }
        break;

    case MSG_CTP_SHORT_UP:
    case MSG_CTP_SHORT_DOWN:
    case MSG_CTP_SHORT_LEFT:
    case MSG_CTP_LONG:
        func_stopwatch_button_release_handle();
        if (func_cb.flag_sort) {
            func_message(msg);
        }
        break;
    case MSG_CTP_SHORT_RIGHT:
        /*未开灵动岛的情况，右滑退出暂停计数，走按键退出的逻辑*/
        if (!SysVariable.SpiritIslandSwitch && sys_cb.stopwatch_sta)
        {
            sys_cb.stopwatch_sta = !sys_cb.stopwatch_sta;
            func_stopwatch_button_release_handle();
        }
        else
        {
            func_stopwatch_button_release_handle();
            func_message(msg);
        }
        break;

    case MSG_QDEC_FORWARD: // 向前滚动
        break;

    case MSG_QDEC_BACKWARD: // 向后滚动
        break;

    default:
        func_message(msg);
        break;
    }
}

//进入秒表功能
static void func_stopwatch_enter(void)
{
    func_cb.f_cb = func_zalloc(sizeof(f_stopwatch_t));
    func_cb.frm_main = func_stopwatch_form_create();
    func_stopwatch_record_data_update();
    func_stopwatch_compo_update(stopwatch_ofs_y, false);
}

//退出秒表功能
static void func_stopwatch_exit(void)
{
    /* 灵动岛 */
#ifdef TJD_GUI_SPIRIT_ISLAND_SHOW
    if (sys_cb.stopwatch_sta) {
        si_activated_task(stopwatch, 0);
    } else {
        si_delet_task(stopwatch);
    }
#endif
}

//秒表功能
void func_stopwatch(void)
{
    printf("%s\n", __func__);
    func_stopwatch_enter();
    while (func_cb.sta == FUNC_STOPWATCH) {
        func_stopwatch_process();
        func_stopwatch_message(msg_dequeue());
    }
    func_stopwatch_exit();
}