rt-thread/components/rtgui/widgets/edit.c

/*
 * File      : edit.c
 * This file is part of RT-Thread RTOS
 * COPYRIGHT (C) 2006 - 2012, RT-Thread Development Team
 *
 * The license and distribution terms for this file may be
 * found in the file LICENSE in this distribution or at
 * http://www.rt-thread.org/license/LICENSE
 *
 * Change Logs:
 * Date           Author       Notes
 * 2012-06-04     amsl         firist version.
 * 2012-08-09     amsl         beta 0.1
 */
#include <rtgui/dc.h>
#include <rtgui/widgets/edit.h>
#include <rtgui/widgets/scrollbar.h>
#include <rtgui/rtgui_system.h>
#include <rtgui/filerw.h>

extern int isprint(unsigned char ch); /* Quote from shell.c */
static void rtgui_edit_draw_caret(struct rtgui_edit *edit);
static void rtgui_edit_timeout(struct rtgui_timer *timer, void *parameter);
static rt_bool_t rtgui_edit_onfocus(struct rtgui_object *object, rtgui_event_t *event);
static rt_bool_t rtgui_edit_onunfocus(struct rtgui_object *object, rtgui_event_t *event);
#ifdef RTGUI_EDIT_USING_SCROLL
static rt_bool_t rtgui_edit_hscroll_handle(struct rtgui_widget *widget, rtgui_event_t *event);
static rt_bool_t rtgui_edit_vscroll_handle(struct rtgui_widget *widget, rtgui_event_t *event);
#endif

void _rtgui_edit_constructor(struct rtgui_edit *edit)
{
    rtgui_rect_t font_rect;
    RTGUI_WIDGET_FLAG(edit) |= RTGUI_WIDGET_FLAG_FOCUSABLE;

    rtgui_object_set_event_handler(RTGUI_OBJECT(edit), rtgui_edit_event_handler);
    rtgui_widget_set_onfocus(RTGUI_WIDGET(edit), rtgui_edit_onfocus);
    rtgui_widget_set_onunfocus(RTGUI_WIDGET(edit), rtgui_edit_onunfocus);

    RTGUI_WIDGET_FOREGROUND(edit) = black;
    RTGUI_WIDGET_BACKGROUND(edit) = white;
    /* set default text align */
    RTGUI_WIDGET_TEXTALIGN(edit) = RTGUI_ALIGN_CENTER_VERTICAL;
    rtgui_widget_set_border(RTGUI_WIDGET(edit), RTGUI_BORDER_SUNKEN);
    /* set proper of control */
    edit->caret_timer = RT_NULL;
    edit->caret = RT_NULL;

    edit->tabsize = 4;
    edit->margin  = 1;
    edit->max_rows = edit->max_cols = 0;
    edit->visual.x = edit->visual.y = 0;
    edit->upleft.x = edit->upleft.y = 0;
    edit->row_per_page = edit->col_per_page = 0;

    edit->update_buf = RT_NULL;
    edit->flag = RTGUI_EDIT_NONE;
#ifdef RTGUI_EDIT_USING_SCROLL
    edit->flag |= RTGUI_EDIT_VSCROLL;
    edit->flag |= RTGUI_EDIT_HSCROLL;
#endif
    /* allocate default line buffer */
    edit->bzsize = 16;

    rtgui_font_get_metrics(RTGUI_WIDGET_FONT(edit), "H", &font_rect);
    edit->font_width = rtgui_rect_width(font_rect);
    edit->font_height = rtgui_rect_height(font_rect);

    edit->dbl_buf = rtgui_dc_buffer_create(edit->font_width * 2 + 1, edit->font_height + 1);

    edit->head = RT_NULL;
    edit->tail = RT_NULL;
    edit->first_line = RT_NULL;
#ifdef RTGUI_EDIT_USING_SCROLL
    edit->hscroll = RT_NULL;
    edit->vscroll = RT_NULL;
#endif
}

void _rtgui_edit_deconstructor(struct rtgui_edit *edit)
{
    if (edit->max_rows > 0)
    {
        while (edit->max_rows > 0)
            rtgui_edit_delete_line(edit, edit->head);
        edit->max_rows = 0;
    }
    if (edit->caret_timer != RT_NULL)
        rtgui_timer_destory(edit->caret_timer);
    edit->caret_timer = RT_NULL;

    if (edit->caret != RT_NULL)
        rtgui_free(edit->caret);
    edit->caret = RT_NULL;
    if (edit->update_buf != RT_NULL)
        rtgui_free(edit->update_buf);

    rtgui_dc_destory(edit->dbl_buf);
}

DEFINE_CLASS_TYPE(edit, "edit",
                  RTGUI_CONTAINER_TYPE,
                  _rtgui_edit_constructor,
                  _rtgui_edit_deconstructor,
                  sizeof(struct rtgui_edit));

#ifdef RTGUI_EDIT_USING_SCROLL
void rtgui_edit_adjust_scroll(rtgui_scrollbar_t *bar)
{
    struct rtgui_edit *edit;

    RT_ASSERT(bar != RT_NULL);

    if (bar->widget_link != RT_NULL)
    {
        rtgui_rect_t rect;
        rt_uint32_t _left = 0, _top = 0, _width = RTGUI_DEFAULT_SB_WIDTH, _len = 0;

        edit = bar->widget_link;
        rtgui_widget_get_rect(edit, &rect);
        rtgui_widget_rect_to_device(edit, &rect);
        if (bar->orient == RTGUI_HORIZONTAL)
        {
            if (RTGUI_WIDGET_IS_HIDE(edit->hscroll))
            {
                if (edit->max_rows > edit->row_per_page)
                {
                    RTGUI_WIDGET_SHOW(edit->hscroll);
                    rtgui_scrollbar_set_line_step(edit->hscroll, 1);
                    rtgui_scrollbar_set_page_step(edit->hscroll, edit->row_per_page);
                    rtgui_scrollbar_set_range(edit->hscroll, edit->max_rows);
                }
                else
                    RTGUI_WIDGET_HIDE(edit->vscroll);
                rtgui_widget_update_clip(RTGUI_WIDGET(edit));
            }
            else
            {
                _left = RTGUI_WIDGET_BORDER(edit);
                _top = rtgui_rect_height(rect) - RTGUI_WIDGET_BORDER(edit) - _width;
                _len = rtgui_rect_width(rect) - RTGUI_WIDGET_BORDER(edit) * 2;

                if (!RTGUI_WIDGET_IS_HIDE(edit->vscroll))
                    _len -= _width;
                rect.x1 += _left;
                rect.y1 += _top;
                rect.x2 = rect.x1 + _len;
                rect.y2 = rect.y1 + _width;
            }
        }
        else if (bar->orient == RTGUI_VERTICAL)
        {
            _left = rtgui_rect_width(rect) - RTGUI_WIDGET_BORDER(edit) - _width;
            _top = RTGUI_WIDGET_BORDER(edit);
            _len = rtgui_rect_height(rect) - RTGUI_WIDGET_BORDER(edit) * 2;

            if (!RTGUI_WIDGET_IS_HIDE(edit->hscroll))
                _len -= _width;
            rect.x1 += _left;
            rect.y1 += _top;
            rect.x2 = rect.x1 + _width;
            rect.y2 = rect.y1 + _len;
        }
        rtgui_widget_set_rect(bar, &rect);
    }
}
RTM_EXPORT(rtgui_edit_adjust_scroll);
#endif

struct rtgui_edit *rtgui_edit_create(struct rtgui_container *container, int left, int top, int w, int h)
{
    struct rtgui_edit *edit;

    RT_ASSERT(container != RT_NULL);

