void rtgui_menu_pop(struct rtgui_menu* menu, int x, int y)
{
rtgui_rect_t rect;
struct rtgui_event_resize eresize;
if (menu == RT_NULL) return;
/* set window extent */
rect.x1 = 0; rect.y1 = 0;
rect.x2 = 100; rect.y2 = menu->items_count * (rtgui_theme_get_selected_height() + 2) + 5;
rtgui_rect_moveto(&rect, x, y);
rtgui_win_set_rect(RTGUI_WIN(menu), &rect);
rtgui_rect_inflate(&rect, -1);
rtgui_widget_set_rect(RTGUI_WIDGET(menu->items_list), &rect);
eresize.parent.type = RTGUI_EVENT_RESIZE;
eresize.x = rect.x1; eresize.y = rect.y1;
eresize.h = rect.y2 - rect.y1; eresize.w = rect.x2 - rect.x1;
rtgui_listctrl_event_handler(RTGUI_WIDGET(menu->items_list), &(eresize.parent));
/* on menu pop handler */
if (menu->on_menupop != RT_NULL)
{
menu->on_menupop(RTGUI_WIDGET(menu), RT_NULL);
}
/* show menu window */
rtgui_win_show(RTGUI_WIN(menu), RT_FALSE);
}
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;
}
static void rtgui_filelist_view_menu_pop(rtgui_widget_t *parent)
{
struct rtgui_win *menu;
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_DESTROY_ON_CLOSE);
if (menu != RT_NULL)
{
rtgui_listbox_t *listbox;
/* Pass the pointer to filelist_view via user_data. */
menu->user_data = (rt_uint32_t)parent;
rtgui_win_set_ondeactivate(menu, rtgui_filelist_view_on_menu_deactivate);
listbox = rtgui_listbox_create(_folder_actions,
sizeof(_folder_actions) / sizeof(_folder_actions[0]),
&rect);
/* Set the item index *before* setup the callback. `set_current_item`
* will invoke the "onitem". So just keep it clean when setting the
* current item. */
rtgui_listbox_set_current_item(listbox, 0);
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_TRUE);
}
}
rt_bool_t on_window_close(struct rtgui_object* object, struct rtgui_event* event)
{
rt_kprintf("win %s(%p) closing\n",
rtgui_win_get_title(RTGUI_WIN(object)),
object);
return RT_TRUE;
}
static rt_bool_t _rtgui_menu_onitem(struct rtgui_object* object, struct rtgui_event* event)
{
struct rtgui_menu* menu;
/* event will be NULL, don't check it. */
RT_ASSERT(object);
/* get menu */
menu = RTGUI_MENU(rtgui_widget_get_toplevel(RTGUI_WIDGET(object)));
if (menu->items[menu->items_list->current_item].type == RTGUI_ITEM_SUBMENU)
{
const rtgui_menu_item_t* items;
rt_uint16_t count;
rtgui_rect_t item_rect;
items = (rtgui_menu_item_t*)menu->items[menu->items_list->current_item].submenu;
count = menu->items[menu->items_list->current_item].submenu_count;
if (menu->sub_menu != RT_NULL)
{
if (menu->sub_menu->items == items)
{
if (!RTGUI_WIDGET_IS_HIDE(RTGUI_WIDGET(menu->sub_menu)))
{
/* hide this sub menu */
rtgui_win_hiden(RTGUI_WIN(menu->sub_menu));
return RT_FALSE;
}
/* show this sub menu */
rtgui_listctrl_get_item_rect(menu->items_list, menu->items_list->current_item, &item_rect);
rtgui_menu_pop(menu->sub_menu, item_rect.x2, item_rect.y1);
return RT_FALSE;
}
/* delete sub menu */
rtgui_menu_destroy(menu->sub_menu);
menu->sub_menu = RT_NULL;
}
/* create sub menu */
menu->sub_menu = rtgui_menu_create("submenu", menu, items, count);
rtgui_listctrl_get_item_rect(menu->items_list, menu->items_list->current_item, &item_rect);
rtgui_menu_pop(menu->sub_menu, item_rect.x2 + 5, item_rect.y1);
}
else /* other menu item */
{
/* invoke action */
if (menu->items[menu->items_list->current_item].on_menuaction != RT_NULL)
menu->items[menu->items_list->current_item].on_menuaction(RTGUI_OBJECT(menu), RT_NULL);
/* hide sub-menu */
if (menu->sub_menu != RT_NULL)
{
rtgui_menu_hiden(menu->sub_menu);
}
rtgui_menu_hiden(menu);
}
return RT_FALSE;
}
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);
}
}
rtgui_win_t* rtgui_win_create(struct rtgui_win* parent_window,
const char* title,
rtgui_rect_t *rect,
rt_uint16_t style)
{
struct rtgui_win* win;
/* allocate win memory */
win = RTGUI_WIN(rtgui_widget_create(RTGUI_WIN_TYPE));
if (win == RT_NULL)
return RT_NULL;
/* set parent toplevel */
win->parent_window = parent_window;
/* set title, rect and style */
if (title != RT_NULL)
win->title = rt_strdup(title);
else
win->title = RT_NULL;
rtgui_widget_set_rect(RTGUI_WIDGET(win), rect);
win->style = style;
if (_rtgui_win_create_in_server(win) == RT_FALSE)
{
goto __on_err;
}
return win;
__on_err:
rtgui_widget_destroy(RTGUI_WIDGET(win));
return RT_NULL;
}
static rt_bool_t rtgui_combobox_pulldown_hide(struct rtgui_object* object, struct rtgui_event* event)
{
struct rtgui_widget *widget;
struct rtgui_combobox *box;
RT_ASSERT(object != RT_NULL);
RT_ASSERT(event != RT_NULL);
widget = RTGUI_WIDGET(object);
box = RTGUI_COMBOBOX(object);
if (widget == RT_NULL) return RT_TRUE;
box = (struct rtgui_combobox*) (((struct rtgui_win*)widget)->user_data);
if (box == RT_NULL) return RT_TRUE;
/* hide pull down window */
rtgui_win_hiden(RTGUI_WIN(box->pd_win));
/* clear pull down button state */
box->pd_pressed = RT_FALSE;
rtgui_widget_update(RTGUI_WIDGET(box));
return RT_TRUE;
}
void rtgui_menu_hiden(struct rtgui_menu* menu)
{
rtgui_win_hiden(RTGUI_WIN(menu));
if (menu->parent_menu != RT_NULL)
rtgui_menu_hiden(menu->parent_menu);
}
void rtgui_win_end_modal(struct rtgui_win* win, rtgui_modal_code_t modal_code)
{
if (win->parent_toplevel != RT_NULL)
{
if (RTGUI_IS_WORKBENCH(win->parent_toplevel))
{
rtgui_workbench_t* workbench;
/* which is shown under workbench */
workbench = RTGUI_WORKBENCH(win->parent_toplevel);
workbench->modal_code = modal_code;
workbench->flag &= ~RTGUI_WORKBENCH_FLAG_MODAL_MODE;
}
else if (RTGUI_IS_WIN(win->parent_toplevel))
{
rtgui_win_t* parent_win;
/* which is shown under win */
parent_win = RTGUI_WIN(win->parent_toplevel);
parent_win->modal_code = modal_code;
parent_win->style &= ~RTGUI_WIN_STYLE_UNDER_MODAL;
}
}
else
{
/* which is a stand alone window */
win->modal_code = modal_code;
}
/* remove modal mode */
win->style &= ~RTGUI_WIN_STYLE_MODAL;
}
struct rtgui_menu* rtgui_menu_create(const char* title, struct rtgui_menu* parent_menu,
const struct rtgui_menu_item* items, rt_uint16_t count)
{
rtgui_rect_t rect = {0, 0, 100, 100};
struct rtgui_menu* menu;
menu = (struct rtgui_menu*) rtgui_widget_create ( RTGUI_MENU_TYPE );
if (menu != RT_NULL)
{
rtgui_win_set_title(RTGUI_WIN(menu), title);
menu->parent_menu = parent_menu;
menu->items = items;
menu->items_count = count;
rtgui_widget_set_rect(RTGUI_WIDGET(menu), &rect);
rtgui_rect_inflate(&rect, -1);
/* create menu item list */
menu->items_list = rtgui_listctrl_create((rt_uint32_t)items, count, &rect, _rtgui_menu_item_ondraw);
RTGUI_WIDGET_BACKGROUND(RTGUI_WIDGET(menu->items_list)) = rtgui_theme_default_bc();
rtgui_container_add_child(RTGUI_CONTAINER(menu), RTGUI_WIDGET(menu->items_list));
rtgui_listctrl_set_onitem(menu->items_list, _rtgui_menu_onitem);
}
return menu;
}
static rt_bool_t rtgui_menu_on_deactivate(struct rtgui_object *object, rtgui_event_t* event)
{
rtgui_menu_t* menu;
RTGUI_WIDGET_EVENT_HANDLER_PREPARE
menu = RTGUI_MENU(object);
if (menu->parent_menu != RT_NULL)
{
/* whether click on parent menu */
if (rtgui_win_is_activated(RTGUI_WIN(menu->parent_menu)) == RT_TRUE &&
menu->parent_menu->items[menu->parent_menu->items_list->current_item].submenu
== (struct rtgui_menu_item_t *)menu->items)
return RT_TRUE;
}
/* submenu is activate */
if (menu->items[menu->items_list->current_item].type == RTGUI_ITEM_SUBMENU)
{
/* if sub menu activated, not hide menu. But we cannot use the
* activated flag as criteria since the old window is deactivated
* before the new window got activated. But the window will be shown in
* this context, so use 'is not hide'. */
if (menu->sub_menu != RT_NULL &&
!RTGUI_WIDGET_IS_HIDE(RTGUI_WIDGET(menu->sub_menu)))
return RT_TRUE;
}
rtgui_win_hiden(RTGUI_WIN(menu));
if (menu->on_menuhide != RT_NULL)
{
menu->on_menuhide(RTGUI_OBJECT(menu), RT_NULL);
}
/* un-select item */
menu->items_list->current_item = -1;
/* if it's a submenu, try to hide parent menu */
if (menu->parent_menu != RT_NULL &&
rtgui_win_is_activated(RTGUI_WIN(menu->parent_menu)) == RT_FALSE)
{
rtgui_menu_on_deactivate(RTGUI_OBJECT(menu->parent_menu), event);
}
return RT_TRUE;
}
void rtgui_menu_hiden(struct rtgui_menu* menu)
{
rtgui_win_hiden(RTGUI_WIN(menu));
/* un-select item */
menu->items_list->current_item = -1;
if (menu->parent_menu != RT_NULL)
rtgui_menu_hiden(menu->parent_menu);
}
static void _rtgui_menu_constructor(rtgui_menu_t *menu)
{
/* set window style */
RTGUI_WIN(menu)->style = RTGUI_WIN_STYLE_NO_TITLE;
/* set deactivate handler */
rtgui_win_set_ondeactivate(RTGUI_WIN(menu), rtgui_menu_on_deactivate);
/* set proper of control */
menu->parent_menu = RT_NULL;
menu->sub_menu = RT_NULL;
menu->items = RT_NULL;
menu->items_count = 0;
menu->items_list = RT_NULL;
menu->on_menupop = RT_NULL;
menu->on_menuhide = RT_NULL;
}
static void demo_close_ntitle_window(struct rtgui_object *object, rtgui_event_t *event)
{
rtgui_win_t *win;
/* 获得最顶层控件 */
win = RTGUI_WIN(rtgui_widget_get_toplevel(RTGUI_WIDGET(object)));
/* 销毁窗口 */
rtgui_win_destroy(win);
}
/* 窗口关闭时的事件处理 */
void window_demo_close(struct rtgui_widget* widget, rtgui_event_t *even)
{
rtgui_win_t* win;
/* 获得最顶层控件 */
win = RTGUI_WIN(rtgui_widget_get_toplevel(widget));
/* 销毁窗口 */
rtgui_win_destroy(win);
}
static rt_bool_t rtgui_filelist_view_on_menu_deactivate(rtgui_object_t *object, struct rtgui_event *event)
{
rtgui_win_t *menu;
menu = RTGUI_WIN(rtgui_widget_get_toplevel(RTGUI_WIDGET(object)));
/* destroy menu window */
rtgui_win_destroy(menu);
return RT_TRUE;
}
static rt_bool_t rtgui_menu_on_deactivate(rtgui_widget_t* widget, rtgui_event_t* event)
{
rtgui_menu_t* menu = (rtgui_menu_t*) widget;
if (menu->parent_menu != RT_NULL)
{
/* whether click on parent menu */
if (rtgui_win_is_activated(RTGUI_WIN(menu->parent_menu)) == RT_TRUE &&
menu->parent_menu->items[menu->parent_menu->items_list->current_item].submenu == (struct rtgui_menu_item_t *)menu->items)
return RT_TRUE;
}
/* submenu is activate */
if (menu->items[menu->items_list->current_item].type == RTGUI_ITEM_SUBMENU)
{
/* if sub menu activated, not hide menu */
if (menu->sub_menu != RT_NULL &&
rtgui_win_is_activated(RTGUI_WIN(menu->sub_menu)) == RT_TRUE)
return RT_TRUE;
}
rtgui_win_hiden(RTGUI_WIN(menu));
if (menu->on_menuhide != RT_NULL)
{
menu->on_menuhide(RTGUI_WIDGET(menu), RT_NULL);
}
/* un-select item */
menu->items_list->current_item = -1;
/* if it's a submenu, try to hide parent menu */
if (menu->parent_menu != RT_NULL &&
rtgui_win_is_activated(RTGUI_WIN(menu->parent_menu)) == RT_FALSE)
{
rtgui_menu_on_deactivate(RTGUI_WIDGET(menu->parent_menu), event);
}
return RT_TRUE;
}
rtgui_win_t* rtgui_win_create(struct rtgui_win* parent_window,
const char* title,
rtgui_rect_t *rect,
rt_uint16_t style)
{
struct rtgui_win* win;
/* allocate win memory */
win = RTGUI_WIN(rtgui_widget_create(RTGUI_WIN_TYPE));
if (win == RT_NULL)
return RT_NULL;
/* set parent toplevel */
#ifdef RTGUI_USING_DESKTOP_WINDOW
if (style & RTGUI_WIN_STYLE_DESKTOP)
{
RT_ASSERT(the_desktop_window == RT_NULL);
win->parent_window = RT_NULL;
the_desktop_window = win;
}
else if (parent_window == RT_NULL)
{
RT_ASSERT(the_desktop_window != RT_NULL);
win->parent_window = the_desktop_window;
}
else
win->parent_window = parent_window;
#else
win->parent_window = parent_window;
#endif
/* set title, rect and style */
if (title != RT_NULL)
win->title = rt_strdup(title);
else
win->title = RT_NULL;
rtgui_widget_set_rect(RTGUI_WIDGET(win), rect);
win->style = style;
if (_rtgui_win_create_in_server(win) == RT_FALSE)
{
goto __on_err;
}
return win;
__on_err:
rtgui_widget_destroy(RTGUI_WIDGET(win));
return RT_NULL;
}
void rtgui_combobox_pdwin_onitem(struct rtgui_widget* widget, struct rtgui_event* event)
{
rtgui_win_t* pd_win;
rtgui_combobox_t* combo;
rtgui_listbox_t* list;
list = RTGUI_LISTBOX(widget);
pd_win = RTGUI_WIN(rtgui_widget_get_toplevel(widget));
combo = RTGUI_COMBOBOX(pd_win->user_data);
combo->current_item = list->current_item;
if (combo->on_selected != RT_NULL)
combo->on_selected(RTGUI_WIDGET(combo), RT_NULL);
rtgui_win_hiden(pd_win);
rtgui_widget_update(RTGUI_WIDGET(combo));
return ;
}
rt_bool_t rtgui_combobox_event_handler(struct rtgui_object* object, struct rtgui_event* event)
{
struct rtgui_combobox *box;
RTGUI_WIDGET_EVENT_HANDLER_PREPARE
box = RTGUI_COMBOBOX(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_combobox_ondraw(box);
break;
case RTGUI_EVENT_MOUSE_BUTTON:
return rtgui_combobox_onmouse_button(box, (struct rtgui_event_mouse*)event);
case RTGUI_EVENT_FOCUSED:
{
/* item focused */
struct rtgui_event_focused* focused;
focused = (struct rtgui_event_focused*) event;
if (focused->widget != RT_NULL)
{
/* hide pull down window */
rtgui_win_hiden(RTGUI_WIN(box->pd_win));
rtgui_combobox_ondraw(box);
}
}
break;
default:
return rtgui_widget_event_handler(object, event);
}
return RT_FALSE;
}
static rt_bool_t rtgui_filelist_view_on_folder_item(rtgui_object_t *object, struct rtgui_event *event)
{
rtgui_win_t *menu;
rtgui_listbox_t *listbox;
rtgui_filelist_view_t *view;
listbox = RTGUI_LISTBOX(object);
menu = RTGUI_WIN(rtgui_widget_get_toplevel(RTGUI_WIDGET(object)));
view = RTGUI_FILELIST_VIEW(menu->user_data);
/* hide window */
rtgui_win_hide(menu);
switch (listbox->current_item)
{
case 0:
{
char *dir_ptr;
/* destroy menu window */
rtgui_win_destroy(menu);
dir_ptr = (char *) rtgui_malloc(256);
rtgui_filelist_view_get_fullpath(view, dir_ptr, 256);
rtgui_filelist_view_set_directory(view, dir_ptr);
rtgui_free(dir_ptr);
}
break;
case 1:
/* destroy menu window */
rtgui_win_destroy(menu);
break;
default:
/* destroy menu window */
rtgui_win_destroy(menu);
break;
}
return RT_TRUE;
}
rt_bool_t rtgui_combobox_event_handler(struct rtgui_widget* widget, struct rtgui_event* event)
{
struct rtgui_combobox* box = (struct rtgui_combobox*)widget;
switch (event->type)
{
case RTGUI_EVENT_PAINT:
#ifndef RTGUI_USING_SMALL_SIZE
if (widget->on_draw != RT_NULL) widget->on_draw(widget, event);
else
#endif
rtgui_combobox_ondraw(box);
break;
case RTGUI_EVENT_MOUSE_BUTTON:
return rtgui_combobox_onmouse_button(box, (struct rtgui_event_mouse*)event);
case RTGUI_EVENT_FOCUSED:
{
/* item focused */
struct rtgui_item* item;
struct rtgui_event_focused* focused;
focused = (struct rtgui_event_focused*) event;
item = (struct rtgui_item*) (focused->widget);
if (item != RT_NULL)
{
/* hide pull down window */
rtgui_win_hiden(RTGUI_WIN(box->pd_win));
rtgui_combobox_ondraw(box);
}
}
break;
}
return RT_FALSE;
}
rt_bool_t rtgui_combobox_pdwin_onitem(struct rtgui_object* object, struct rtgui_event* event)
{
struct rtgui_widget *widget;
rtgui_win_t* pd_win;
rtgui_combobox_t* combo;
rtgui_listbox_t* list;
RT_ASSERT(object != RT_NULL);
widget = RTGUI_WIDGET(object);
list = RTGUI_LISTBOX(widget);
pd_win = RTGUI_WIN(rtgui_widget_get_toplevel(widget));
combo = RTGUI_COMBOBOX(pd_win->user_data);
combo->current_item = list->current_item;
if (combo->on_selected != RT_NULL)
combo->on_selected(RTGUI_OBJECT(combo), RT_NULL);
rtgui_win_hiden(pd_win);
rtgui_widget_update(RTGUI_WIDGET(combo));
return RT_FALSE;
}
struct rtgui_win *rtgui_app_get_main_win(struct rtgui_app *app)
{
return RTGUI_WIN(app->main_object);
}
rt_bool_t rtgui_win_event_handler(struct rtgui_object* object, struct rtgui_event* event)
{
struct rtgui_win* win;
RT_ASSERT(object != RT_NULL);
RT_ASSERT(event != RT_NULL);
win = RTGUI_WIN(object);
switch (event->type)
{
case RTGUI_EVENT_WIN_SHOW:
rtgui_win_show(win, RT_FALSE);
break;
case RTGUI_EVENT_WIN_HIDE:
rtgui_win_hiden(win);
break;
case RTGUI_EVENT_WIN_CLOSE:
_rtgui_win_deal_close(win, event);
/* don't broadcast WIN_CLOSE event to others */
return RT_TRUE;
case RTGUI_EVENT_WIN_MOVE:
{
struct rtgui_event_win_move* emove = (struct rtgui_event_win_move*)event;
/* move window */
rtgui_win_move(win, emove->x, emove->y);
}
break;
case RTGUI_EVENT_WIN_ACTIVATE:
if (RTGUI_WIDGET_IS_HIDE(RTGUI_WIDGET(win)))
{
/* activate a hide window */
return RT_TRUE;
}
win->flag |= RTGUI_WIN_FLAG_ACTIVATE;
#ifndef RTGUI_USING_SMALL_SIZE
if (RTGUI_WIDGET(object)->on_draw != RT_NULL)
RTGUI_WIDGET(object)->on_draw(object, event);
else
#endif
rtgui_widget_update(RTGUI_WIDGET(win));
if (win->on_activate != RT_NULL)
{
win->on_activate(RTGUI_OBJECT(object), event);
}
break;
case RTGUI_EVENT_WIN_DEACTIVATE:
if (win->flag & RTGUI_WIN_FLAG_MODAL)
{
/* FIXME: make modal concept clear and easy. See the comment of
* rtgui_topwin_modal_enter. */
/* There are various reason that a modal window got deactivated:
* 1, it has child windows and the user activate one of them.
* 2, the application has more than one root window and the
* user switched to one of the others.
*
* In any of the cases, we have nothing to do here.
*/
}
else
{
win->flag &= ~RTGUI_WIN_FLAG_ACTIVATE;
#ifndef RTGUI_USING_SMALL_SIZE
if (RTGUI_WIDGET(object)->on_draw != RT_NULL)
RTGUI_WIDGET(object)->on_draw(object, event);
else
#endif
rtgui_widget_update(RTGUI_WIDGET(win));
if (win->on_deactivate != RT_NULL)
{
win->on_deactivate(RTGUI_OBJECT(object), event);
}
}
break;
case RTGUI_EVENT_PAINT:
#ifndef RTGUI_USING_SMALL_SIZE
if (RTGUI_WIDGET(object)->on_draw != RT_NULL)
RTGUI_WIDGET(object)->on_draw(object, event);
else
#endif
rtgui_win_ondraw(win);
break;
case RTGUI_EVENT_MOUSE_BUTTON:
/* check whether has widget which handled mouse event before */
if (win->last_mevent_widget != RT_NULL)
{
RTGUI_OBJECT(win->last_mevent_widget)->event_handler(
RTGUI_OBJECT(win->last_mevent_widget),
event);
/* clean last mouse event handled widget */
win->last_mevent_widget = RT_NULL;
}
else if (rtgui_container_dispatch_mouse_event(RTGUI_CONTAINER(win),
(struct rtgui_event_mouse*)event) == RT_FALSE)
{
#ifndef RTGUI_USING_SMALL_SIZE
if (RTGUI_WIDGET(object)->on_mouseclick != RT_NULL)
{
return RTGUI_WIDGET(object)->on_mouseclick(object, event);
}
#endif
}
break;
case RTGUI_EVENT_MOUSE_MOTION:
#if 0
if (rtgui_widget_dispatch_mouse_event(widget,
(struct rtgui_event_mouse*)event) == RT_FALSE)
{
#ifndef RTGUI_USING_SMALL_SIZE
/* handle event in current widget */
if (widget->on_mousemotion != RT_NULL)
{
return widget->on_mousemotion(widget, event);
}
#endif
}
else return RT_TRUE;
#endif
break;
case RTGUI_EVENT_KBD:
/* we should dispatch key event firstly */
if (!(win->flag & RTGUI_WIN_FLAG_HANDLE_KEY))
{
rt_bool_t res = RT_FALSE;
/* we should dispatch the key event just once. Once entered the
* dispatch mode, we should swtich to key handling mode. */
win->flag |= RTGUI_WIN_FLAG_HANDLE_KEY;
/* dispatch the key event */
if (win->focused_widget != RT_NULL &&
RTGUI_OBJECT(win->focused_widget)->event_handler != RT_NULL)
res = RTGUI_OBJECT(win->focused_widget)->event_handler(
RTGUI_OBJECT(win->focused_widget), event);
/* if the focused widget doesn't handle it, I will handle it. */
if (res != RT_TRUE && win->on_key != RT_NULL)
res = win->on_key(RTGUI_OBJECT(win), event);
win->flag &= ~RTGUI_WIN_FLAG_HANDLE_KEY;
return res;
}
else
{
/* in key handling mode(it may reach here in
* win->focused_widget->event_handler call) */
if (win->on_key != RT_NULL)
return win->on_key(RTGUI_OBJECT(win), event);
}
break;
default:
/* call parent event handler */
return rtgui_toplevel_event_handler(object, event);
}
return RT_FALSE;
}
rt_bool_t rtgui_app_event_handler(struct rtgui_object* object, rtgui_event_t* event)
{
struct rtgui_app* app;
RT_ASSERT(object != RT_NULL);
RT_ASSERT(event != RT_NULL);
app = RTGUI_APP(object);
switch (event->type)
{
case RTGUI_EVENT_PAINT:
case RTGUI_EVENT_CLIP_INFO:
case RTGUI_EVENT_WIN_ACTIVATE:
case RTGUI_EVENT_WIN_DEACTIVATE:
case RTGUI_EVENT_WIN_CLOSE:
case RTGUI_EVENT_WIN_MOVE:
case RTGUI_EVENT_KBD:
_rtgui_application_dest_handle(app, event);
break;
case RTGUI_EVENT_APP_ACTIVATE:
if (app->main_object != RT_NULL)
{
rtgui_win_activate(RTGUI_WIN(app->main_object));
if (app->modal_object != RT_NULL)
rtgui_win_activate(RTGUI_WIN(app->modal_object));
}
else if (app->modal_object != RT_NULL)
{
rtgui_win_activate(RTGUI_WIN(app->modal_object));
}
break;
case RTGUI_EVENT_APP_DESTROY:
rtgui_app_exit(app, 0);
break;
case RTGUI_EVENT_MOUSE_BUTTON:
case RTGUI_EVENT_MOUSE_MOTION:
{
struct rtgui_event_win* wevent = (struct rtgui_event_win*)event;
struct rtgui_object* dest_object = RTGUI_OBJECT(wevent->wid);
// FIXME: let application determine the dest_wiget but not in sever
// so we can combine this handler with above one
if (app->modal_object != RT_NULL &&
dest_object != app->modal_object)
{
// rt_kprintf("discard event %s that is not sent to modal object\n",
// event_string[event->type]);
}
else
{
_rtgui_application_dest_handle(app, event);
}
}
break;
case RTGUI_EVENT_TIMER:
{
struct rtgui_timer* timer;
struct rtgui_event_timer* etimer = (struct rtgui_event_timer*) event;
timer = etimer->timer;
if (timer->timeout != RT_NULL)
{
/* call timeout function */
timer->timeout(timer, timer->user_data);
}
}
break;
case RTGUI_EVENT_COMMAND:
{
struct rtgui_event_command *ecmd = (struct rtgui_event_command*)event;
if (ecmd->wid != RT_NULL)
return _rtgui_application_dest_handle(app, event);
}
}
return rtgui_object_event_handler(object, event);
}
rtgui_modal_code_t rtgui_win_show(struct rtgui_win* win, rt_bool_t is_modal)
{
rtgui_modal_code_t result;
RT_ASSERT(win != RT_NULL);
result = RTGUI_MODAL_CANCEL;
/* if it does not register into server, create it in server */
if (RTGUI_TOPLEVEL(win)->server == RT_NULL)
{
if (_rtgui_win_create_in_server(win) == RT_FALSE)
return result;
}
if (RTGUI_WIDGET_IS_HIDE(RTGUI_WIDGET(win)))
{
/* send show message to server */
struct rtgui_event_win_show eshow;
RTGUI_EVENT_WIN_SHOW_INIT(&eshow);
eshow.wid = win;
if (rtgui_thread_send_sync(RTGUI_TOPLEVEL(win)->server, RTGUI_EVENT(&eshow),
sizeof(struct rtgui_event_win_show)) != RT_EOK)
{
/* hide window failed */
return result;
}
/* set window unhidden */
RTGUI_WIDGET_UNHIDE(RTGUI_WIDGET(win));
}
else rtgui_widget_update(RTGUI_WIDGET(win));
if (is_modal == RT_TRUE)
{
if (win->parent_toplevel != RT_NULL)
{
rtgui_widget_t *parent_widget;
/* set style */
win->style |= RTGUI_WIN_STYLE_MODAL;
/* get root toplevel */
parent_widget = RTGUI_WIDGET(win->parent_toplevel);
if (RTGUI_IS_WORKBENCH(parent_widget))
{
rtgui_workbench_t* workbench;
workbench = RTGUI_WORKBENCH(win->parent_toplevel);
workbench->flag |= RTGUI_WORKBENCH_FLAG_MODAL_MODE;
workbench->modal_widget = RTGUI_WIDGET(win);
rtgui_workbench_event_loop(workbench);
result = workbench->modal_code;
workbench->flag &= ~RTGUI_WORKBENCH_FLAG_MODAL_MODE;
workbench->modal_widget = RT_NULL;
}
else if (RTGUI_IS_WIN(parent_widget))
{
rtgui_win_t* parent_win;
parent_win = RTGUI_WIN(win->parent_toplevel);
parent_win->style |= RTGUI_WIN_STYLE_UNDER_MODAL;
parent_win->modal_widget = RTGUI_WIDGET(win);
rtgui_win_event_loop(parent_win);
result = parent_win->modal_code;
parent_win->style &= ~RTGUI_WIN_STYLE_UNDER_MODAL;
parent_win->modal_widget = RT_NULL;
}
}
else
{
/* which is a root window */
win->style |= RTGUI_WIN_STYLE_MODAL;
rtgui_win_event_loop(win);
result = win->modal_code;
win->style &= ~RTGUI_WIN_STYLE_MODAL;
}
}
return result;
}
rt_bool_t calibration_event_handler(struct rtgui_widget* widget, struct rtgui_event* event)
{
switch (event->type)
{
case RTGUI_EVENT_PAINT:
{
struct rtgui_dc* dc;
struct rtgui_rect rect;
dc = rtgui_dc_begin_drawing(widget);
if (dc == RT_NULL) break;
/* get rect information */
rtgui_widget_get_rect(widget, &rect);
/* clear whole window */
RTGUI_WIDGET_BACKGROUND(widget) = white;
rtgui_dc_fill_rect(dc, &rect);
/* reset color */
RTGUI_WIDGET_BACKGROUND(widget) = green;
RTGUI_WIDGET_FOREGROUND(widget) = black;
switch (calibration_ptr->step)
{
case CALIBRATION_STEP_LEFTTOP:
rtgui_dc_draw_hline(dc, 0, 2 * CALIBRATION_WIDTH, CALIBRATION_HEIGHT);
rtgui_dc_draw_vline(dc, CALIBRATION_WIDTH, 0, 2 * CALIBRATION_HEIGHT);
RTGUI_WIDGET_FOREGROUND(widget) = red;
rtgui_dc_fill_circle(dc, CALIBRATION_WIDTH, CALIBRATION_HEIGHT, 4);
break;
case CALIBRATION_STEP_RIGHTTOP:
rtgui_dc_draw_hline(dc, calibration_ptr->width - 2 * CALIBRATION_WIDTH,
calibration_ptr->width, CALIBRATION_HEIGHT);
rtgui_dc_draw_vline(dc, calibration_ptr->width - CALIBRATION_WIDTH, 0, 2 * CALIBRATION_HEIGHT);
RTGUI_WIDGET_FOREGROUND(widget) = red;
rtgui_dc_fill_circle(dc, calibration_ptr->width - CALIBRATION_WIDTH, CALIBRATION_HEIGHT, 4);
break;
case CALIBRATION_STEP_LEFTBOTTOM:
rtgui_dc_draw_hline(dc, 0, 2 * CALIBRATION_WIDTH, calibration_ptr->height - CALIBRATION_HEIGHT);
rtgui_dc_draw_vline(dc, CALIBRATION_WIDTH, calibration_ptr->height - 2 * CALIBRATION_HEIGHT, calibration_ptr->height);
RTGUI_WIDGET_FOREGROUND(widget) = red;
rtgui_dc_fill_circle(dc, CALIBRATION_WIDTH, calibration_ptr->height - CALIBRATION_HEIGHT, 4);
break;
case CALIBRATION_STEP_RIGHTBOTTOM:
rtgui_dc_draw_hline(dc, calibration_ptr->width - 2 * CALIBRATION_WIDTH,
calibration_ptr->width, calibration_ptr->height - CALIBRATION_HEIGHT);
rtgui_dc_draw_vline(dc, calibration_ptr->width - CALIBRATION_WIDTH, calibration_ptr->height - 2 * CALIBRATION_HEIGHT, calibration_ptr->height);
RTGUI_WIDGET_FOREGROUND(widget) = red;
rtgui_dc_fill_circle(dc, calibration_ptr->width - CALIBRATION_WIDTH, calibration_ptr->height - CALIBRATION_HEIGHT, 4);
break;
case CALIBRATION_STEP_CENTER:
rtgui_dc_draw_hline(dc, calibration_ptr->width/2 - CALIBRATION_WIDTH, calibration_ptr->width/2 + CALIBRATION_WIDTH, calibration_ptr->height/2);
rtgui_dc_draw_vline(dc, calibration_ptr->width/2, calibration_ptr->height/2 - CALIBRATION_HEIGHT, calibration_ptr->height/2 + CALIBRATION_HEIGHT);
RTGUI_WIDGET_FOREGROUND(widget) = red;
rtgui_dc_fill_circle(dc, calibration_ptr->width/2, calibration_ptr->height/2, 4);
break;
}
rtgui_dc_end_drawing(dc);
}
break;
case RTGUI_EVENT_COMMAND:
{
struct rtgui_event_command* ecmd = (struct rtgui_event_command*)event;
switch (ecmd->command_id)
{
case TOUCH_WIN_UPDATE:
rtgui_widget_update(widget);
break;
case TOUCH_WIN_CLOSE:
rtgui_win_close(RTGUI_WIN(widget));
break;
}
}
return RT_TRUE;
default:
rtgui_win_event_handler(widget, event);
}
return RT_FALSE;
}
rt_bool_t rtgui_combobox_pdwin_ondeactive(struct rtgui_widget* widget, struct rtgui_event* event)
{
rtgui_win_hiden(RTGUI_WIN(widget));
return RT_TRUE;
}
