libs/rt-thread-official
libs
/
rt-thread-official
mirror of https://github.com/RT-Thread/rt-thread.git
4
0
Fork 0
Code Issues Releases Wiki Activity
rt-thread-official/components/rtgui/widgets/edit.c

1913 lines
48 KiB
C
Raw Blame History

/*
* 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
View Git Blame Copy Permalink