    edit = (struct rtgui_edit *)rtgui_widget_create(RTGUI_EDIT_TYPE);
    if (edit != RT_NULL)
    {
        rtgui_rect_t rect;
        int effe;
        rtgui_widget_get_rect(RTGUI_WIDGET(container), &rect);
        rtgui_widget_rect_to_device(RTGUI_WIDGET(container), &rect);
        rect.x1 += left;
        rect.y1 += top;
        rect.x2 = rect.x1 + w;
        rect.y2 = rect.y1 + h;
        rtgui_widget_set_rect(RTGUI_WIDGET(edit), &rect);
        rtgui_container_add_child(container, RTGUI_WIDGET(edit));

        /* set character number */
        edit->item_height = edit->font_height; /* the same height */
        effe = h - (edit->margin + RTGUI_WIDGET_BORDER(edit)) * 2;
        edit->row_per_page = effe / edit->item_height;
        if (effe % edit->item_height)
            edit->row_per_page += 1;

        effe = w - (edit->margin + RTGUI_WIDGET_BORDER(edit)) * 2;
        edit->col_per_page = effe / edit->font_width;
        if (effe % edit->font_width)
            edit->col_per_page += 1;
        edit->update_buf = rtgui_malloc(edit->col_per_page + 1);

#ifdef RTGUI_EDIT_USING_SCROLL
        if (edit->hscroll == RT_NULL && edit->flag & RTGUI_EDIT_HSCROLL)
        {
            /* create horizontal scrollbar */
            rt_uint32_t _left, _top, _width = RTGUI_DEFAULT_SB_WIDTH, _len;
            _left = RTGUI_WIDGET_BORDER(edit);
            _top = rtgui_rect_height(rect) - RTGUI_WIDGET_BORDER(edit) - _width;
            _len = rtgui_rect_width(rect) - RTGUI_WIDGET_BORDER(edit) * 2;
            if (edit->max_rows > edit->row_per_page) _len -= _width;

            edit->hscroll = rtgui_scrollbar_create(edit, _left, _top, _width, _len, RTGUI_HORIZONTAL);

            if (edit->hscroll != RT_NULL)
            {
                edit->hscroll->widget_link = (pvoid)edit;
                edit->hscroll->on_scroll = rtgui_edit_hscroll_handle;
                RTGUI_WIDGET_HIDE(edit->hscroll);
            }
        }
        if (edit->vscroll == RT_NULL && edit->flag & RTGUI_EDIT_VSCROLL)
        {
            /* create vertical scrollbar */
            rt_uint32_t _left, _top, _width = RTGUI_DEFAULT_SB_WIDTH, _len;
            _left = rtgui_rect_width(rect) - RTGUI_WIDGET_BORDER(edit) - _width;
            _top = RTGUI_WIDGET_BORDER(edit);
            _len = rtgui_rect_height(rect) - RTGUI_WIDGET_BORDER(edit) * 2;
            if (edit->max_cols > edit->col_per_page) _len -= _width;

            edit->vscroll = rtgui_scrollbar_create(edit, _left, _top, _width, _len, RTGUI_VERTICAL);

            if (edit->vscroll != RT_NULL)
            {
                edit->vscroll->widget_link = (pvoid)edit;
                edit->vscroll->on_scroll = rtgui_edit_vscroll_handle;
                RTGUI_WIDGET_HIDE(edit->vscroll);
            }
        }
#endif
    }

    return edit;
}
RTM_EXPORT(rtgui_edit_create);

void rtgui_edit_destroy(struct rtgui_edit *edit)
{
    rtgui_widget_destroy(RTGUI_WIDGET(edit));
}
RTM_EXPORT(rtgui_edit_destroy);

/**
 * calc line buffer alloc length
 *
 * @param n a standard buffer value, please use edit->bzsize
 * @param m given a reference value
 *
 * @return get a proper standard values
 */
rt_inline rt_int16_t rtgui_edit_alloc_len(rt_int16_t n, rt_int16_t m)
{
    if (n > m) return n;
#ifndef RTGUI_USING_SMALL_SIZE
    return rtgui_edit_alloc_len(n * 2, m);
#else
    return rtgui_edit_alloc_len(n + 16, m);
#endif
}

/**
 * please use it to replace rt_strlen
 * especially in reading the source file.
 */
rt_inline rt_int16_t rtgui_edit_line_strlen(const char *s)
{
    const char *sc;
    /* ascii text end of 0x0A or 0x0D-0x0A*/
    for (sc = s; *sc != 0x0D && *sc != 0x0A && *sc != 0x00; ++sc);
    return sc - s;
}

rt_bool_t rtgui_edit_append_line(struct rtgui_edit *edit, const char *text)
{
    rt_int16_t len;
    struct edit_line *line, *node;

    RT_ASSERT(edit != RT_NULL);

    line = rtgui_malloc(sizeof(struct edit_line));
    if (line == RT_NULL) return RT_FALSE;

    len = rtgui_edit_line_strlen(text);
    line->zsize = rtgui_edit_alloc_len(edit->bzsize, len + 1);
    line->text = rtgui_malloc(line->zsize);
    rt_memcpy(line->text, text, len);
    *(line->text + len) = '\0';
    line->len = rtgui_edit_line_strlen(line->text);

    line->next = RT_NULL;
    edit->max_rows++;
    if (edit->max_cols < len) edit->max_cols = len;

    node = edit->head;
    if (node == RT_NULL)
    {
        edit->head = line;
        edit->tail = line;
        line->prev = RT_NULL;
        edit->first_line = line;
        return RT_TRUE;
    }
    while (node->next != RT_NULL) node = node->next;
    /* to tail item on to queue */
    node->next = line;
    line->prev = node;
    /* re-fixed position tail */
    edit->tail = line;

    return RT_TRUE;
}
RTM_EXPORT(rtgui_edit_append_line);

rt_bool_t rtgui_edit_insert_line(struct rtgui_edit *edit, struct edit_line *p, char *text)
{
    rt_int16_t len;
    struct edit_line *line;

    RT_ASSERT(edit != RT_NULL);
    RT_ASSERT(p != RT_NULL);

    if (p->next == RT_NULL)
    {
        rtgui_edit_append_line(edit, text);
        return RT_TRUE;
    }

    line = rtgui_malloc(sizeof(struct edit_line));
    if (line == RT_NULL) return RT_FALSE;

    line->prev = p;
    line->next = p->next;
    p->next = line;
    if (line->next != RT_NULL)
    {
        line->next->prev = line;
    }

    len = rtgui_edit_line_strlen(text);
    line->zsize = rtgui_edit_alloc_len(edit->bzsize, len + 1);

    line->text = rtgui_malloc(line->zsize);
    rt_memset(line->text, 0, line->zsize);
    rt_memcpy(line->text, text, len);
    *(line->text + len) = '\0';

    edit->max_rows ++;
    line->len = rtgui_edit_line_strlen(line->text);

    return RT_TRUE;
}
RTM_EXPORT(rtgui_edit_insert_line);

rt_bool_t rtgui_edit_delete_line(struct rtgui_edit *edit, struct edit_line *line)
{
    RT_ASSERT(edit != RT_NULL);
    RT_ASSERT(line != RT_NULL);

    if (edit->max_rows == 0) return RT_FALSE;

    if (line->prev == RT_NULL)
    {
        if (line->next == RT_NULL)
        {
            /* only one item */
            edit->head = RT_NULL;
            edit->tail = RT_NULL;
        }
        else
        {
            /* first item */
            line->next->prev = RT_NULL;
            edit->head = line->next;
        }
    }
    else
    {
        if (line->next == RT_NULL)
        {
            /* last item */
            line->prev->next = RT_NULL;
            edit->tail = line->prev;
        }
        else
        {
            /* middle item */
            line->prev->next = line->next;
            line->next->prev = line->prev;
        }
    }

    if (edit->max_rows > 0)edit->max_rows--;
    if (line->text)
    {
        rtgui_free(line->text);
        line->text = RT_NULL;
    }
    rtgui_free(line);
    line = RT_NULL;

    return RT_TRUE;
}
RTM_EXPORT(rtgui_edit_delete_line);

rt_bool_t rtgui_edit_connect_line(struct rtgui_edit *edit, struct edit_line *line, struct edit_line *connect)
{
    rt_int16_t len1, len2;

    RT_ASSERT(edit != RT_NULL);
    RT_ASSERT(line != RT_NULL);
    RT_ASSERT(connect != RT_NULL);

    len1 = rtgui_edit_line_strlen(line->text);
    len2 = rtgui_edit_line_strlen(connect->text);

    line->zsize = rtgui_edit_alloc_len(edit->bzsize, len1 + len2 + 1);
    line->text = rt_realloc(line->text, line->zsize);
    rt_memcpy(line->text + len1, connect->text, len2);
    *(line->text + len1 + len2) = '\0';

    line->len = rtgui_edit_line_strlen(line->text);
    return RT_TRUE;
}
RTM_EXPORT(rtgui_edit_connect_line);

static void rtgui_edit_get_caret_rect(struct rtgui_edit *edit, rtgui_rect_t *rect, rtgui_point_t visual)
{
    RT_ASSERT(edit != RT_NULL);

    rtgui_widget_get_rect(RTGUI_WIDGET(edit), rect);

    rect->x1 += visual.x * edit->font_width + RTGUI_WIDGET_BORDER(edit) + edit->margin;
    rect->x2 = rect->x1 + 1; /* caret width: 1 */
    rect->y1 += visual.y * edit->item_height + RTGUI_WIDGET_BORDER(edit) + edit->margin;
    if ((rect->y1 + edit->font_height) < (rect->y2 - RTGUI_WIDGET_BORDER(edit) - edit->margin))
        rect->y2 = rect->y1 + edit->font_height;
    else
        rect->y2 = rect->y2 - RTGUI_WIDGET_BORDER(edit) - edit->margin;
}

