static void rtgui_filelist_view_menu_pop(rtgui_widget_t *parent)
{
rtgui_win_t *menu;
rtgui_listbox_t *listbox;
rtgui_rect_t screen, rect = {0, 0, 140, 85};
rtgui_graphic_driver_get_rect(rtgui_graphic_driver_get_default(), &screen);
rtgui_rect_moveto_align(&screen, &rect, RTGUI_ALIGN_CENTER_HORIZONTAL | RTGUI_ALIGN_CENTER_VERTICAL);
menu = rtgui_win_create(RTGUI_WIN(rtgui_widget_get_toplevel(parent)),
"Folder Menu", &rect, RTGUI_WIN_STYLE_DEFAULT);
if (menu != RT_NULL)
{
/* set user data on menu window */
menu->user_data = (rt_uint32_t)parent;
rtgui_win_set_ondeactivate(menu, rtgui_filelist_view_on_menu_deactivate);
listbox = rtgui_listbox_create(items, sizeof(items)/sizeof(items[0]), &rect);
rtgui_listbox_set_onitem(listbox, rtgui_filelist_view_on_folder_item);
rtgui_container_add_child(RTGUI_CONTAINER(menu), RTGUI_WIDGET(listbox));
rtgui_win_show(menu, RT_FALSE);
rtgui_widget_focus(RTGUI_WIDGET(listbox));
rtgui_listbox_set_current_item(listbox, 0);
}
}
static void info_entry(void* parameter)
{
rt_mq_t mq;
struct rtgui_view* view;
struct rtgui_workbench* workbench;
mq = rt_mq_create("qInfo", 256, 4, RT_IPC_FLAG_FIFO);
rtgui_thread_register(rt_thread_self(), mq);
workbench = rtgui_workbench_create("info", "workbench");
if(workbench == RT_NULL)
return;
view = rtgui_view_create("view");
RTGUI_WIDGET_BACKGROUND(RTGUI_WIDGET(view)) = white;
RTGUI_WIDGET_FOREGROUND(RTGUI_WIDGET(view)) = black;
rtgui_widget_set_event_handler(RTGUI_WIDGET(view), view_event_handler);
rtgui_workbench_add_view(workbench, view);
/* this view can be focused */
RTGUI_WIDGET(view)->flag |= RTGUI_WIDGET_FLAG_FOCUSABLE;
/* set widget focus */
rtgui_widget_focus(RTGUI_WIDGET(view));
rtgui_view_show(view, RT_FALSE);
rtgui_workbench_event_loop(workbench);
rtgui_thread_deregister(rt_thread_self());
rt_mq_delete(mq);
}
static rt_bool_t rtgui_combobox_onmouse_button(struct rtgui_combobox* box, struct rtgui_event_mouse* event)
{
struct rtgui_rect rect;
/* get widget rect */
rect = RTGUI_WIDGET(box)->extent;
/* move to the pull down button */
rect.x1 = rect.x2 - RTGUI_COMBOBOX_BUTTON_WIDTH;
if (rtgui_rect_contains_point(&rect, event->x, event->y) == RT_EOK)
{
/* handle mouse button on pull down button */
if (event->button & RTGUI_MOUSE_BUTTON_LEFT &&
event->button & RTGUI_MOUSE_BUTTON_DOWN)
{
box->pd_pressed = RT_TRUE;
rtgui_widget_update(RTGUI_WIDGET(box));
}
else if (event->button & RTGUI_MOUSE_BUTTON_LEFT &&
event->button & RTGUI_MOUSE_BUTTON_UP)
{
box->pd_pressed = RT_FALSE;
rtgui_widget_update(RTGUI_WIDGET(box));
/* pop pull down window */
if (box->pd_win == RT_NULL)
{
rtgui_listbox_t *list;
/* create pull down window */
rect = RTGUI_WIDGET(box)->extent;
rect.y1 = rect.y2;
rect.y2 = rect.y1 + 5 * (2 + rtgui_theme_get_selected_height());
box->pd_win = rtgui_win_create(RT_NULL, "combo", &rect, RTGUI_WIN_STYLE_NO_TITLE);
rtgui_win_set_ondeactivate(RTGUI_WIN(box->pd_win), rtgui_combobox_pulldown_hide);
/* set user data to parent combobox */
box->pd_win->user_data = (rt_uint32_t)box;
/* create list box */
rtgui_rect_inflate(&rect, -1);
list = rtgui_listbox_create(box->items, box->items_count, &rect);
rtgui_container_add_child(RTGUI_CONTAINER(box->pd_win), RTGUI_WIDGET(list));
rtgui_widget_focus(RTGUI_WIDGET(list));
rtgui_listbox_set_onitem(list, rtgui_combobox_pdwin_onitem);
rtgui_win_set_ondeactivate(box->pd_win, rtgui_combobox_pdwin_ondeactive);
}
/* show combo box pull down window */
rtgui_win_show(RTGUI_WIN(box->pd_win), RT_FALSE);
}
return RT_TRUE;
}
return RT_FALSE;
}
rt_bool_t rtgui_checkbox_event_handler(struct rtgui_widget* widget, struct rtgui_event* event)
{
struct rtgui_checkbox* box = (struct rtgui_checkbox*)widget;
switch (event->type) {
case RTGUI_EVENT_PAINT:
#ifndef RTGUI_USING_SMALL_SIZE
if (widget->on_draw != RT_NULL) {
return widget->on_draw(widget, event);
} else
#endif
rtgui_theme_draw_checkbox(box);
break;
case RTGUI_EVENT_MOUSE_BUTTON: {
if (RTGUI_WIDGET_IS_ENABLE(widget) && !RTGUI_WIDGET_IS_HIDE(widget)) {
struct rtgui_event_mouse* emouse = (struct rtgui_event_mouse*)event;
if (emouse->button & RTGUI_MOUSE_BUTTON_LEFT &&
emouse->button & RTGUI_MOUSE_BUTTON_UP) {
/* set focus */
rtgui_widget_focus(widget);
if (box->status_down & RTGUI_CHECKBOX_STATUS_UNCHECKED) {
/* check it */
box->status_down = RTGUI_CHECKBOX_STATUS_CHECKED;
} else {
/* un-check it */
box->status_down = RTGUI_CHECKBOX_STATUS_UNCHECKED;
}
}
/* draw checkbox */
rtgui_theme_draw_checkbox(box);
#ifndef RTGUI_USING_SMALL_SIZE
/* call user callback */
if (widget->on_mouseclick != RT_NULL) {
return widget->on_mouseclick(widget, event);
}
#endif
if (box->on_button != RT_NULL) {
box->on_button(widget, event);
return RT_TRUE;
}
}
return RT_TRUE;
}
}
return RT_FALSE;
}
static void player_entry(void* parameter)
{
rt_mq_t mq;
rtgui_rect_t rect;
mq = rt_mq_create("ply_ui", 256, 4, RT_IPC_FLAG_FIFO);
rtgui_thread_register(rt_thread_self(), mq);
/* create information timer */
info_timer = rtgui_timer_create(RT_TICK_PER_SECOND, RT_TIMER_FLAG_PERIODIC, info_timer_timeout, RT_NULL);
workbench = rtgui_workbench_create("main", "workbench");
if (workbench == RT_NULL) return;
rtgui_widget_set_event_handler(RTGUI_WIDGET(workbench), player_workbench_event_handler);
/* add home view */
home_view = rtgui_view_create("Home");
rtgui_widget_set_event_handler(RTGUI_WIDGET(home_view), home_view_event_handler);
rtgui_workbench_add_view(workbench, home_view);
/* this view can be focused */
RTGUI_WIDGET(home_view)->flag |= RTGUI_WIDGET_FLAG_FOCUSABLE;
/* set widget focus */
rtgui_widget_focus(RTGUI_WIDGET(home_view));
rtgui_widget_get_rect(RTGUI_WIDGET(home_view), &rect);
rect.x1 += 6; rect.y1 += 150 + 25;
rect.x2 = rect.x1 + 228; rect.y2 = rect.y1 + 145;
music_listbox = rtgui_listbox_create(RT_NULL, 0, &rect);
/* none focusable widget */
RTGUI_WIDGET(music_listbox)->flag &= ~RTGUI_WIDGET_FLAG_FOCUSABLE;
RTGUI_WIDGET_FOREGROUND(RTGUI_WIDGET(music_listbox)) = black;
RTGUI_WIDGET_BACKGROUND(RTGUI_WIDGET(music_listbox)) = white;
rtgui_container_add_child(RTGUI_CONTAINER(home_view), RTGUI_WIDGET(music_listbox));
rtgui_listbox_set_onitem(music_listbox, player_play_list_onitem);
rtgui_view_show(home_view, RT_FALSE);
/* add function view */
rtgui_widget_get_rect(RTGUI_WIDGET(workbench), &rect);
function_view = rtgui_list_view_create(function_list,
sizeof(function_list)/sizeof(struct rtgui_list_item),
&rect,
RTGUI_LIST_VIEW_LIST);
rtgui_workbench_add_view(workbench, RTGUI_VIEW(function_view));
rtgui_workbench_event_loop(workbench);
rtgui_thread_deregister(rt_thread_self());
rt_mq_delete(mq);
}
static void rtgui_radiobox_onmouse(struct rtgui_radiobox *radiobox, struct rtgui_event_mouse *event)
{
RT_ASSERT(radiobox != RT_NULL);
RT_ASSERT(event != RT_NULL);
/* widget is hide, return */
if (RTGUI_WIDGET_IS_HIDE(radiobox) ||
!RTGUI_WIDGET_IS_ENABLE(radiobox)) return;
if (event->button & RTGUI_MOUSE_BUTTON_DOWN &&
event->button & RTGUI_MOUSE_BUTTON_LEFT)
{
int bord_size;
struct rtgui_rect rect;
/* focus widgets */
rtgui_widget_focus(RTGUI_WIDGET(radiobox));
/* get widget physical rect */
rtgui_widget_get_rect(RTGUI_WIDGET(radiobox), &rect);
rtgui_widget_rect_to_device(RTGUI_WIDGET(radiobox), &rect);
/* get board size */
if (radiobox->orient == RTGUI_VERTICAL)
bord_size = radiobox->item_size;
else
{
struct rtgui_rect bord_rect;
rtgui_font_get_metrics(RTGUI_WIDGET_FONT(radiobox), "H", &bord_rect);
bord_size = rtgui_rect_height(bord_rect);
}
rtgui_rect_inflate(&rect, - bord_size);
if (rtgui_rect_contains_point(&rect, event->x, event->y) != RT_EOK) return;
if (radiobox->orient == RTGUI_VERTICAL)
{
int delta_y = event->y - rect.y1;
rtgui_radiobox_set_selection(radiobox, delta_y / radiobox->item_size);
}
else
{
int delta_x = event->x - rect.x1;
rtgui_radiobox_set_selection(radiobox, delta_x / radiobox->item_size);
}
}
}
static void rtgui_slider_onmouse(struct rtgui_slider* slider, struct rtgui_event_mouse* event)
{
RT_ASSERT(slider != RT_NULL);
RT_ASSERT(event != RT_NULL);
if (event->button & RTGUI_MOUSE_BUTTON_DOWN &&
event->button & RTGUI_MOUSE_BUTTON_LEFT)
{
int sel;
int range = slider->max - slider->min;
int x0, xsize;
int x;
x0 = 1 + slider->thumb_width/2;
if (slider->orient == RTGUI_VERTICAL)
{
x = event->y - RTGUI_WIDGET(slider)->extent.y1;
x -= x0;
xsize = rtgui_rect_height(RTGUI_WIDGET(slider)->extent) - 2 * x0;
}
else
{
x = event->x - RTGUI_WIDGET(slider)->extent.x1;
x -= x0;
xsize = rtgui_rect_width(RTGUI_WIDGET(slider)->extent) - 2 * x0;
}
if (x <= 0)
{
sel = slider->min;
}
else if (x >= xsize)
{
sel = slider->max;
}
else
{
sel = ((range * x) + xsize/2) / xsize;
sel += slider->min;
}
rtgui_widget_focus(RTGUI_WIDGET(slider));
rtgui_slider_set_value(slider, sel);
if (slider->on_changed != RT_NULL) /* invoke callback function */
slider->on_changed(RTGUI_WIDGET(slider), RT_NULL);
}
}
void rtgui_notebook_set_current_by_index(struct rtgui_notebook* notebook, rt_uint16_t index)
{
RT_ASSERT(notebook != RT_NULL);
if ((index < notebook->count) && (notebook->current != index))
{
struct rtgui_widget *widget;
if (notebook->current != RTGUI_NOT_FOUND)
rtgui_widget_hide(notebook->childs[notebook->current].widget);
notebook->current = index;
widget = notebook->childs[notebook->current].widget;
rtgui_widget_show(widget);
rtgui_widget_update_clip(widget);
rtgui_widget_update(widget);
rtgui_widget_focus(widget);
}
}
static void rtgui_textbox_onmouse(struct rtgui_textbox* box, struct rtgui_event_mouse* event)
{
rt_size_t length;
RT_ASSERT(box != RT_NULL);
RT_ASSERT(event != RT_NULL);
length = rt_strlen((const char*)box->text);
if (event->button & RTGUI_MOUSE_BUTTON_LEFT &&
event->button & RTGUI_MOUSE_BUTTON_DOWN)
{
rt_int32_t x;
/* set caret position */
x = event->x - RTGUI_WIDGET(box)->extent.x1;
if (x < 0)
{
box->position = 0;
}
else if (x > length * box->font_width)
{
box->position = length;
}
else
{
box->position = x / box->font_width;
}
/* set caret to show */
box->flag |= RTGUI_TEXTBOX_CARET_SHOW;
/* set widget focus */
rtgui_widget_focus(RTGUI_WIDGET(box));
/* re-draw text box */
rtgui_theme_draw_textbox(box);
}
}
rt_bool_t rtgui_radiobox_event_handler(struct rtgui_object *object, struct rtgui_event *event)
{
struct rtgui_radiobox *radiobox;
RTGUI_WIDGET_EVENT_HANDLER_PREPARE
radiobox = RTGUI_RADIOBOX(object);
switch (event->type)
{
case RTGUI_EVENT_PAINT:
#ifndef RTGUI_USING_SMALL_SIZE
if (widget->on_draw != RT_NULL)
widget->on_draw(RTGUI_OBJECT(widget), event);
else
#endif
{
rtgui_theme_draw_radiobox(radiobox);
}
break;
case RTGUI_EVENT_KBD:
if (RTGUI_WIDGET_IS_HIDE(radiobox)) return RT_FALSE;
#ifndef RTGUI_USING_SMALL_SIZE
if (widget->on_key != RT_NULL)
return widget->on_key(RTGUI_OBJECT(widget), event);
else
#endif
{
struct rtgui_event_kbd *e = (struct rtgui_event_kbd *)event;
/* set focused */
rtgui_widget_focus(RTGUI_WIDGET(radiobox));
if (!(RTGUI_KBD_IS_UP(e))) return RT_FALSE;
if (radiobox->orient == RTGUI_VERTICAL)
{
if (e->key == RTGUIK_UP)
{
if (radiobox->item_selection > 0)
{
rtgui_radiobox_set_selection(radiobox, radiobox->item_selection - 1);
return RT_TRUE;
}
}
else if (e->key == RTGUIK_DOWN)
{
if (radiobox->item_selection < radiobox->item_count - 1)
{
rtgui_radiobox_set_selection(radiobox, radiobox->item_selection + 1);
return RT_TRUE;
}
}
}
else
{
if (e->key == RTGUIK_LEFT)
{
if (radiobox->item_selection > 0)
{
rtgui_radiobox_set_selection(radiobox, radiobox->item_selection - 1);
return RT_TRUE;
}
}
else if (e->key == RTGUIK_RIGHT)
{
if (radiobox->item_selection < radiobox->item_count - 1)
{
rtgui_radiobox_set_selection(radiobox, radiobox->item_selection + 1);
return RT_TRUE;
}
}
}
}
break;
case RTGUI_EVENT_MOUSE_BUTTON:
#ifndef RTGUI_USING_SMALL_SIZE
if (widget->on_mouseclick != RT_NULL)
widget->on_mouseclick(RTGUI_OBJECT(widget), event);
else
#endif
{
rtgui_radiobox_onmouse(radiobox, (struct rtgui_event_mouse *)event);
}
break;
default:
return rtgui_widget_event_handler(object, event);
}
return RT_FALSE;
}
rt_bool_t rtgui_combo_event_handler(pvoid wdt, rtgui_event_t* event)
{
rtgui_widget_t *widget = RTGUI_WIDGET(wdt);
rtgui_combo_t* cbo = RTGUI_COMBO(wdt);
RT_ASSERT(widget != RT_NULL);
switch(event->type)
{
case RTGUI_EVENT_PAINT:
if(widget->on_draw != RT_NULL)
widget->on_draw(widget, event);
else
rtgui_combo_ondraw(cbo);
break;
case RTGUI_EVENT_KBD:
if(widget->on_key != RT_NULL)
widget->on_key(widget, event);
return RT_TRUE;
case RTGUI_EVENT_MOUSE_BUTTON:
{
rtgui_rect_t rect;
struct rtgui_event_mouse* emouse = (struct rtgui_event_mouse*)event;
rt_bool_t inclip=RT_EOK;
if(!RTGUI_WIDGET_IS_ENABLE(cbo)) break;
if(cbo->tbox->isedit == RT_TRUE)
{
/* only detect textbox area */
inclip = rtgui_region_contains_point(&RTGUI_WIDGET_CLIP(cbo),emouse->x,emouse->y,&rect);
}
else
{
/* detect all area */
inclip = (rtgui_region_contains_point(&RTGUI_WIDGET_CLIP(cbo),emouse->x,emouse->y,&rect) &&
rtgui_region_contains_point(&RTGUI_WIDGET_CLIP(cbo->tbox),emouse->x,emouse->y,&rect));
}
if(inclip == RT_EOK)
{
rtgui_combo_get_downarrow_rect(cbo,&rect);
if(emouse->button & RTGUI_MOUSE_BUTTON_DOWN)
{
if(rtgui_rect_contains_point(&rect,emouse->x,emouse->y) == RT_EOK)
{
/* on pull-down button */
cbo->style = RTGUI_COMBO_STYLE_DOWNARROW_DOWN;
rtgui_combo_draw_downarrow(cbo);
}
if(cbo->lbox != RT_NULL)
{
if(RTGUI_WIDGET_IS_HIDE(cbo->lbox))
{
/* display pupup listbox */
RTGUI_WIDGET_SHOW(cbo->lbox);
rtgui_widget_focus(cbo->lbox);
rtgui_widget_update_clip_pirate(RTGUI_WIDGET_PARENT(cbo->lbox),cbo->lbox);
/* set listbox location is 0 */
cbo->lbox->first_item=0;
cbo->lbox->now_item = 0;
if(cbo->lbox->scroll != RT_NULL)
{
if(!RTGUI_WIDGET_IS_HIDE(cbo->lbox->scroll))
{
rtgui_scrollbar_set_value(cbo->lbox->scroll,cbo->lbox->first_item);
}
}
rtgui_widget_update(RTGUI_WIDGET_PARENT(cbo->lbox));
}
else
{
/* hide it */
rtgui_widget_hide(cbo->lbox);
}
}
}
else if(emouse->button & RTGUI_MOUSE_BUTTON_UP)
{
if(rtgui_region_contains_point(&RTGUI_WIDGET_CLIP(cbo),emouse->x,emouse->y,&rect) == RT_EOK)
{
/* on upriver button */
cbo->style = RTGUI_COMBO_STYLE_DOWNARROW_UP;
rtgui_combo_draw_downarrow(cbo);
}
}
}
else
rtgui_view_event_handler(widget,event);
return RT_TRUE;
}
default:
return rtgui_view_event_handler(widget,event);
}
return RT_FALSE;
}
rt_bool_t rtgui_fileview_event_handler(pvoid wdt, rtgui_event_t* event)
{
rtgui_widget_t *widget = RTGUI_WIDGET(wdt);
rtgui_fileview_t* fview = RTGUI_FILEVIEW(wdt);
switch(event->type)
{
case RTGUI_EVENT_PAINT:
rtgui_fileview_ondraw(fview);
return RT_FALSE;
case RTGUI_EVENT_MOUSE_BUTTON:
{
rtgui_rect_t rect;
struct rtgui_event_mouse* emouse;
emouse = (struct rtgui_event_mouse*)event;
rtgui_widget_focus(fview);
/* get physical extent information */
rtgui_widget_get_rect(fview, &rect);
rtgui_widget_rect_to_device(fview, &rect);
if(fview->sbar && !RTGUI_WIDGET_IS_HIDE(fview->sbar))
rect.x2 -= RC_W(fview->sbar->parent.extent);
if((rtgui_rect_contains_point(&rect, emouse->x, emouse->y) == RT_EOK) && fview->item_count>0)
{
rt_uint16_t i;
/* set focus */
rtgui_widget_focus(fview);
i = (emouse->y - rect.y1) / (2 + RTGUI_SEL_H);
if((i < fview->item_count) && (i < fview->item_per_page))
{
if(emouse->button & RTGUI_MOUSE_BUTTON_DOWN)
{
fview->old_item = fview->now_item;
fview->now_item = fview->first_item + i;
rtgui_fileview_update_current(fview);
}
else if(emouse->button & RTGUI_MOUSE_BUTTON_UP)
{
if(fview->now_item==fview->old_item) return RT_FALSE;
rtgui_fileview_update_current(fview);
}
if(fview->sbar && !RTGUI_WIDGET_IS_HIDE(fview))
{
if(!RTGUI_WIDGET_IS_HIDE(fview->sbar))
rtgui_scrollbar_set_value(fview->sbar,fview->first_item);
}
}
}
rtgui_container_dispatch_mouse_event(fview, emouse);
return RT_TRUE;
}
case RTGUI_EVENT_KBD:
{
struct rtgui_event_kbd *ekbd = (struct rtgui_event_kbd*)event;
if(RTGUI_KBD_IS_DOWN(ekbd))
{
switch(ekbd->key)
{
case RTGUIK_UP:
if(fview->now_item > 0)
{
fview->old_item = fview->now_item;
fview->now_item --;
if(fview->now_item < fview->first_item)
{
/* turn up page */
fview->first_item = fview->now_item;
rtgui_fileview_ondraw(fview);
}
else
{
/* current page */
rtgui_fileview_update_current(fview);
}
if(fview->sbar && !RTGUI_WIDGET_IS_HIDE(fview))
{
if(!RTGUI_WIDGET_IS_HIDE(fview->sbar))
rtgui_scrollbar_set_value(fview->sbar,fview->first_item);
}
}
return RT_TRUE;
case RTGUIK_DOWN:
if(fview->now_item < fview->item_count-1)
{
fview->old_item = fview->now_item;
fview->now_item ++;
if(fview->now_item >= fview->first_item+fview->item_per_page)
{
/* turn down page */
fview->first_item++;
rtgui_fileview_ondraw(fview);
}
else
{
/* in current page */
rtgui_fileview_update_current(fview);
}
if(fview->sbar && !RTGUI_WIDGET_IS_HIDE(fview))
{
if(!RTGUI_WIDGET_IS_HIDE(fview->sbar))
rtgui_scrollbar_set_value(fview->sbar,fview->first_item);
}
}
return RT_TRUE;
case RTGUIK_LEFT:
if(fview->item_count==0)return RT_FALSE;
fview->old_item = fview->now_item;
fview->now_item -= fview->item_per_page;
if(fview->now_item < 0)
fview->now_item = 0;
if(fview->now_item < fview->first_item)
{
fview->first_item = fview->now_item;
rtgui_fileview_ondraw(fview);
}
else
{
rtgui_fileview_update_current(fview);
}
if(fview->sbar && !RTGUI_WIDGET_IS_HIDE(fview))
{
if(!RTGUI_WIDGET_IS_HIDE(fview->sbar))
rtgui_scrollbar_set_value(fview->sbar,fview->first_item);
}
return RT_TRUE;
case RTGUIK_RIGHT:
if(fview->item_count==0)return RT_FALSE;
fview->old_item = fview->now_item;
fview->now_item += fview->item_per_page;
if(fview->now_item > fview->item_count-1)
fview->now_item = fview->item_count-1;
if(fview->now_item >= fview->first_item+fview->item_per_page)
{
fview->first_item += fview->item_per_page;
if(fview->first_item >fview->item_count-fview->item_per_page)
{
fview->first_item = fview->item_count-fview->item_per_page;
fview->now_item = fview->first_item;
}
rtgui_fileview_ondraw(fview);
}
else
{
rtgui_fileview_update_current(fview);
}
if(fview->sbar && !RTGUI_WIDGET_IS_HIDE(fview))
{
if(!RTGUI_WIDGET_IS_HIDE(fview->sbar))
rtgui_scrollbar_set_value(fview->sbar,fview->first_item);
}
return RT_TRUE;
case RTGUIK_RETURN:
rtgui_fileview_on_enter(fview, event);
return RT_TRUE;
case RTGUIK_BACKSPACE:
rtgui_fileview_goto_topfolder(fview);
return RT_TRUE;
default:
break;
}
}
}
return RT_FALSE;
default:
return rtgui_container_event_handler(widget, event);
}
}
rt_bool_t rtgui_listctrl_event_handler(struct rtgui_widget* widget, struct rtgui_event* event)
{
struct rtgui_listctrl* ctrl = RT_NULL;
ctrl = RTGUI_LISTCTRL(widget);
switch (event->type)
{
case RTGUI_EVENT_PAINT:
_rtgui_listctrl_ondraw(ctrl);
return RT_FALSE;
case RTGUI_EVENT_RESIZE:
{
struct rtgui_event_resize* resize;
resize = (struct rtgui_event_resize*)event;
/* recalculate page items */
ctrl->page_items = resize->h / (2 + rtgui_theme_get_selected_height());
}
break;
case RTGUI_EVENT_MOUSE_BUTTON:
{
rtgui_rect_t rect;
struct rtgui_event_mouse* emouse;
emouse = (struct rtgui_event_mouse*)event;
/* get scrollbar rect */
_rtgui_listctrl_get_scrollbar_rect(ctrl, &rect);
rtgui_widget_rect_to_device(RTGUI_WIDGET(ctrl), &rect);
if (rtgui_rect_contains_point(&rect, emouse->x, emouse->y) == RT_EOK)
{
_rtgui_listctrl_scrollbar_onmouse(ctrl, emouse);
return RT_TRUE;
}
/* calculate selected item */
/* get physical extent information */
_rtgui_listctrl_get_rect(ctrl, &rect);
rtgui_widget_rect_to_device(widget, &rect);
if ((rtgui_rect_contains_point(&rect, emouse->x, emouse->y) == RT_EOK) &&
(ctrl->items_count > 0))
{
rt_uint16_t index;
index = (emouse->y - rect.y1) / (2 + rtgui_theme_get_selected_height());
/* set focus */
rtgui_widget_focus(widget);
{
struct rtgui_rect rect;
struct rtgui_dc* dc;
dc = rtgui_dc_begin_drawing(RTGUI_WIDGET(ctrl));
if (dc != RT_NULL)
{
/* get widget rect */
rtgui_widget_get_rect(RTGUI_WIDGET(ctrl), &rect);
/* update focus border */
rect.x2 -= 1; rect.y2 -= 1;
rtgui_dc_end_drawing(dc);
}
}
if ((index < ctrl->page_items) &&
(ctrl->current_item/ctrl->page_items)* ctrl->page_items + index < ctrl->items_count)
{
rt_uint16_t old_item;
old_item = ctrl->current_item;
/* set selected item */
ctrl->current_item = (ctrl->current_item/ctrl->page_items) * ctrl->page_items + index;
if (emouse->button & RTGUI_MOUSE_BUTTON_DOWN)
{
/* down event */
rtgui_listctrl_update_current(ctrl, old_item);
}
else
{
/* up event */
if (ctrl->on_item != RT_NULL)
{
ctrl->on_item(RTGUI_WIDGET(ctrl), RT_NULL);
}
}
}
}
return RT_TRUE;
}
case RTGUI_EVENT_KBD:
{
struct rtgui_event_kbd* ekbd = (struct rtgui_event_kbd*)event;
if ((ekbd->type == RTGUI_KEYDOWN) && (ctrl->items_count > 0))
{
rt_uint16_t old_item;
old_item = ctrl->current_item;
switch (ekbd->key)
{
case RTGUIK_LEFT:
if (ctrl->current_item - ctrl->page_items >= 0)
ctrl->current_item -= ctrl->page_items;
rtgui_listctrl_update_current(ctrl, old_item);
return RT_FALSE;
case RTGUIK_UP:
if (ctrl->current_item > 0)
ctrl->current_item --;
rtgui_listctrl_update_current(ctrl, old_item);
return RT_FALSE;
case RTGUIK_RIGHT:
if (ctrl->current_item + ctrl->page_items < ctrl->items_count - 1)
ctrl->current_item += ctrl->page_items;
else
{
if ((((ctrl->current_item/ctrl->page_items) + 1) * ctrl->page_items) < ctrl->items_count - 1)
ctrl->current_item = ((ctrl->current_item / ctrl->page_items) + 1) * ctrl->page_items;
}
rtgui_listctrl_update_current(ctrl, old_item);
return RT_FALSE;
case RTGUIK_DOWN:
if (ctrl->current_item < ctrl->items_count - 1)
ctrl->current_item ++;
rtgui_listctrl_update_current(ctrl, old_item);
return RT_FALSE;
case RTGUIK_RETURN:
if (ctrl->on_item != RT_NULL)
{
ctrl->on_item(RTGUI_WIDGET(ctrl), RT_NULL);
}
return RT_FALSE;
default:
break;
}
}
}
return RT_FALSE;
}
/* use ctrl event handler */
return rtgui_widget_event_handler(widget, event);
}
static void _rtgui_scrollbar_on_mouseclick(rtgui_scrollbar_t *bar, rtgui_event_t * event)
{
rtgui_rect_t btn_rect, bar_rect,rect;
rt_uint32_t pos;
struct rtgui_event_mouse *mouse = (struct rtgui_event_mouse*)event;
RT_ASSERT(bar != RT_NULL);
/* get value */
pos = get_scrollbar_pos(bar);
rtgui_widget_get_rect(RTGUI_WIDGET(bar), &rect);
rtgui_widget_rect_to_device(RTGUI_WIDGET(bar),&rect);
if(bar->orient == RTGUI_VERTICAL)
{
/* arrange vertical */
/* get up arrow button rect */
btn_rect.x1 = rect.x1;
btn_rect.x2 = rect.x2;
btn_rect.y1 = rect.y1;
btn_rect.y2 = rect.y1 + rtgui_rect_width(rect);
if(rtgui_rect_contains_point(&btn_rect, mouse->x, mouse->y) == RT_EOK)
{
if((mouse->button & RTGUI_MOUSE_BUTTON_LEFT) && (mouse->button & RTGUI_MOUSE_BUTTON_DOWN))
{
bar->status |= SBS_UPARROW;
if(bar->value==0)
{
rtgui_scrollbar_ondraw(bar);
return;
}
/* line step */
bar->value -= bar->line_step;
if(bar->value < 0) bar->value = 0;
}
else if(mouse->button & RTGUI_MOUSE_BUTTON_UP)
{
bar->status = 0;
}
goto __exit;
}
/* click on the thumb chunk, be going to dragging */
rtgui_scrollbar_get_thumb_rect(bar, &bar_rect);
rtgui_widget_rect_to_device(RTGUI_WIDGET(bar),&bar_rect);
if(rtgui_rect_contains_point(&bar_rect, mouse->x, mouse->y) == RT_EOK)
{
/* on thumb */
if((mouse->button & RTGUI_MOUSE_BUTTON_LEFT) && (mouse->button & RTGUI_MOUSE_BUTTON_DOWN))
{
/* changed status into drag */
bar->status |= SBS_VERTTHUMB;
sbar_mouse_move_size.x = mouse->x;
sbar_mouse_move_size.y = mouse->y;
}
else if(mouse->button & RTGUI_MOUSE_BUTTON_UP)
{
bar->status = 0;
}
goto __exit;
}
else
{
/* click on space without thumb */
/* get bar rect */
bar_rect.y1 = rect.y1 + rtgui_rect_width(rect);
bar_rect.y2 = rect.y2 - rtgui_rect_width(rect);
if(rtgui_rect_contains_point(&bar_rect, mouse->x, mouse->y) == RT_EOK)
{
if((mouse->button & RTGUI_MOUSE_BUTTON_LEFT) && (mouse->button & RTGUI_MOUSE_BUTTON_DOWN))
{
/* page step */
if(mouse->y < bar_rect.y1 + pos)
{
bar->status |= SBS_UPSPACE;
bar->value -= bar->page_step;
if(bar->value < 0) bar->value = 0;
}
else if(mouse->y > pos + bar->thumb_len)
{
bar->status |= SBS_DOWNSPACE;
bar->value += bar->page_step;
if(bar->value > bar->count) bar->value = bar->count;
}
}
goto __exit;
}
}
/* likewise foregoing */
/* get down arrow button rect */
bar_rect.x1 = rect.x1;
bar_rect.x2 = rect.x2;
btn_rect.y1 = rect.y2 - rtgui_rect_width(rect);
btn_rect.y2 = rect.y2;
if(rtgui_rect_contains_point(&btn_rect, mouse->x, mouse->y) == RT_EOK)
{
if((mouse->button & RTGUI_MOUSE_BUTTON_LEFT) && (mouse->button & RTGUI_MOUSE_BUTTON_DOWN))
{
bar->status |= SBS_DOWNARROW;
if(bar->value==bar->count)
{
rtgui_scrollbar_ondraw(bar);
return;
}
/* line step */
bar->value += bar->line_step;
if(bar->value > bar->count) bar->value = bar->count;
}
else if(mouse->button & RTGUI_MOUSE_BUTTON_UP)
bar->status = 0;
goto __exit;
}
}
else
{
/* get left arrow button rect */
btn_rect.x1 = rect.x1;
btn_rect.x2 = rect.x1 + rtgui_rect_height(rect);
btn_rect.y1 = rect.y1;
btn_rect.y2 = rect.y2;
if(rtgui_rect_contains_point(&btn_rect, mouse->x, mouse->y) == RT_EOK)
{
if((mouse->button & RTGUI_MOUSE_BUTTON_LEFT) && (mouse->button & RTGUI_MOUSE_BUTTON_DOWN))
{
bar->status |= SBS_LEFTARROW;
if(bar->value==0)
{
rtgui_scrollbar_ondraw(bar);
return;
}
/* line step */
bar->value -= bar->line_step;
if(bar->value < 0) bar->value = 0;
}
else if(mouse->button & RTGUI_MOUSE_BUTTON_UP)
bar->status = 0;
goto __exit;
}
rtgui_scrollbar_get_thumb_rect(bar, &bar_rect);
rtgui_widget_rect_to_device(RTGUI_WIDGET(bar),&bar_rect);
if(rtgui_rect_contains_point(&bar_rect, mouse->x, mouse->y) == RT_EOK)
{
/* on the thumb */
if((mouse->button & RTGUI_MOUSE_BUTTON_LEFT) && (mouse->button & RTGUI_MOUSE_BUTTON_DOWN))
{
bar->status |= SBS_HORZTHUMB;
sbar_mouse_move_size.x = mouse->x;
sbar_mouse_move_size.y = mouse->y;
}
else if(mouse->button & RTGUI_MOUSE_BUTTON_UP)
{
bar->status = 0;
}
goto __exit;
}
else
{
/* get bar rect */
bar_rect.x1 = rect.x1 + rtgui_rect_height(rect);
bar_rect.x2 = rect.x2 - rtgui_rect_height(rect);
bar_rect.y1 = rect.y1;
bar_rect.y2 = rect.y2;
if(rtgui_rect_contains_point(&bar_rect, mouse->x, mouse->y) == RT_EOK)
{
if((mouse->button & RTGUI_MOUSE_BUTTON_LEFT) && (mouse->button & RTGUI_MOUSE_BUTTON_DOWN))
{
/* page step */
if(mouse->x < bar_rect.x1 + pos)
{
bar->status |= SBS_LEFTSPACE;
bar->value -= bar->page_step;
if(bar->value < 0) bar->value = 0;
}
else if(mouse->x > pos + bar->thumb_len)
{
bar->status |= SBS_RIGHTSPACE;
bar->value += bar->page_step;
if(bar->value > bar->count) bar->value = bar->count;
}
}
else if(mouse->button & RTGUI_MOUSE_BUTTON_UP)
{
bar->status = 0;
}
goto __exit;
}
}
/* get right arrow button rect */
btn_rect.x1 = rect.x2 - rtgui_rect_height(rect);
btn_rect.x2 = rect.x2;
bar_rect.y1 = rect.y1;
bar_rect.y2 = rect.y2;
if(rtgui_rect_contains_point(&btn_rect, mouse->x, mouse->y) == RT_EOK)
{
if((mouse->button & RTGUI_MOUSE_BUTTON_LEFT) && (mouse->button & RTGUI_MOUSE_BUTTON_DOWN))
{
bar->status |= SBS_RIGHTARROW;
if(bar->value==bar->count)
{
rtgui_scrollbar_ondraw(bar);
return;
}
/* line step */
bar->value += bar->line_step;
if(bar->value > bar->count) bar->value = bar->count;
}
else if(mouse->button & RTGUI_MOUSE_BUTTON_UP)
bar->status = 0;
goto __exit;
}
}
__exit:
rtgui_scrollbar_ondraw(bar);
if((mouse->button & RTGUI_MOUSE_BUTTON_LEFT) && (mouse->button & RTGUI_MOUSE_BUTTON_DOWN))
{
if(bar->widget_link != RT_NULL && bar->on_scroll != RT_NULL)
{
rtgui_widget_focus(bar->widget_link);
bar->on_scroll(RTGUI_OBJECT(bar->widget_link), event);
}
}
}
rt_bool_t window_focus(void)
{
rtgui_label_t *label;
rtgui_button_t* start_btn;
rtgui_button_t* stop_btn;
rtgui_win_t *picture_win;
rtgui_rect_t rect = {0, 20, 240, 320};
/* 创建一个窗口 */
main_win = rtgui_win_create(RT_NULL,
"主窗口",
&rect,
RTGUI_WIN_STYLE_DEFAULT | RTGUI_WIN_STYLE_DESTROY_ON_CLOSE);
/* 获得视图的位置信息 */
rtgui_widget_get_rect(RTGUI_WIDGET(main_win), &rect);
rtgui_widget_rect_to_device(RTGUI_WIDGET(main_win), &rect);
rect.x1 += 10;
rect.x2 -= 5;
rect.y2 = rect.y1 + 20;
/* 创建标题用的标签 */
label = rtgui_label_create("主窗口");
/* 设置标签位置信息 */
rtgui_widget_set_rect(RTGUI_WIDGET(label), &rect);
/* 添加标签到视图中 */
rtgui_container_add_child(RTGUI_CONTAINER(main_win),
RTGUI_WIDGET(label));
/* 获得视图的位置信息 */
rtgui_widget_get_rect(RTGUI_WIDGET(main_win), &rect);
rtgui_widget_rect_to_device(RTGUI_WIDGET(main_win), &rect);
rect.x1 += 10;
rect.y2 -= 10;
rect.y1 = rect.y2 - 25;
rect.x2 = rect.x1 + 50;
/* 创建"启动"按钮 */
start_btn = rtgui_button_create("按钮1");
/* 设置按钮的位置信息 */
rtgui_widget_set_rect(RTGUI_WIDGET(start_btn), &rect);
rtgui_button_set_onbutton(start_btn, show_modal_info);
/* 添加按钮到视图中 */
rtgui_container_add_child(RTGUI_CONTAINER(main_win),
RTGUI_WIDGET(start_btn));
/* 添加停止按钮*/
rtgui_widget_get_rect(RTGUI_WIDGET(main_win), &rect);
rtgui_widget_rect_to_device(RTGUI_WIDGET(main_win), &rect);
rect.x2 -= 10;
rect.y2 -= 10;
rect.x1 = rect.x2 - 50;
rect.y1 = rect.y2 - 25;
/* 创建"停止"按钮 */
stop_btn = rtgui_button_create("按钮2");
/* 设置按钮的位置信息 */
rtgui_widget_set_rect(RTGUI_WIDGET(stop_btn), &rect);
rtgui_button_set_onbutton(stop_btn, echo_btn_pressed);
/* 添加按钮到视图中 */
rtgui_container_add_child(RTGUI_CONTAINER(main_win),
RTGUI_WIDGET(stop_btn));
/*创建一个绘图Windows控件*/
rtgui_widget_get_rect(RTGUI_WIDGET(main_win), &rect);
rtgui_widget_rect_to_device(RTGUI_WIDGET(main_win), &rect);
rect.x1 += 10;
rect.y1 += 20;
rect.x2 = rect.x1 + 200;
rect.y2 = rect.y1 + 150;
picture_win = rtgui_win_create(main_win, "绘图窗口", &rect,
RTGUI_WIN_STYLE_NO_TITLE|RTGUI_WIN_STYLE_NO_BORDER|RTGUI_WIN_STYLE_NO_FOCUS);
//创建窗口，没有标题栏，没有最小化窗口，也不能获取焦点
/* 添加windows的事件*/
/* all of the windows are managed by topwin. Never set a window as other
* window's child.
*
*rtgui_container_add_child(RTGUI_CONTAINER(main_win),
* RTGUI_WIDGET(picture_win));
*/
rtgui_object_set_event_handler(RTGUI_OBJECT(picture_win),
picture_win_onpaint);
/* 非模态显示窗口 */
rtgui_widget_focus(RTGUI_WIDGET(main_win));//设定主窗体获取焦点
rtgui_win_show(main_win, RT_FALSE);
rtgui_win_show(picture_win,RT_FALSE);
return RT_TRUE;
}
static rt_bool_t _benchmark_onshow(struct rtgui_object *obj, struct rtgui_event* ev)
{
rtgui_widget_focus(RTGUI_WIDGET(obj));
return RT_TRUE;
}
rt_bool_t rtgui_listbox_event_handler(struct rtgui_widget* widget, struct rtgui_event* event)
{
struct rtgui_listbox* box = RT_NULL;
box = RTGUI_LISTBOX(widget);
switch (event->type)
{
case RTGUI_EVENT_PAINT:
rtgui_listbox_ondraw(box);
return RT_FALSE;
case RTGUI_EVENT_RESIZE:
{
struct rtgui_event_resize* resize;
resize = (struct rtgui_event_resize*)event;
/* recalculate page items */
box->page_items = resize->h / (2 + rtgui_theme_get_selected_height());
}
break;
case RTGUI_EVENT_MOUSE_BUTTON:
{
rtgui_rect_t rect;
struct rtgui_event_mouse* emouse;
emouse = (struct rtgui_event_mouse*)event;
/* calculate selected item */
/* get physical extent information */
rtgui_widget_get_rect(widget, &rect);
rtgui_widget_rect_to_device(widget, &rect);
if ((rtgui_rect_contains_point(&rect, emouse->x, emouse->y) == RT_EOK) && (box->items_count > 0))
{
rt_uint16_t index;
index = (emouse->y - rect.y1) / (2 + rtgui_theme_get_selected_height());
/* set focus */
rtgui_widget_focus(widget);
{
struct rtgui_rect rect;
struct rtgui_dc* dc;
dc = rtgui_dc_begin_drawing(RTGUI_WIDGET(box));
if (dc != RT_NULL)
{
/* get widget rect */
rtgui_widget_get_rect(RTGUI_WIDGET(box), &rect);
/* update focus border */
rect.x2 -= 1; rect.y2 -= 1;
/* draw focused border */
if (RTGUI_WIDGET_IS_FOCUSED(RTGUI_WIDGET(box)))
rtgui_dc_draw_focus_rect(dc, &rect);
rtgui_dc_end_drawing(dc);
}
}
if ((index < box->items_count) && (index < box->page_items))
{
rt_uint16_t old_item;
old_item = box->current_item;
/* set selected item */
box->current_item = (box->current_item/box->page_items) * box->page_items + index;
if (emouse->button & RTGUI_MOUSE_BUTTON_DOWN)
{
/* down event */
rtgui_listbox_update_current(box, old_item);
}
else
{
/* up event */
if (box->on_item != RT_NULL)
{
box->on_item(RTGUI_WIDGET(box), RT_NULL);
}
}
}
}
return RT_TRUE;
}
case RTGUI_EVENT_KBD:
{
struct rtgui_event_kbd* ekbd = (struct rtgui_event_kbd*)event;
if ((ekbd->type == RTGUI_KEYDOWN) && (box->items_count > 0))
{
rt_uint16_t old_item;
old_item = box->current_item;
switch (ekbd->key)
{
case RTGUIK_LEFT:
if (box->current_item - box->page_items >= 0)
box->current_item -= box->page_items;
rtgui_listbox_update_current(box, old_item);
return RT_FALSE;
case RTGUIK_UP:
if (box->current_item > 0)
box->current_item --;
rtgui_listbox_update_current(box, old_item);
return RT_FALSE;
case RTGUIK_RIGHT:
if (box->current_item + box->page_items < box->items_count - 1)
box->current_item += box->page_items;
rtgui_listbox_update_current(box, old_item);
return RT_FALSE;
case RTGUIK_DOWN:
if (box->current_item < box->items_count - 1)
box->current_item ++;
rtgui_listbox_update_current(box, old_item);
return RT_FALSE;
case RTGUIK_RETURN:
if (box->on_item != RT_NULL)
{
box->on_item(RTGUI_WIDGET(box), RT_NULL);
}
return RT_FALSE;
default:
break;
}
}
}
return RT_FALSE;
}
/* use box event handler */
return rtgui_widget_event_handler(widget, event);
}
rt_bool_t rtgui_workbench_event_handler(rtgui_widget_t* widget, rtgui_event_t* event)
{
struct rtgui_workbench* workbench = (struct rtgui_workbench*)widget;
switch (event->type)
{
case RTGUI_EVENT_PANEL_DETACH:
RTGUI_WIDGET_HIDE(RTGUI_WIDGET(workbench));
RTGUI_TOPLEVEL(workbench)->server = RT_NULL;
return RT_TRUE;
case RTGUI_EVENT_PANEL_SHOW:
/* show workbench in server */
rtgui_workbench_show(workbench);
break;
case RTGUI_EVENT_PANEL_HIDE:
/* hide widget */
RTGUI_WIDGET_HIDE(widget);
break;
case RTGUI_EVENT_MOUSE_MOTION:
{
struct rtgui_event_mouse* emouse = (struct rtgui_event_mouse*)event;
struct rtgui_toplevel* top = RTGUI_TOPLEVEL(emouse->wid);
/* check the destination window */
if (top != RT_NULL && RTGUI_WIDGET(top)->event_handler != RT_NULL)
{
RTGUI_WIDGET(top)->event_handler(RTGUI_WIDGET(top), event);
}
else
{
/* let viewer to handle it */
rtgui_view_t* view = workbench->current_view;
if (view != RT_NULL &&
RTGUI_WIDGET(view)->event_handler != RT_NULL)
{
RTGUI_WIDGET(view)->event_handler(RTGUI_WIDGET(view), event);
}
}
}
break;
case RTGUI_EVENT_MOUSE_BUTTON:
{
struct rtgui_event_mouse* emouse = (struct rtgui_event_mouse*)event;
struct rtgui_toplevel* top = RTGUI_TOPLEVEL(emouse->wid);
/* check the destination window */
if (top != RT_NULL && RTGUI_WIDGET(top)->event_handler != RT_NULL)
{
RTGUI_WIDGET(top)->event_handler(RTGUI_WIDGET(top), event);
}
else
{
if (RTGUI_WORKBENCH_IS_MODAL_MODE(workbench))
{
/* let modal widget to handle it */
if (workbench->modal_widget != RT_NULL &&
workbench->modal_widget->event_handler != RT_NULL)
{
workbench->modal_widget->event_handler(workbench->modal_widget, event);
}
}
else
{
/* let viewer to handle it */
rtgui_view_t* view = workbench->current_view;
if (view != RT_NULL &&
RTGUI_WIDGET(view)->event_handler != RT_NULL)
{
RTGUI_WIDGET(view)->event_handler(RTGUI_WIDGET(view), event);
}
}
}
}
break;
case RTGUI_EVENT_KBD:
{
struct rtgui_event_kbd* kbd = (struct rtgui_event_kbd*)event;
struct rtgui_toplevel* top = RTGUI_TOPLEVEL(kbd->wid);
/* check the destination window */
if (top != RT_NULL && RTGUI_WIDGET(top)->event_handler != RT_NULL)
{
RTGUI_WIDGET(top)->event_handler(RTGUI_WIDGET(top), event);
}
else
{
if (RTGUI_WORKBENCH_IS_MODAL_MODE(workbench))
{
/* let modal widget to handle it */
if (workbench->modal_widget != RT_NULL &&
workbench->modal_widget->event_handler != RT_NULL)
{
workbench->modal_widget->event_handler(workbench->modal_widget, event);
}
}
else
{
if (RTGUI_CONTAINER(widget)->focused == widget)
{
/* set focused widget to the current view */
if (workbench->current_view != RT_NULL)
rtgui_widget_focus(RTGUI_WIDGET(RTGUI_CONTAINER(workbench->current_view)->focused));
}
return rtgui_toplevel_event_handler(widget, event);
}
}
}
break;
case RTGUI_EVENT_PAINT:
{
struct rtgui_event_paint* epaint = (struct rtgui_event_paint*)event;
struct rtgui_toplevel* top = RTGUI_TOPLEVEL(epaint->wid);
/* check the destination window */
if (top != RT_NULL && RTGUI_WIDGET(top)->event_handler != RT_NULL)
{
RTGUI_WIDGET(top)->event_handler(RTGUI_WIDGET(top), event);
}
else
{
rtgui_view_t* view;
/* un-hide workbench */
RTGUI_WIDGET_UNHIDE(widget);
/* paint a view */
view = workbench->current_view;
if (view != RT_NULL)
{
/* remake a paint event */
RTGUI_EVENT_PAINT_INIT(epaint);
epaint->wid = RT_NULL;
/* send this event to the view */
if (RTGUI_WIDGET(view)->event_handler != RT_NULL)
{
RTGUI_WIDGET(view)->event_handler(RTGUI_WIDGET(view), event);
}
}
else
{
struct rtgui_dc* dc;
struct rtgui_rect rect;
dc = rtgui_dc_begin_drawing(widget);
rtgui_widget_get_rect(widget, &rect);
rtgui_dc_fill_rect(dc, &rect);
rtgui_dc_end_drawing(dc);
}
}
}
break;
case RTGUI_EVENT_CLIP_INFO:
{
struct rtgui_event_clip_info* eclip = (struct rtgui_event_clip_info*)event;
struct rtgui_widget* dest_widget = RTGUI_WIDGET(eclip->wid);
if (dest_widget != RT_NULL && dest_widget->event_handler != RT_NULL)
{
dest_widget->event_handler(dest_widget, event);
}
else
{
return rtgui_toplevel_event_handler(widget, event);
}
}
break;
case RTGUI_EVENT_WIN_CLOSE:
case RTGUI_EVENT_WIN_ACTIVATE:
case RTGUI_EVENT_WIN_DEACTIVATE:
{
struct rtgui_event_win* wevent = (struct rtgui_event_win*)event;
struct rtgui_widget* dest_widget = RTGUI_WIDGET(wevent->wid);
if (dest_widget != RT_NULL && dest_widget->event_handler != RT_NULL)
{
dest_widget->event_handler(dest_widget, event);
}
}
break;
case RTGUI_EVENT_WIN_MOVE:
{
struct rtgui_event_win_move* wevent = (struct rtgui_event_win_move*)event;
struct rtgui_toplevel* top = RTGUI_TOPLEVEL(wevent->wid);
if (top != RT_NULL && RTGUI_WIDGET(top)->event_handler != RT_NULL)
{
RTGUI_WIDGET(top)->event_handler(RTGUI_WIDGET(top), event);
}
}
break;
default:
return rtgui_toplevel_event_handler(widget, event);
}
return RT_TRUE;
}
rt_base_t rtgui_win_show(struct rtgui_win* win, rt_bool_t is_modal)
{
struct rtgui_event_win_show eshow;
rt_base_t exit_code = -1;
RTGUI_EVENT_WIN_SHOW_INIT(&eshow);
eshow.wid = win;
if (win == RT_NULL)
return exit_code;
/* if it does not register into server, create it in server */
if (!(win->flag & RTGUI_WIN_FLAG_CONNECTED))
{
if (_rtgui_win_create_in_server(win) == RT_FALSE)
return exit_code;
}
if (rtgui_server_post_event_sync(RTGUI_EVENT(&eshow),
sizeof(struct rtgui_event_win_show)
) != RT_EOK)
{
rt_kprintf("show win failed\n");
return exit_code;
}
/* set window unhidden */
RTGUI_WIDGET_UNHIDE(RTGUI_WIDGET(win));
if (win->focused_widget == RT_NULL)
rtgui_widget_focus(RTGUI_WIDGET(win));
if (is_modal == RT_TRUE)
{
struct rtgui_application *app;
struct rtgui_event_win_modal_enter emodal;
RTGUI_EVENT_WIN_MODAL_ENTER_INIT(&emodal);
emodal.wid = win;
app = rtgui_application_self();
RT_ASSERT(app != RT_NULL);
win->flag |= RTGUI_WIN_FLAG_MODAL;
if (rtgui_server_post_event_sync((struct rtgui_event*)&emodal,
sizeof(emodal)) != RT_EOK)
return exit_code;
app->modal_object = RTGUI_OBJECT(win);
exit_code = rtgui_application_run(app);
app->modal_object = RT_NULL;
win->flag &= ~RTGUI_WIN_FLAG_MODAL;
if (win->style & RTGUI_WIN_STYLE_DESTROY_ON_CLOSE)
{
rtgui_win_destroy(win);
}
}
return exit_code;
}
/* thumb chunk activity */
static void _rtgui_scrollbar_on_mousemotion(rtgui_scrollbar_t *bar, rtgui_event_t * event)
{
float tmppos;
rt_uint32_t pos;
struct rtgui_event_mouse *mouse = (struct rtgui_event_mouse*)event;
rt_kprintf("sbar mouse motion.\n");
tmppos = _rtgui_scrollbar_get_length(bar);
tmppos /= bar->count;
pos = (rt_uint32_t)tmppos;
if(bar->orient == RTGUI_VERTICAL)
{
if(bar->status & SBS_VERTTHUMB)
{
/* from then on mouseclick */
if((mouse->y-sbar_mouse_move_size.y) > 3)
{
bar->status |= SBS_DOWNTHUMB;
}
else if((mouse->y-sbar_mouse_move_size.y) < -3)
{
bar->status |= SBS_UPTHUMB;
}
else bar->status &= ~(SBS_UPTHUMB|SBS_DOWNTHUMB);
if(abs(mouse->y-sbar_mouse_move_size.y) >= pos)
{
int step = abs(mouse->y-sbar_mouse_move_size.y)/pos;
sbar_mouse_move_size.y = mouse->y;
if(bar->status & SBS_UPTHUMB)
{
bar->value -= step;
if(bar->value < 0) bar->value = 0;
}
else if(bar->status & SBS_DOWNTHUMB)
{
bar->value += step;
if(bar->value > bar->count) bar->value = bar->count;
}
goto __exit;
}
}
else if(bar->status & SBS_UPARROW)
{
/* on-going push down uparrow button */
if(bar->value==0)return;
bar->value -= bar->line_step;
if(bar->value < 0) bar->value = 0;
goto __exit;
}
else if(bar->status & SBS_DOWNARROW)
{
/* on-going push down downarrow button */
if(bar->value==bar->count)return;
bar->value += bar->line_step;
if(bar->value > bar->count) bar->value = bar->count;
goto __exit;
}
/*else if(bar->status & SBS_UPSPACE)
{
bar->value -= bar->page_step;
if(bar->value < 0) bar->value = 0;
goto __exit;
}
else if(bar->status & SBS_DOWNSPACE)
{
bar->value += bar->page_step;
if(bar->value > bar->count) bar->value = bar->count;
goto __exit;
}*/
return;
}
else
{
if(bar->status & SBS_HORZTHUMB)
{rt_kprintf("HORZTHUMB, move event\n");
if((mouse->x-sbar_mouse_move_size.x) > 5)
{
bar->status |= SBS_RIGHTTHUMB;
}
else if((mouse->x-sbar_mouse_move_size.x) < -5)
{
bar->status |= SBS_LEFTTHUMB;
}
if(abs(mouse->x-sbar_mouse_move_size.x) > pos)
{
int step = abs(mouse->x-sbar_mouse_move_size.x)/pos;
sbar_mouse_move_size.x = mouse->x;
if(bar->status & SBS_LEFTTHUMB)
{
bar->value -= step;
if(bar->value < 0) bar->value = 0;
}
else if(bar->status & SBS_RIGHTTHUMB)
{
bar->value += step;
if(bar->value > bar->count) bar->value = bar->count;
}
goto __exit;
}
}
else if(bar->status & SBS_LEFTARROW)
{
if(bar->value==0)return;
bar->value -= bar->line_step;
if(bar->value < 0) bar->value = 0;
goto __exit;
}
else if(bar->status & SBS_RIGHTARROW)
{
if(bar->value==bar->count)return;
bar->value += bar->line_step;
if(bar->value > bar->count) bar->value = bar->count;
goto __exit;
}
/*else if(bar->status & SBS_LEFTSPACE)
{
bar->value -= bar->page_step;
if(bar->value < bar->min) bar->value = bar->min;
goto __exit;
}
else if(bar->status & SBS_RIGHTSPACE)
{
bar->value += bar->page_step;
if(bar->value > bar->count-1) bar->value = bar->count-1;
goto __exit;
}*/
return;
}
__exit:
rtgui_scrollbar_ondraw(bar);
if(bar->widget_link != RT_NULL && bar->on_scroll != RT_NULL)
{
rtgui_widget_focus(bar->widget_link);
bar->on_scroll(RTGUI_OBJECT(bar->widget_link), event);
}
}
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_uint32_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_base_t rtgui_win_show(struct rtgui_win* win, rt_bool_t is_modal)
{
rt_base_t exit_code = -1;
struct rtgui_app *app;
struct rtgui_event_win_show eshow;
app = rtgui_app_self();
RTGUI_EVENT_WIN_SHOW_INIT(&eshow);
eshow.wid = win;
if (win == RT_NULL)
return exit_code;
/* if it does not register into server, create it in server */
if (!(win->flag & RTGUI_WIN_FLAG_CONNECTED))
{
if (_rtgui_win_create_in_server(win) == RT_FALSE)
return exit_code;
}
/* set window unhidden before notify the server */
rtgui_widget_show(RTGUI_WIDGET(win));
if (rtgui_server_post_event_sync(RTGUI_EVENT(&eshow),
sizeof(struct rtgui_event_win_show)) != RT_EOK)
{
/* It could not be shown if a parent window is hidden. */
rtgui_widget_hide(RTGUI_WIDGET(win));
return exit_code;
}
if (win->focused_widget == RT_NULL)
rtgui_widget_focus(RTGUI_WIDGET(win));
/* set main window */
if (app->main_object == RT_NULL)
rtgui_app_set_main_win(win);
if (is_modal == RT_TRUE)
{
struct rtgui_app *app;
struct rtgui_event_win_modal_enter emodal;
RTGUI_EVENT_WIN_MODAL_ENTER_INIT(&emodal);
emodal.wid = win;
app = rtgui_app_self();
RT_ASSERT(app != RT_NULL);
win->flag |= RTGUI_WIN_FLAG_MODAL;
if (rtgui_server_post_event_sync((struct rtgui_event*)&emodal,
sizeof(emodal)) != RT_EOK)
return exit_code;
app->modal_object = RTGUI_OBJECT(win);
exit_code = rtgui_app_run(app);
app->modal_object = RT_NULL;
win->flag &= ~RTGUI_WIN_FLAG_MODAL;
if (win->style & RTGUI_WIN_STYLE_DESTROY_ON_CLOSE)
{
rtgui_win_destroy(win);
}
}
return exit_code;
}