static void rtgui_edit_init_caret(struct rtgui_edit *edit, rtgui_point_t visual)
{
    struct rtgui_graphic_driver *hw_driver = rtgui_graphic_driver_get_default();
    int x, y;
    rtgui_color_t color;
    rtgui_rect_t rect;
    int ofs = 0;

    RT_ASSERT(edit != RT_NULL);
    if (!RTGUI_WIDGET_IS_FOCUSED(edit)) return;

    rtgui_edit_get_caret_rect(edit, &edit->caret_rect, visual);
    rect = edit->caret_rect;
    rtgui_widget_rect_to_device(RTGUI_WIDGET(edit), &rect);

    if (edit->caret == RT_NULL)
        edit->caret = (rtgui_color_t *)rtgui_malloc(rtgui_rect_width(rect) * rtgui_rect_height(rect) * sizeof(rtgui_color_t));
    rtgui_timer_stop(edit->caret_timer);

    for (x = rect.x1; x < rect.x2; x++)
    {
        for (y = rect.y1; y < rect.y2; y++)
        {
            hw_driver->ops->get_pixel(&color, x, y);
            *(edit->caret + ofs++) = color;
        }
    }

    rtgui_timer_start(edit->caret_timer);
}

/* draw caret */
static void rtgui_edit_draw_caret(struct rtgui_edit *edit)
{
    int x, y;
    rtgui_color_t color;
    rtgui_rect_t rect;
    int ofs = 0;
    struct rtgui_dc *dc;

    RT_ASSERT(edit != RT_NULL);
    if (edit->caret == RT_NULL) return;

    dc = rtgui_dc_begin_drawing(RTGUI_WIDGET(edit));
    if (dc == RT_NULL)return;

    rect = edit->caret_rect;

    for (x = rect.x1; x < rect.x2; x++)
    {
        for (y = rect.y1; y < rect.y2; y++)
        {
            color = *(edit->caret + ofs);
            ofs++;
            if (edit->flag & RTGUI_EDIT_CARET)
            {
                color = ~color;
                rtgui_dc_draw_color_point(dc, x, y, color);
            }
            else
            {
                rtgui_dc_draw_color_point(dc, x, y, color);
            }
        }
    }

    rtgui_dc_end_drawing(dc);
}

static void rtgui_edit_timeout(struct rtgui_timer *timer, void *parameter)
{
    struct rtgui_edit *edit;

    edit = RTGUI_EDIT(parameter);
    /* set caret flag */
    if (edit->flag & RTGUI_EDIT_CARET)
        edit->flag &= ~RTGUI_EDIT_CARET;
    else
        edit->flag |= RTGUI_EDIT_CARET;

    rtgui_edit_draw_caret(edit);

    return;
}

struct edit_line *rtgui_edit_get_line_by_index(struct rtgui_edit *edit, rt_uint32_t index)
{
    struct edit_line *line = RT_NULL;

    RT_ASSERT(edit != RT_NULL);

    if (edit->head != RT_NULL)
    {
        int i = 0;
        line = edit->first_line;
        while (line)
        {
            if ((edit->upleft.y + i++)  == index)
                break;
            line = line->next;
        }
    }
    return line;
}
RTM_EXPORT(rtgui_edit_get_line_by_index);

rt_uint32_t rtgui_edit_get_index_by_line(struct rtgui_edit *edit, struct edit_line *line)
{
    rt_uint32_t  index = 0;
    struct edit_line *tmp;

    RT_ASSERT(edit != RT_NULL);
    RT_ASSERT(line != RT_NULL);

    if (edit->head != RT_NULL)
    {
        tmp = edit->first_line;
        index = edit->upleft.y;
        while (tmp)
        {
            if (tmp == line)
                break;
            index ++;
            tmp = tmp->next;
        }
    }
    return index;
}
RTM_EXPORT(rtgui_edit_get_index_by_line);

enum
{
    EDIT_IDENT_DIR_BOTH,
    EDIT_IDENT_DIR_LEFT,
    EDIT_IDENT_DIR_RIGHT
};
/*
* identify a byte is double byte
* @param dir set direction.
* @param *p record the position of the effective.
* @return RT_TRUE is Got it, else not found.
*/
static rt_bool_t identify_double_byte(struct rtgui_edit *edit, struct edit_line *line,
                                      rt_uint32_t dir, rt_int16_t *p)
{
    int index, effe_nums;

    RT_ASSERT(edit != RT_NULL);
    RT_ASSERT(line != RT_NULL);

    if (dir == EDIT_IDENT_DIR_BOTH)
    {
    }
    else if (dir == EDIT_IDENT_DIR_LEFT)
    {
        if (edit->upleft.x == 0 && edit->visual.x == 0)
            return RT_FALSE;
        index = edit->upleft.x + edit->visual.x;
        effe_nums = 0;
        while (index--)
        {
            if ((rt_uint8_t)(*(line->text + index)) >= 0x80)
                effe_nums ++;
            else
                break;
        }
        if (effe_nums > 0)
        {
            *p = 2 - effe_nums % 2;
            return RT_TRUE;
        }
    }
    else if (dir == EDIT_IDENT_DIR_RIGHT)
    {
        if (edit->upleft.x + edit->visual.x == line->len)
            return RT_FALSE;
        index = edit->upleft.x + edit->visual.x;
        effe_nums = 0;
        while (index < line->len)
        {
            if ((rt_uint8_t)(*(line->text + index)) >= 0x80)
                effe_nums ++;
            else
                break;
            index ++;
        }
        if (effe_nums > 0)
        {
            *p = 2 - effe_nums % 2;
            return RT_TRUE;
        }
    }
    return RT_FALSE;
}

static void rtgui_edit_onmouse(struct rtgui_edit *edit, struct rtgui_event_mouse *emouse)
{
    rtgui_rect_t rect;

    RT_ASSERT(edit != RT_NULL);
    RT_ASSERT(emouse != RT_NULL);

    rtgui_widget_get_rect(RTGUI_WIDGET(edit), &rect);
    if ((rtgui_region_contains_point(&(RTGUI_WIDGET(edit)->clip), emouse->x, emouse->y, &rect) == RT_EOK))
    {
        rt_uint16_t x, y;

        /* multiline text */
        x = (emouse->x - rect.x1) / (edit->font_width);
        y = (emouse->y - rect.y1) / (edit->item_height);
        if ((x < edit->col_per_page) && (y < edit->row_per_page))
        {
            if (emouse->button & RTGUI_MOUSE_BUTTON_DOWN)
            {
                struct edit_line *line;
                rt_int16_t tmp_pos = 0;

                edit->visual.x = x;
                edit->visual.y = y;

                line = rtgui_edit_get_line_by_index(edit, edit->upleft.y + edit->visual.y);
                if (line == RT_NULL)
                    return;

                if (edit->visual.x > line->len)
                    edit->visual.x = line->len;
                if (edit->upleft.x > 0)
                {
                    if (edit->upleft.x >= line->len)
                        edit->upleft.x = 0;
                    else
                        edit->visual.x -= edit->upleft.x;
                    rtgui_edit_ondraw(edit);
                }
                if (identify_double_byte(edit, line, EDIT_IDENT_DIR_LEFT, &tmp_pos))
                    edit->visual.x -= (2 - tmp_pos);
                if (edit->flag & RTGUI_EDIT_CARET)
                {
                    if (edit->caret_timer != RT_NULL)
                        rtgui_timer_stop(edit->caret_timer);

                    edit->flag &= ~RTGUI_EDIT_CARET;
                    rtgui_edit_draw_caret(edit);

                    if (edit->caret_timer != RT_NULL)
                        rtgui_timer_start(edit->caret_timer);
                }

                /* set widget focus */
                rtgui_widget_focus(RTGUI_WIDGET(edit));

                if (RTGUI_WIDGET_IS_FOCUSED(edit))
                {
                    rtgui_edit_init_caret(edit, edit->visual);
                    edit->flag |= RTGUI_EDIT_CARET;
                    rtgui_edit_draw_caret(edit);
                }
            }
            else if (emouse->button & RTGUI_MOUSE_BUTTON_UP)
            {
                /* please add codes at here. */
            }
#ifdef RTGUI_EDIT_USING_SCROLL
            if (edit->vscroll && !RTGUI_WIDGET_IS_HIDE(edit))
            {
                if (!RTGUI_WIDGET_IS_HIDE(edit->vscroll))
                    rtgui_scrollbar_set_value(edit->vscroll, edit->upleft.y);
            }
            if (edit->hscroll && !RTGUI_WIDGET_IS_HIDE(edit))
            {
                if (!RTGUI_WIDGET_IS_HIDE(edit->hscroll))
                    rtgui_scrollbar_set_value(edit->hscroll, edit->upleft.x);
            }
#endif
        }
    }
}

rt_inline rt_uint16_t query_shift_code(rt_uint16_t key)
{
    if (key >= RTGUIK_a && key <= RTGUIK_z)
        return (key - ('a' - 'A'));
    else
    {
        switch (key)
        {
        case '1':
            return '!';
        case '2':
            return '@';
        case '3':
            return '#';
        case '4':
            return '$';
        case '5':
            return '%';
        case '6':
            return '^';
        case '7':
            return '&';
        case '8':
            return '*';
        case '9':
            return '(';
        case '0':
            return ')';
        case '-':
            return '_';
        case '=':
            return '+';
        case '\\':
            return '|';
        case ';':
            return ':';
        case '\'':
            return '"';
        case ',':
            return '<';
        case '.':
            return '>';
        case '/':
            return '?';
        case '`':
            return '~';
        }
    }
    return key;
}

rt_inline rt_uint16_t query_caps_code(rt_uint16_t key)
{
    if (key >= RTGUIK_a && key <= RTGUIK_z)
        return (key - ('a' - 'A'));
    return key;
}

rt_inline rt_bool_t is_small_keyboard(rt_uint16_t *key)
{
    if (*key >= RTGUIK_KP0 && *key <= RTGUIK_KP9)
    {
        *key = *key - (RTGUIK_KP0 - RTGUIK_0);
        return RT_TRUE;
    }
    else if (*key == RTGUIK_KP_PERIOD)
    {
        *key = '.';
        return RT_TRUE;
    }
    else if (*key == RTGUIK_KP_DIVIDE)
    {
        *key = '/';
        return RT_TRUE;
    }
    else if (*key == RTGUIK_KP_MULTIPLY)
    {
        *key = '*';
        return RT_TRUE;
    }
    else if (*key == RTGUIK_KP_MINUS)
    {
        *key = '-';
        return RT_TRUE;
    }
    else if (*key == RTGUIK_KP_PLUS)
    {
        *key = '+';
        return RT_TRUE;
    }
    else if (*key == RTGUIK_KP_ENTER)
    {
        *key = RTGUIK_RETURN;
        return RT_TRUE;
    }
    return RT_FALSE;
}

void kbd_event_set_key(struct rtgui_event_kbd *ekbd, rt_uint16_t key)
{
    RTGUI_EVENT_KBD_INIT(ekbd);
    ekbd->mod  = RTGUI_KMOD_NONE;
    ekbd->unicode = 0;

    ekbd->key = key;
    ekbd->type = RTGUI_KEYDOWN;
}

static rt_bool_t rtgui_edit_onkey(struct rtgui_object *object, rtgui_event_t *event)
{
    enum { EDIT_NONE, EDIT_ONDRAW, EDIT_UPDATE };
    struct rtgui_edit *edit = RTGUI_EDIT(object);
    struct rtgui_event_kbd *ekbd = (struct rtgui_event_kbd *)event;
    struct edit_line *line = RT_NULL;
    rt_bool_t update_type = EDIT_NONE;

    RT_ASSERT(edit != RT_NULL);
    RT_ASSERT(ekbd != RT_NULL);

    if (RTGUI_KBD_IS_UP(ekbd))
    {
        /* reset function key */
        if (ekbd->key == RTGUIK_RCTRL || ekbd->key == RTGUIK_LCTRL)
            edit->flag &= ~RTGUI_EDIT_CTRL;
        else if (ekbd->key == RTGUIK_RALT || ekbd->key == RTGUIK_LALT)
            edit->flag &= ~RTGUI_EDIT_ALT;
        else if (ekbd->key == RTGUIK_RSHIFT || ekbd->key == RTGUIK_LSHIFT)
            edit->flag &= ~RTGUI_EDIT_SHIFT;
        else if (ekbd->key == RTGUIK_CAPSLOCK)
            edit->flag &= ~RTGUI_EDIT_CAPSLOCK;
        else if (ekbd->key == RTGUIK_NUMLOCK)
            edit->flag &= ~RTGUI_EDIT_NUMLOCK;
        return RT_TRUE;
    }

    line = rtgui_edit_get_line_by_index(edit, edit->upleft.y + edit->visual.y);
    if (line == RT_NULL)
        return RT_FALSE;

    /* rt_kprintf("key=%04X ",ekbd->key); */
    if (ekbd->key == RTGUIK_RCTRL || ekbd->key == RTGUIK_LCTRL)
    {
        /* use CTRL key */
        edit->flag |= RTGUI_EDIT_CTRL;
        return RT_FALSE;
    }
    else if (ekbd->key == RTGUIK_RALT || ekbd->key == RTGUIK_LALT)
    {
        /* use ALT key */
        edit->flag |= RTGUI_EDIT_ALT;
        return RT_FALSE;
    }
    else if (ekbd->key == RTGUIK_RSHIFT || ekbd->key == RTGUIK_LSHIFT)
    {
        /* use SHIFT key */
        edit->flag |= RTGUI_EDIT_SHIFT;
        return RT_FALSE;
    }
    else if (ekbd->key == RTGUIK_CAPSLOCK)
    {
        edit->flag |= RTGUI_EDIT_CAPSLOCK;
        return RT_FALSE;
    }
    else if (ekbd->key == RTGUIK_NUMLOCK)
    {
        edit->flag |= RTGUI_EDIT_NUMLOCK;
        return RT_FALSE;
    }
    else if (ekbd->key == RTGUIK_DELETE)
    {
        /* delete latter character */
        int ofs = edit->upleft.x + edit->visual.x;
        if (ofs > line->len - 1 || (ofs == 0 && line->len == 0))
        {
            /* will the next line marges into the current line */
            struct edit_line *next_line = line->next;
            if (next_line != RT_NULL)
            {
                struct edit_line *update_end_line;

                update_type = EDIT_UPDATE;
                edit->update.start = edit->visual;

                rtgui_edit_connect_line(edit, line, next_line);
                rtgui_edit_delete_line(edit, next_line);

                if (edit->max_rows - edit->upleft.y > edit->row_per_page)
                {
                    update_end_line = rtgui_edit_get_line_by_index(edit, edit->upleft.y + edit->row_per_page);
                    if (update_end_line != RT_NULL)
                    {
                        edit->update.end.x = edit->col_per_page;
                        edit->update.end.y = edit->upleft.y + edit->row_per_page;
                    }
                }
                else
                {
                    int update_end_index = rtgui_edit_get_index_by_line(edit, edit->tail);
                    edit->update.end.x = edit->col_per_page;
                    edit->update.end.y = update_end_index + 1;
                }
            }
            line->len = rtgui_edit_line_strlen(line->text);
            goto _edit_exit;
        }
        else if (ofs == line->len - 1)
        {
            line->text[ofs] = '\0';
        }
        else
        {
            char *c;
            rt_int16_t tmp_pos = 1;
            identify_double_byte(edit, line, EDIT_IDENT_DIR_RIGHT, &tmp_pos);
            /* remove character */
            for (c = &line->text[ofs]; c[tmp_pos] != '\0'; c++)
                *c = c[tmp_pos];
            *c = '\0';
        }
        update_type = EDIT_UPDATE;
        edit->update.start = edit->visual;
        edit->update.end.x = line->len - edit->upleft.x;
        if (edit->update.end.x > edit->col_per_page)
            edit->update.end.x = edit->col_per_page;
        edit->update.end.y = edit->visual.y;
    }
    else if (ekbd->key == RTGUIK_BACKSPACE)
    {
        if (edit->visual.x == 0)
        {
            /* incorporated into prev line */
            struct rtgui_event_kbd event_kbd;
            struct edit_line *prev_line = line->prev;
            if (prev_line != RT_NULL)
            {
                struct edit_line *update_end_line;

                update_type = EDIT_UPDATE;
                edit->visual.x = prev_line->len;

                rtgui_edit_connect_line(edit, prev_line, line);
                kbd_event_set_key(&event_kbd, RTGUIK_UP);
                rtgui_edit_onkey(object, (rtgui_event_t *)&event_kbd);
                rtgui_edit_delete_line(edit, line);

                edit->update.start = edit->visual; /* update.start.y is changed */
                if (edit->max_rows - edit->upleft.y > edit->row_per_page)
                {
                    update_end_line = rtgui_edit_get_line_by_index(edit, edit->upleft.y + edit->row_per_page);
                    if (update_end_line != RT_NULL)
                    {
                        edit->update.end.x = edit->col_per_page;
                        edit->update.end.y = edit->upleft.y + edit->row_per_page;
                    }
                }
                else
                {
                    int update_end_index = rtgui_edit_get_index_by_line(edit, edit->tail);
                    edit->update.end.x = edit->col_per_page;
                    edit->update.end.y = update_end_index + 1;
                }
            }
            goto _edit_exit;
        }

        /* delete front character */
        if (edit->visual.x == line->len)
        {
            rt_int16_t tmp_pos = 1;
            identify_double_byte(edit, line, EDIT_IDENT_DIR_LEFT, &tmp_pos);
            line->text[edit->visual.x - tmp_pos] = '\0';
            edit->visual.x -= tmp_pos;
        }
        else if (edit->visual.x != 0)
        {
            /* remove current character */
            char *c;
            rt_int16_t tmp_pos = 1;
            identify_double_byte(edit, line, EDIT_IDENT_DIR_LEFT, &tmp_pos);
            /* remove character */
            for (c = &line->text[edit->visual.x - tmp_pos]; c[tmp_pos] != '\0'; c++)
            {
                *c = c[tmp_pos];
            }
            *c = '\0';
            edit->visual.x -= tmp_pos;
        }
        /* adjusted line buffer length */
        if (rtgui_edit_alloc_len(edit->bzsize, line->len + 2) < line->zsize)
        {
            line->zsize = rtgui_edit_alloc_len(edit->bzsize, line->len + 1);
            line->text = rt_realloc(line->text, line->zsize);
        }
        update_type = EDIT_UPDATE;
        edit->update.start = edit->visual;
        edit->update.end.x = line->len;
        edit->update.end.y = edit->visual.y;
    }
    else if (ekbd->key == RTGUIK_UP)
    {
        /* move to prev line */
        struct edit_line *prev_line;
        if (edit->visual.y > 0)
            edit->visual.y --;
        else
        {
            /* change first row */
            if (edit->upleft.y > 0)
            {
                edit->upleft.y --;
                if (edit->first_line->prev != RT_NULL)
                    edit->first_line = edit->first_line->prev;
                update_type = EDIT_ONDRAW;
            }
        }

        /* The position of the recount X */
        prev_line = rtgui_edit_get_line_by_index(edit, edit->upleft.y + edit->visual.y);
        if (prev_line == RT_NULL)
            return RT_FALSE;

        if (edit->upleft.x > 0)
        {
            if (prev_line->len <= edit->upleft.x)
            {
                if (prev_line->len <= edit->col_per_page)
                {
                    edit->upleft.x = 0;
                    edit->visual.x = prev_line->len;
                }
                else
                {
                    edit->upleft.x = prev_line->len - (edit->col_per_page - 1);
                    edit->visual.x = edit->col_per_page - 1;
                }
                update_type = EDIT_ONDRAW;
            }
            else if (prev_line->len - edit->upleft.x < edit->col_per_page)
            {
                if (edit->visual.x > prev_line->len - edit->upleft.x)
                    edit->visual.x = prev_line->len - edit->upleft.x;
                else
                {
                    rt_int16_t tmp_pos = 0;
                    if (identify_double_byte(edit, prev_line, EDIT_IDENT_DIR_LEFT, &tmp_pos))
                        edit->visual.x -= (2 - tmp_pos);
                }
            }
        }
        else if (edit->visual.x > prev_line->len)
            edit->visual.x = prev_line->len;
        else if (prev_line->len >= 2)
        {
            rt_int16_t tmp_pos = 0;
            if (identify_double_byte(edit, prev_line, EDIT_IDENT_DIR_LEFT, &tmp_pos))
                edit->visual.x -= (2 - tmp_pos);
        }

#ifdef RTGUI_EDIT_USING_SCROLL
        /* update vscroll */
        if (edit->vscroll && !RTGUI_WIDGET_IS_HIDE(edit))
        {
            if (!RTGUI_WIDGET_IS_HIDE(edit->vscroll))
                rtgui_scrollbar_set_value(edit->vscroll, edit->upleft.y);
        }
#endif
    }
    else if (ekbd->key == RTGUIK_DOWN)
    {
        struct edit_line *tail_line, *next_line;
        tail_line = rtgui_edit_get_line_by_index(edit, edit->upleft.y + edit->visual.y);
        if (tail_line != RT_NULL)
        {
            /* it is tail line */
            if (tail_line == edit->tail) return RT_FALSE;
        }
        /* move to next line */
        if (edit->visual.y < edit->row_per_page - 2)
        {
            edit->visual.y ++;
        }
        else if (edit->visual.y + edit->upleft.y < edit->max_rows - 1)
        {
            /* change first row */
            edit->upleft.y++;
            if (edit->first_line->next != RT_NULL)
                edit->first_line = edit->first_line->next;
            update_type = EDIT_ONDRAW;
        }

        /* adjust next line end position */
        next_line = rtgui_edit_get_line_by_index(edit, edit->upleft.y + edit->visual.y);
        if (next_line == RT_NULL)
            return RT_FALSE;

        if (edit->upleft.x > 0)
        {
            if (next_line->len <= edit->upleft.x)
            {
                if (next_line->len <= edit->col_per_page)
                {
                    edit->upleft.x = 0;
                    edit->visual.x = next_line->len;
                }
                else
                {
                    edit->upleft.x = next_line->len - (edit->col_per_page - 1);
                    edit->visual.x = edit->col_per_page - 1;
                }
                update_type = EDIT_ONDRAW;
            }
            else if (next_line->len - edit->upleft.x < edit->col_per_page)
            {
                if (edit->visual.x > next_line->len - edit->upleft.x)
                    edit->visual.x = next_line->len - edit->upleft.x;
                else
                {
                    rt_int16_t tmp_pos = 0;
                    if (identify_double_byte(edit, next_line, EDIT_IDENT_DIR_LEFT, &tmp_pos))
                        edit->visual.x -= (2 - tmp_pos);
                }
            }
        }
        else if (edit->visual.x > next_line->len)
            edit->visual.x = next_line->len;
        else if (next_line->len >= 2)
        {
            rt_int16_t tmp_pos = 0;
            if (identify_double_byte(edit, next_line, EDIT_IDENT_DIR_LEFT, &tmp_pos))
                edit->visual.x -= (2 - tmp_pos);
        }

#ifdef RTGUI_EDIT_USING_SCROLL
        /* update vscroll */
        if (edit->vscroll && !RTGUI_WIDGET_IS_HIDE(edit))
        {
            if (!RTGUI_WIDGET_IS_HIDE(edit->vscroll))
                rtgui_scrollbar_set_value(edit->vscroll, edit->upleft.y);
        }
#endif
    }
    else if (ekbd->key == RTGUIK_LEFT)
    {
        /* move to prev char */
        if (edit->visual.x > 0)
        {
            rt_int16_t tmp_pos = 1;
            identify_double_byte(edit, line, EDIT_IDENT_DIR_LEFT, &tmp_pos);
            edit->visual.x -= tmp_pos;
            if (edit->visual.x == -1)
            {
                edit->visual.x = 0;
                edit->upleft.x --;
                update_type = EDIT_ONDRAW;
            }
        }
        else
        {
            if (edit->upleft.x > 0)
            {
                rt_int16_t tmp_pos = 1;
                identify_double_byte(edit, line, EDIT_IDENT_DIR_LEFT, &tmp_pos);
                edit->upleft.x -= tmp_pos;
                update_type = EDIT_ONDRAW;
            }
            else
            {
                struct rtgui_event_kbd event_kbd;
                struct edit_line *first_line;
                first_line = rtgui_edit_get_line_by_index(edit, edit->upleft.y + edit->visual.y);
                if (first_line != RT_NULL)
                {
                    /* it is head line */
                    if (first_line == edit->head) return RT_FALSE;
                }
                /* move the caret to the prev line end */
                kbd_event_set_key(&event_kbd, RTGUIK_UP);
                rtgui_edit_onkey(object, (rtgui_event_t *)&event_kbd);
                kbd_event_set_key(&event_kbd, RTGUIK_END);
                rtgui_edit_onkey(object, (rtgui_event_t *)&event_kbd);
            }
        }
    }
    else if (ekbd->key == RTGUIK_RIGHT)
    {
        /* move to next char */
        if (line->len >= edit->col_per_page)
        {
            if (edit->upleft.x + edit->col_per_page <= line->len)
            {
                if (edit->visual.x < edit->col_per_page - 1)
                {
                    rt_int16_t tmp_pos = 1;
                    identify_double_byte(edit, line, EDIT_IDENT_DIR_RIGHT, &tmp_pos);
                    edit->visual.x += tmp_pos;
                }
                else if (edit->visual.x == edit->col_per_page - 1)
                {
                    if (edit->upleft.x + edit->col_per_page < line->len)
                        edit->upleft.x ++;
                    else
                        edit->upleft.x = line->len - edit->col_per_page + 1;
                    update_type = EDIT_ONDRAW;
                }
            }
            else
            {
                struct rtgui_event_kbd event_kbd;
                /* move to next head */
                kbd_event_set_key(&event_kbd, RTGUIK_DOWN);
                rtgui_edit_onkey(object, (rtgui_event_t *)&event_kbd);
                kbd_event_set_key(&event_kbd, RTGUIK_HOME);
                rtgui_edit_onkey(object, (rtgui_event_t *)&event_kbd);
            }
        }
        else
        {
            if (edit->visual.x < line->len)
            {
                rt_int16_t tmp_pos = 1;
                identify_double_byte(edit, line, EDIT_IDENT_DIR_RIGHT, &tmp_pos);
                edit->visual.x += tmp_pos;
            }
            else
            {
                struct rtgui_event_kbd event_kbd;
                struct edit_line *tail_line;
                tail_line = rtgui_edit_get_line_by_index(edit, edit->upleft.y + edit->visual.y);
                if (tail_line != RT_NULL)
                {
                    /* it is tail line */
                    if (tail_line == edit->tail) return RT_FALSE;
                }
                /* move the caret to the next line head */
                kbd_event_set_key(&event_kbd, RTGUIK_DOWN);
                rtgui_edit_onkey(object, (rtgui_event_t *)&event_kbd);
                kbd_event_set_key(&event_kbd, RTGUIK_HOME);
                rtgui_edit_onkey(object, (rtgui_event_t *)&event_kbd);
            }
        }
    }
    else if (ekbd->key == RTGUIK_HOME)
    {
        /* move cursor to line head */
        edit->visual.x = 0;
        if (edit->upleft.x > 0)
        {
            edit->upleft.x = 0;
            update_type = EDIT_ONDRAW;
        }
    }
    else if (ekbd->key == RTGUIK_END)
    {
        /* move cursor to line tail */
        if (line->len >= edit->col_per_page)
        {
            edit->visual.x = edit->col_per_page - 1;
            edit->upleft.x = line->len - (edit->col_per_page - 1);
            update_type = EDIT_ONDRAW;
        }
        else
            edit->visual.x = line->len;
    }
    else if (ekbd->key == RTGUIK_TAB)
    {
        int space_nums;
        struct rtgui_event_kbd event_kbd;
        /* using spaces to replace TAB */
        space_nums = edit->tabsize - (edit->upleft.x + edit->visual.x) % edit->tabsize;
        while (space_nums--)
        {
            kbd_event_set_key(&event_kbd, RTGUIK_SPACE);
            rtgui_edit_onkey(object, (rtgui_event_t *)&event_kbd);
        }
    }
    else if (ekbd->key == RTGUIK_RETURN)
    {
        struct edit_line *update_end_line;
        struct rtgui_event_kbd event_kbd;

        /* insert a new line buffer */
        rtgui_edit_insert_line(edit, line, line->text + edit->upleft.x + edit->visual.x);
        line->text[edit->upleft.x + edit->visual.x] = '\0';
        line->len = rtgui_edit_line_strlen(line->text);

        if ((edit->max_rows - edit->upleft.y) < edit->row_per_page)
        {
            int update_end_index = rtgui_edit_get_index_by_line(edit, edit->tail);
            update_type = EDIT_UPDATE;
            edit->update.start = edit->visual;
            edit->update.end.x = edit->tail->len;
            edit->update.end.y = update_end_index;
        }
        else
        {
            /* nothing */
            /* it will be adjusted upleft.y when entering DOWN case */
        }

        /* move the caret to the next line head */
        kbd_event_set_key(&event_kbd, RTGUIK_DOWN);
        rtgui_edit_onkey(object, (rtgui_event_t *)&event_kbd);
        kbd_event_set_key(&event_kbd, RTGUIK_HOME);
        rtgui_edit_onkey(object, (rtgui_event_t *)&event_kbd);
        /* adjust update line end position */
        if ((edit->max_rows - edit->upleft.y) >= edit->row_per_page)
        {
            update_type = EDIT_UPDATE;
            edit->update.start = edit->visual;
            edit->update.start.y -= 1;
            update_end_line = rtgui_edit_get_line_by_index(edit, edit->upleft.y + edit->row_per_page - 1);

            if (update_end_line != RT_NULL)
            {
                edit->update.end.x = update_end_line->len;
                edit->update.end.y = edit->upleft.y + edit->row_per_page;
            }
        }
    }
    else
    {
        if (isprint((unsigned char)ekbd->key))
        {
            /* it's may print character */
            update_type = EDIT_UPDATE;
            edit->update.start = edit->visual;

            if (edit->flag & RTGUI_EDIT_SHIFT)
                ekbd->key = query_shift_code(ekbd->key);
            if (edit->flag & RTGUI_EDIT_CAPSLOCK)
                ekbd->key = query_caps_code(ekbd->key);

            if (line->len < line->zsize - 1)
            {
                int ofs = edit->upleft.x + edit->visual.x;
                if (edit->visual.x >= edit->col_per_page - 1)
                {
                    edit->upleft.x ++;
                    update_type = EDIT_ONDRAW;
                }

                if (ofs < line->len)
                {
                    char *c;
                    for (c = &line->text[line->len]; c != &line->text[ofs]; c--)
                        *c = *(c - 1);
                }
                line->text[ofs] = (char)ekbd->key;
                if (edit->visual.x < edit->col_per_page - 1)
                    edit->visual.x ++;
                line->text[line->len + 1] = '\0';
                line->len = rtgui_edit_line_strlen(line->text);
                edit->update.end.x = line->len;
                if (edit->update.end.x > edit->col_per_page)
                    edit->update.end.x = edit->col_per_page;
                edit->update.end.y = edit->visual.y;
            }
            else
            {
                /* adjust line buffer's zone size */
                line->zsize = rtgui_edit_alloc_len(edit->bzsize, line->len + 1);
                line->text = rt_realloc(line->text, line->zsize);
                rtgui_edit_onkey(object, event); /* reentry */
            }
        }
        else
        {
            /* Is small keyboard ? */
            if (edit->flag & RTGUI_EDIT_NUMLOCK)
            {
                if (is_small_keyboard(&ekbd->key))
                    rtgui_edit_onkey(object, event);
                /* small keyboard another value reserved */
            }
        }
    }
    line->len = rtgui_edit_line_strlen(line->text);

_edit_exit:
    if (edit->flag & RTGUI_EDIT_CARET)
    {
        if (edit->caret_timer != RT_NULL)
            rtgui_timer_stop(edit->caret_timer);

        edit->flag &= ~RTGUI_EDIT_CARET;
        rtgui_edit_draw_caret(edit);/* refresh it */
        if (edit->caret_timer != RT_NULL)
            rtgui_timer_start(edit->caret_timer);
    }

    /* re-draw edit widget */
    if (update_type == EDIT_ONDRAW)
        rtgui_edit_ondraw(edit);
    else if (update_type == EDIT_UPDATE)
        rtgui_edit_update(edit);

    if (RTGUI_WIDGET_IS_FOCUSED(edit))
    {
        rtgui_edit_init_caret(edit, edit->visual);
        edit->flag |= RTGUI_EDIT_CARET;
        rtgui_edit_draw_caret(edit);
    }
    return RT_TRUE;
}

static rt_bool_t rtgui_edit_onfocus(struct rtgui_object *object, rtgui_event_t *event)
{
    struct rtgui_edit *edit = RTGUI_EDIT(object);

    edit->caret_timer = rtgui_timer_create(50, RT_TIMER_FLAG_PERIODIC,
                                           rtgui_edit_timeout, (void *)edit);
    /* set caret to show */
    edit->flag |= RTGUI_EDIT_CARET;
    /* start caret timer */
    if (edit->caret_timer != RT_NULL)
        rtgui_timer_start(edit->caret_timer);

    return RT_TRUE;
}

static rt_bool_t rtgui_edit_onunfocus(struct rtgui_object *object, rtgui_event_t *event)
{
    struct rtgui_edit *edit = RTGUI_EDIT(object);

    /* stop caret timer */
    if (edit->caret_timer != RT_NULL)
    {
        rtgui_timer_stop(edit->caret_timer);
        rtgui_timer_destory(edit->caret_timer);
    }
    /* set caret to hide */
    edit->flag &= ~RTGUI_EDIT_CARET;
    rtgui_edit_draw_caret(edit);

    return RT_TRUE;
}

#ifdef RTGUI_EDIT_USING_SCROLL
static rt_bool_t rtgui_edit_hscroll_handle(struct rtgui_widget *widget, rtgui_event_t *event)
{
    struct rtgui_edit *edit = RTGUI_EDIT(widget);

    /* adjust first display row when dragging */
    edit->upleft.y = edit->hscroll->value;

    rtgui_edit_ondraw(edit);

    return RT_TRUE;
}

static rt_bool_t rtgui_edit_vscroll_handle(struct rtgui_widget *widget, rtgui_event_t *event)
{
    struct rtgui_edit *edit = RTGUI_EDIT(widget);

    /* adjust first display row when dragging */
    edit->upleft.x = edit->vscroll->value;

    rtgui_edit_ondraw(edit);

    return RT_TRUE;
}
#endif

/* local area update */
void rtgui_edit_update(struct rtgui_edit *edit)
{
    rt_int16_t i, cpy_len = 0, prev_len;
    rtgui_rect_t rect, r;
    struct rtgui_dc *dc;
    char *src;

    RT_ASSERT(edit != RT_NULL);

    dc = rtgui_dc_begin_drawing(RTGUI_WIDGET(edit));
    if (dc == RT_NULL) return;

    rtgui_widget_get_rect(RTGUI_WIDGET(edit), &rect);
    rtgui_rect_inflate(&rect, -(edit->margin + RTGUI_WIDGET_BORDER(edit)));

    if (edit->update_buf == RT_NULL)
    {
        /* try again allocate */
        edit->update_buf = rtgui_malloc(edit->col_per_page + 1);
    }

    prev_len = edit->col_per_page;
    for (i = edit->update.start.y; i <= edit->update.end.y; i++)
    {
        struct edit_line *line = rtgui_edit_get_line_by_index(edit, edit->upleft.y + i);

        if (i > edit->upleft.y + edit->row_per_page) break;
        if (line == RT_NULL)
        {
            /* when use "RTGUIK_BACKSPACE" backspace forward,
             * the last line is blank, that only fill background. */
            r.x1 = rect.x1;
            r.x2 = rect.x1 + prev_len * edit->font_width;
            r.y1 = rect.y1 + i * edit->font_height;
            r.y2 = r.y1 + edit->font_height;
            if (r.x2 > rect.x2) r.x2 = rect.x2;
            if (r.y2 > rect.y2) r.y2 = rect.y2;
            rtgui_dc_fill_rect(dc, &r);
            break;
        }

        if (edit->update.start.y == edit->update.end.y)
        {
            r.x1 = rect.x1 + edit->update.start.x * edit->font_width;
            r.x2 = rect.x1 + edit->update.end.x * edit->font_width;
            r.y1 = rect.y1 + i * edit->font_height;
            r.y2 = r.y1 + edit->font_height;
            cpy_len = edit->update.end.x - edit->update.start.x;
            src = line->text + edit->update.start.x + edit->upleft.x;
        }
        else
        {
            if (i == edit->update.start.y)
            {
                r.x1 = rect.x1 + edit->update.start.x * edit->font_width;
                r.x2 = rect.x2;
                r.y1 = rect.y1 + i * edit->font_height;
                r.y2 = r.y1 + edit->font_height;
                cpy_len = line->len - edit->update.start.x - edit->upleft.x;
                if (cpy_len > (edit->col_per_page - edit->update.start.x))
                    cpy_len = edit->col_per_page - edit->update.start.x;
                src = line->text + edit->update.start.x + edit->upleft.x;
            }
            else if (i == edit->update.end.y)
            {
                r.x1 = rect.x1;
                r.x2 = rect.x1 + edit->update.end.x * edit->font_width;
                cpy_len = edit->update.end.x;
                r.y1 = rect.y1 + i * edit->font_height;
                r.y2 = r.y1 + edit->font_height;
                src = line->text + edit->upleft.x;
            }
            else
            {
                r.x1 = rect.x1;
                r.x2 = rect.x2;
                r.y1 = rect.y1 + i * edit->font_height;
                r.y2 = r.y1 + edit->font_height;
                cpy_len = line->len - edit->upleft.x;
                if (cpy_len > edit->col_per_page)
                    cpy_len = edit->col_per_page;
                src = line->text + edit->upleft.x;
            }
        }
        if (r.y1 > rect.y2) break;
        if (r.x2 > rect.x2) r.x2 = rect.x2;
        if (r.y2 > rect.y2) r.y2 = rect.y2;

        rt_memcpy(edit->update_buf, src, cpy_len);
        *(edit->update_buf + cpy_len) = '\0';

        rtgui_dc_fill_rect(dc, &r);
        rtgui_dc_draw_text(dc, edit->update_buf, &r);
        prev_len = line->len;
    }

    rtgui_dc_end_drawing(dc);
}

void rtgui_edit_ondraw(struct rtgui_edit *edit)
{
    rtgui_rect_t rect, r;
    struct rtgui_dc *dc;
#ifdef RTGUI_EDIT_USING_SCROLL
    int hscroll_flag = 0;
    int vscroll_flag = 0;
#endif

    RT_ASSERT(edit != RT_NULL);

    dc = rtgui_dc_begin_drawing(RTGUI_WIDGET(edit));
    if (dc == RT_NULL) return;

    /* get widget rect */
    rtgui_widget_get_rect(RTGUI_WIDGET(edit), &rect);
    rtgui_rect_inflate(&rect, -RTGUI_WIDGET_BORDER(edit));

    /* fill widget rect with edit background color */
    RTGUI_DC_BC(dc) = RTGUI_WIDGET_BACKGROUND(edit);
    rtgui_dc_fill_rect(dc, &rect);

    rtgui_rect_inflate(&rect, RTGUI_WIDGET_BORDER(edit));
    /* draw border */
    rtgui_dc_draw_border(dc, &rect, RTGUI_WIDGET_BORDER_STYLE(edit));

    rtgui_rect_inflate(&rect, -(edit->margin + RTGUI_WIDGET_BORDER(edit)));

#ifdef RTGUI_EDIT_USING_SCROLL
    if (edit->vscroll && !RTGUI_WIDGET_IS_HIDE(edit->vscroll))
    {
        rect.x2 = rect.x2 - rtgui_rect_width(edit->vscroll->parent.extent);
    }
    if (edit->hscroll && !RTGUI_WIDGET_IS_HIDE(edit->hscroll))
    {
        rect.y2 = rect.y2 - rtgui_rect_height(edit->hscroll->parent.extent);
    }
#endif
    r = rect;

    /* draw text */
    if (edit->head != RT_NULL)
    {
        struct edit_line *line = edit->first_line;
        int num = 0;

        rect.y2 = rect.y1 + edit->item_height;
        while (line)
        {
            rt_int16_t tmp_pos = 0, ofs;
            char *str = line->text + edit->upleft.x;

            if (edit->upleft.x < line->len)
            {
                rtgui_point_t p = edit->visual; /* backup */
                edit->visual.x = 0;
                identify_double_byte(edit, line, EDIT_IDENT_DIR_LEFT, &tmp_pos);
                ofs = tmp_pos % 2;
                if (ofs == 1)
                {
                    /* use dc_buffer draw the left half of double byte */
                    char dbl_bmp[3];
                    rtgui_point_t pot = {0};
                    rtgui_rect_t r = {0};

                    pot.x = edit->font_width;
                    r.x2 = edit->font_width * 2;
                    r.y2 = edit->font_height;
                    dbl_bmp[0] = *(str - 1);
                    dbl_bmp[1] = *str;
                    dbl_bmp[2] = '\0';
                    RTGUI_DC_BC(edit->dbl_buf) = RTGUI_WIDGET_BACKGROUND(edit);
                    rtgui_dc_fill_rect(edit->dbl_buf, &r);
                    RTGUI_DC_FC(edit->dbl_buf) = RTGUI_WIDGET_FOREGROUND(edit);
                    rtgui_dc_draw_text(edit->dbl_buf, dbl_bmp, &r);
                    rtgui_dc_blit(edit->dbl_buf, &pot, dc, &rect);
                }
                rect.x1 += ofs * edit->font_width;
                rtgui_dc_draw_text(dc, line->text + edit->upleft.x + ofs, &rect);
                rect.x1 -= ofs * edit->font_width;
                edit->visual = p; /* restore */
            }

            line = line->next;

            rect.y1 += edit->item_height;
            if ((rect.y1 + edit->item_height) < r.y2)
                rect.y2 = rect.y1 + edit->item_height;
            else
                rect.y2 = r.y2;

            if (num++ >= edit->row_per_page)
                break;
        }
    }

#ifdef RTGUI_EDIT_USING_SCROLL
    if (edit->hscroll && !RTGUI_WIDGET_IS_HIDE(edit->hscroll))
    {
        hscroll_flag = 1;
        rtgui_scrollbar_ondraw(edit->hscroll);
    }
    if (edit->vscroll && !RTGUI_WIDGET_IS_HIDE(edit->vscroll))
    {
        vscroll_flag = 1;
        rtgui_scrollbar_ondraw(edit->vscroll);
    }

    if (hscroll_flag && vscroll_flag)
    {
        rtgui_color_t _bc;
        rtgui_widget_get_rect(RTGUI_WIDGET(edit), &rect);
        rect.x1 = rect.x2 - RTGUI_WIDGET_BORDER(edit);
        rect.y1 = rect.y2 - RTGUI_WIDGET_BORDER(edit);
        _bc = RTGUI_DC_BC(dc);
        RTGUI_DC_BC(dc) = default_background;
        rtgui_dc_fill_rect(dc, &rect);
        RTGUI_DC_BC(dc) = _bc;
    }
#endif
    rtgui_dc_end_drawing(dc);
}

/* set edit text */
void rtgui_edit_set_text(struct rtgui_edit *edit, const char *text)
{
    const char *begin, *ptr;
#ifdef RTGUI_EDIT_USING_SCROLL
    int hscroll_flag = 0;
    int vscroll_flag = 0;
#endif

    RT_ASSERT(edit != RT_NULL);

    while (edit->max_rows > 0)
        rtgui_edit_delete_line(edit, edit->head);
    edit->max_rows = 0;

    begin = text;
    for (ptr = begin; *ptr != '\0'; ptr++)
    {
        if (*ptr == 0x0A)
        {
            /* unix style */
            rtgui_edit_append_line(edit, begin);
            begin = ptr + 1;
        }
        else if (*ptr == 0x0D && *(ptr + 1) == 0x0A)
        {
            /* windows style */
            rtgui_edit_append_line(edit, begin);
            begin = ptr + 2;
        }
    }
    if (*ptr == '\0')
    {
        if (begin < ptr)
            rtgui_edit_append_line(edit, begin);
    }

#ifdef RTGUI_EDIT_USING_SCROLL
    if (edit->hscroll != RT_NULL)
    {
        if (edit->max_cols > edit->col_per_page)
        {
            RTGUI_WIDGET_SHOW(edit->hscroll);
            rtgui_scrollbar_set_line_step(edit->hscroll, 1);
            rtgui_scrollbar_set_page_step(edit->hscroll, edit->col_per_page);
            rtgui_scrollbar_set_range(edit->hscroll, edit->max_cols);
            hscroll_flag = 1;
        }
        else
        {
            RTGUI_WIDGET_HIDE(edit->hscroll);
        }
    }
    if (edit->vscroll != RT_NULL)
    {
        if (edit->max_rows > edit->row_per_page)
        {
            RTGUI_WIDGET_SHOW(edit->vscroll);
            rtgui_scrollbar_set_line_step(edit->vscroll, 1);
            rtgui_scrollbar_set_page_step(edit->vscroll, edit->row_per_page);
            rtgui_scrollbar_set_range(edit->vscroll, edit->max_rows);
            vscroll_flag = 1;
        }
        else
        {
            RTGUI_WIDGET_HIDE(edit->vscroll);
        }
    }

    if (edit->hscroll != RT_NULL && !RTGUI_WIDGET_IS_HIDE(edit->hscroll))
    {
        rtgui_edit_adjust_scroll(edit->hscroll);
    }
    if (edit->vscroll != RT_NULL && !RTGUI_WIDGET_IS_HIDE(edit->vscroll))
    {
        rtgui_edit_adjust_scroll(edit->vscroll);
    }

    if (hscroll_flag || vscroll_flag)
    {
        rtgui_widget_update_clip(RTGUI_WIDGET(edit));
    }
#endif
}

rt_bool_t rtgui_edit_event_handler(struct rtgui_object *object, rtgui_event_t *event)
{
    rtgui_widget_t *widget = RTGUI_WIDGET(object);
    struct rtgui_edit *edit = RTGUI_EDIT(object);

    switch (event->type)
    {
    case RTGUI_EVENT_PAINT:
#ifndef RTGUI_USING_SMALL_SIZE
        if (widget->on_draw != RT_NULL)
            widget->on_draw(object, event);
        else
#endif
            rtgui_edit_ondraw(edit);
        break;

    case RTGUI_EVENT_MOUSE_BUTTON:
#ifndef RTGUI_USING_SMALL_SIZE
        if (widget->on_mouseclick != RT_NULL)
            widget->on_mouseclick(object, event);
        else
#endif
            rtgui_edit_onmouse(edit, (struct rtgui_event_mouse *)event);
        return RT_TRUE;

    case RTGUI_EVENT_KBD:
#ifndef RTGUI_USING_SMALL_SIZE
        if (widget->on_key != RT_NULL)
            widget->on_key(object, event);
        else
#endif
            rtgui_edit_onkey(object, event);
        return RT_TRUE;

    default:
        return rtgui_widget_event_handler(object, event);
    }

    return RT_FALSE;
}

rtgui_point_t rtgui_edit_get_current_point(struct rtgui_edit *edit)
{
    rtgui_point_t p;

    RT_ASSERT(edit != RT_NULL);

    p.x = edit->upleft.x + edit->visual.x;
    p.y = edit->upleft.y + edit->visual.y;

    return p;
}

rt_uint32_t rtgui_edit_get_mem_consume(struct rtgui_edit *edit)
{
    rt_uint32_t mem_size;
    struct edit_line *line;

    mem_size = sizeof(struct rtgui_edit);
    mem_size += edit->col_per_page + 1; /* update_buf */
    if (edit->head != RT_NULL)
    {
        line = edit->head;
        while (line)
        {
            mem_size += line->zsize;
            mem_size += sizeof(struct edit_line);
            line = line->next;
        }
    }

    return mem_size;
}

#ifdef RTGUI_USING_DFS_FILERW
/**
 * File access component, General File Access Interface
 */
rt_bool_t rtgui_edit_readin_file(struct rtgui_edit *edit, const char *filename)
{
    struct rtgui_filerw *filerw;
    int num = 0, read_bytes, size , len = 0;
    char *text , ch;

    filerw = rtgui_filerw_create_file(filename, "rb");
    if (filerw == RT_NULL) return RT_FALSE;
    /**
     * If it was in the debug of the win32, If document encode is UTF-8 or Unicode,
     * Will read to garbled code when using the function read documents.
     * You can Change of the document contains the source code for ANSI.
     */
    while (edit->max_rows > 0)
        rtgui_edit_delete_line(edit, edit->head);
    edit->max_rows = 0;

    size = edit->bzsize;
    text = rtgui_malloc(size);
    if (text == RT_NULL) return RT_FALSE;

    do
    {
        if ((read_bytes = rtgui_filerw_read(filerw, &ch, 1, 1)) > 0)
        {
            /* rt_kprintf("ch=%02X ",ch); DEBUG */
            if (num >= size - 1)
                text = rt_realloc(text, rtgui_edit_alloc_len(size, num));
            if (ch == 0x09) //Tab
            {
                len = edit->tabsize - num % edit->tabsize;
                while (len--)
                    *(text + num++) = ' ';
            }
            else
                *(text + num++) = ch;
            if (ch == 0x0A)
            {
                rtgui_edit_append_line(edit, text);
                num = 0;
            }

        }
        else if (num > 0)
        {
            /* last line does not exist the end operator */
            *(text + num) = '\0';
            rtgui_edit_append_line(edit, text);
        }
    }
    while (read_bytes);

    rtgui_filerw_close(filerw);
    rtgui_free(text);
    rtgui_edit_ondraw(edit);

    return RT_TRUE;
}

rt_bool_t rtgui_edit_saveas_file(struct rtgui_edit *edit, const char *filename)
{
    struct rtgui_filerw *filerw;
    char ch_tailed = 0x0A;
    struct edit_line *line;

    filerw = rtgui_filerw_create_file(filename, "wb");
    if (filerw == RT_NULL) return RT_FALSE;

    line = edit->head;
    while (line)
    {
        rtgui_filerw_write(filerw, line->text, line->len, 1);
        if (line != edit->tail)
            rtgui_filerw_write(filerw, &ch_tailed, 1, 1);
        line = line->next;
    }

    rtgui_filerw_close(filerw);

    return RT_TRUE;
}
#endif