rt-thread/components/rtgui/server/topwin.c

/*
 * File      : topwin.c
 * This file is part of RT-Thread RTOS
 * COPYRIGHT (C) 2006 - 2009, 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
 * 2009-10-16     Bernard      first version
 */
#include "panel.h"
#include "topwin.h"
#include "mouse.h"

#include <rtgui/event.h>
#include <rtgui/image.h>
#include <rtgui/rtgui_theme.h>
#include <rtgui/rtgui_system.h>
#include <rtgui/widgets/window.h>

struct rtgui_topwin* rtgui_server_focus_topwin = RT_NULL;

static struct rtgui_list_node _rtgui_topwin_show_list;
static struct rtgui_list_node _rtgui_topwin_hide_list;
static struct rt_semaphore _rtgui_topwin_lock;

static void rtgui_topwin_update_clip(void);
static void rtgui_topwin_redraw(struct rtgui_rect* rect);

void rtgui_topwin_init()
{
	/* init window list */
	rtgui_list_init(&_rtgui_topwin_show_list);
	rtgui_list_init(&_rtgui_topwin_hide_list);

	rt_sem_init(&_rtgui_topwin_lock, 
		"topwin", 1, RT_IPC_FLAG_FIFO);
}

static struct rtgui_topwin*
rtgui_topwin_search_in_list(struct rtgui_win* wid, struct rtgui_list_node* list)
{
	struct rtgui_list_node* node;
	struct rtgui_topwin* topwin;

	/* search in list */
	rtgui_list_foreach(node, list)
	{
		topwin = rtgui_list_entry(node, struct rtgui_topwin, list);

		/* is this node? */
		if (topwin->wid == wid)
		{
			return topwin;
		}
	}

	return RT_NULL;
}

/* add a window to window list[hide] */
rt_err_t rtgui_topwin_add(struct rtgui_event_win_create* event)
{
	struct rtgui_topwin* topwin;

	topwin = rtgui_malloc(sizeof(struct rtgui_topwin));
	if (topwin == RT_NULL) return -RT_ERROR;

	topwin->wid 	= event->wid;
#ifdef RTGUI_USING_SMALL_SIZE
	topwin->extent	= RTGUI_WIDGET(event->wid)->extent;
#else
	topwin->extent 	= event->extent;
#endif
	topwin->tid 	= event->parent.sender;

	topwin->flag 	= 0;
	if (event->parent.user & RTGUI_WIN_STYLE_NO_TITLE) topwin->flag |= WINTITLE_NO;
	if (event->parent.user & RTGUI_WIN_STYLE_CLOSEBOX) topwin->flag |= WINTITLE_CLOSEBOX;
	if (!(event->parent.user & RTGUI_WIN_STYLE_NO_BORDER)) topwin->flag |= WINTITLE_BORDER;
	if (event->parent.user & RTGUI_WIN_STYLE_NO_FOCUS) topwin->flag |= WINTITLE_NOFOCUS;

	if(!(topwin->flag & WINTITLE_NO) || (topwin->flag & WINTITLE_BORDER))
	{
		/* get win extent */
		rtgui_rect_t rect = topwin->extent;

		/* add border rect */
		if (topwin->flag & WINTITLE_BORDER)
		{
			rtgui_rect_inflate(&rect, WINTITLE_BORDER_SIZE);
		}

		/* add title rect */
		if (!(topwin->flag & WINTITLE_NO)) rect.y1 -= WINTITLE_HEIGHT;

#ifdef RTGUI_USING_SMALL_SIZE
		topwin->title = rtgui_wintitle_create(event->wid->title);
#else
		topwin->title = rtgui_wintitle_create((const char*)event->title);
#endif
		rtgui_widget_set_rect(RTGUI_WIDGET(topwin->title), &rect);

		/* update clip info */
		rtgui_toplevel_update_clip(RTGUI_TOPLEVEL(topwin->title));
		rtgui_region_subtract_rect(&(RTGUI_WIDGET(topwin->title)->clip),
			&(RTGUI_WIDGET(topwin->title)->clip),
			&(topwin->extent));
	}
	else topwin->title = RT_NULL;

	rtgui_list_init(&topwin->list);
	rtgui_list_init(&topwin->monitor_list);

	/* add topwin node to the hidden window list */
	rtgui_list_insert(&(_rtgui_topwin_hide_list), &(topwin->list));

	return RT_EOK;
}

rt_err_t rtgui_topwin_remove(struct rtgui_win* wid)
{
	struct rtgui_topwin* topwin;

	/* find the topwin node */
	topwin = rtgui_topwin_search_in_list(wid, &_rtgui_topwin_show_list);

	if (topwin)
	{
		/* remove node from list */
		rtgui_list_remove(&_rtgui_topwin_show_list, &(topwin->list));

		rtgui_topwin_update_clip();

		/* redraw the old rect */
		rtgui_topwin_redraw(&(topwin->extent));

		if (rtgui_server_focus_topwin == topwin)
		{
			/* activate the next window */
			if (_rtgui_topwin_show_list.next != RT_NULL)
			{
				struct rtgui_event_win wevent;
				struct rtgui_topwin* wnd;

				/* get the topwin */
				wnd = rtgui_list_entry(_rtgui_topwin_show_list.next,
					struct rtgui_topwin, list);

				/* activate the window */
				RTGUI_EVENT_WIN_ACTIVATE_INIT(&wevent);
				wevent.wid = wnd->wid;
				rtgui_thread_send(wnd->tid, &(wevent.parent), sizeof(struct rtgui_event_win));

				/* set new focus topwin */
				rtgui_server_focus_topwin = wnd;
			}
			else
			{
				/* there is no shown window right now */
				rtgui_server_focus_topwin = RT_NULL;
			}
		}

		/* free the monitor rect list, topwin node and title */
		while (topwin->monitor_list.next != RT_NULL)
		{
			struct rtgui_mouse_monitor* monitor = rtgui_list_entry(topwin->monitor_list.next,
				struct rtgui_mouse_monitor, list);

			topwin->monitor_list.next = topwin->monitor_list.next->next;
			rtgui_free(monitor);
		}

		/* destroy win title */
		rtgui_wintitle_destroy(topwin->title);
		topwin->title = RT_NULL;

		rtgui_free(topwin);

		return RT_EOK;
	}

	topwin = rtgui_topwin_search_in_list(wid, &_rtgui_topwin_hide_list);
	if (topwin)
	{
		/* remove node from list */
		rtgui_list_remove(&_rtgui_topwin_hide_list, &(topwin->list));

		/* free the topwin node and title */
		rtgui_wintitle_destroy(topwin->title);
		topwin->title = RT_NULL;

		rtgui_free(topwin);

		return RT_EOK;
	}

	return -RT_ERROR;
}

/* activate a win
 * - deactivate the old focus win
 * - activate a win
 * - set the focus win to activate win
 * - draw win title
 */
void rtgui_topwin_activate_win(struct rtgui_topwin* win)
{
	struct rtgui_event_win event;

	/* activate the raised window */
	RTGUI_EVENT_WIN_ACTIVATE_INIT(&event);
	event.wid = win->wid;
	rtgui_thread_send(win->tid, &(event.parent), sizeof(struct rtgui_event_win));

	/* redraw title */
	if (win->title != RT_NULL)
	{
		win->flag |= WINTITLE_ACTIVATE;
		rtgui_theme_draw_win(win);
	}

	if ((rtgui_server_focus_topwin != RT_NULL) && (rtgui_server_focus_topwin != win))
	{
		/* deactivate the old focus win  */
		RTGUI_EVENT_WIN_DEACTIVATE_INIT(&event);
		event.wid = rtgui_server_focus_topwin->wid;
		rtgui_thread_send(rtgui_server_focus_topwin->tid,
			&event.parent, sizeof(struct rtgui_event_win));

		/* redraw title */
		if (rtgui_server_focus_topwin->title != RT_NULL)
		{
			rtgui_server_focus_topwin->flag &= ~WINTITLE_ACTIVATE;
			rtgui_theme_draw_win(rtgui_server_focus_topwin);
		}
	}

	rtgui_server_focus_topwin = win;
}

/*
 * deactivate a win
 * - deactivate the win
 * - redraw win title
 * - set rtgui_server_focus_topwin
 */
void rtgui_topwin_deactivate_win(struct rtgui_topwin* win)
{
	/* deactivate win */
	struct rtgui_event_win event;
	RTGUI_EVENT_WIN_DEACTIVATE_INIT(&event);
	event.wid = win->wid;
	rtgui_thread_send(win->tid,
		&event.parent, sizeof(struct rtgui_event_win));

	win->flag &= ~WINTITLE_ACTIVATE;
	rtgui_theme_draw_win(win);

	if (rtgui_server_focus_topwin == win)
	{
		rtgui_server_focus_topwin = RT_NULL;
	}
}

/* raise window to front */
void rtgui_topwin_raise(struct rtgui_win* wid, rt_thread_t sender)
{
	struct rtgui_topwin* topwin;
	struct rtgui_list_node* node;
	struct rtgui_event_clip_info eclip;

	RTGUI_EVENT_CLIP_INFO_INIT(&eclip);
	eclip.wid = RT_NULL;

	/* the window is already placed in front */
	if (&(topwin->list) == _rtgui_topwin_show_list.next)
	{
		rtgui_server_focus_topwin = RT_NULL;
		rtgui_topwin_activate_win(topwin);
	    return ;
	}

	// rt_sem_take(&_rtgui_topwin_lock, RT_WAITING_FOREVER);
	/* find the topwin node */
	for (node = _rtgui_topwin_show_list.next; node->next != RT_NULL; node = node->next)
	{
		topwin = rtgui_list_entry(node->next, struct rtgui_topwin, list);
		if (topwin->wid == wid)
		{
			/* found target */

			struct rtgui_list_node* n;
			n = node->next;
			/* remove node */
			node->next = node->next->next;
			/* insert node to the header */
			n->next = _rtgui_topwin_show_list.next;
			_rtgui_topwin_show_list.next = n;

			/* send clip update to each upper window */
			for (n = _rtgui_topwin_show_list.next; n != node->next; n = n->next)
			{
				struct rtgui_topwin* wnd = rtgui_list_entry(n, struct rtgui_topwin, list);
				eclip.wid = wnd->wid;

				/* send to destination window */
				rtgui_thread_send(wnd->tid, &(eclip.parent), sizeof(struct rtgui_event_clip_info));

				/* reset clip info in title */
				if (wnd->title != RT_NULL)
				{
					rtgui_toplevel_update_clip(RTGUI_TOPLEVEL(wnd->title));
					rtgui_region_subtract_rect(&(RTGUI_WIDGET(wnd->title)->clip),
						&(RTGUI_WIDGET(wnd->title)->clip),
						&(wnd->extent));
				}
			}

			/* active window */
			rtgui_topwin_activate_win(topwin);
			break;
		}
	}
	// rt_sem_release(&_rtgui_topwin_lock);
}

/* show a window */
void rtgui_topwin_show(struct rtgui_event_win* event)
{
	struct rtgui_topwin* topwin;
	struct rtgui_win* wid = event->wid;
	rt_thread_t sender = RTGUI_EVENT(event)->sender;

	/* find in hide list */
	topwin = rtgui_topwin_search_in_list(wid, &_rtgui_topwin_hide_list);

	/* find it */
	if (topwin != RT_NULL)
	{
		/* remove node from hidden list */
		rtgui_list_remove(&_rtgui_topwin_hide_list, &(topwin->list));

		/* add node to show list */
		rtgui_list_insert(&_rtgui_topwin_show_list, &(topwin->list));

		/* show window title */
		if (topwin->title != RT_NULL)
		{
			RTGUI_WIDGET_UNHIDE(RTGUI_WIDGET(topwin->title));
		}

		/* update clip info */
		rtgui_topwin_update_clip();

		rtgui_thread_ack(RTGUI_EVENT(event), RTGUI_STATUS_OK);

		/* activate this window */
		rtgui_topwin_activate_win(topwin);
	}
	else
	{
		/* the wnd is located in show list, raise wnd to front */
		topwin = rtgui_topwin_search_in_list(wid, &_rtgui_topwin_show_list);
		if (topwin != RT_NULL)
		{
			if (_rtgui_topwin_show_list.next != &(topwin->list))
			{
				rtgui_thread_ack(RTGUI_EVENT(event), RTGUI_STATUS_OK);

				/* not the front window, raise it */
				rtgui_topwin_raise(wid, sender);
			}
			else
			{
				/* just raise it */
				rtgui_topwin_raise(wid, sender);
			}
		}
		else
		{
			/* there is no wnd in wnd list */
			rtgui_thread_ack(RTGUI_EVENT(event), RTGUI_STATUS_ERROR);
		}
	}
}

/* send clip info to panel */
#ifdef RTGUI_USING_SMALL_SIZE
void rtgui_topwin_update_clip_to_panel(struct rtgui_panel* panel)
{
	rt_uint32_t count;
	rt_thread_t tid;
	struct rtgui_list_node* node;
	struct rtgui_event_clip_info eclip;

	/* get topwin count  */
	count = 0;
	node = _rtgui_topwin_show_list.next;
	while (node != RT_NULL)
	{
		count ++;
		node = node->next;
	}

	/* send clip info event to panel */
	RTGUI_EVENT_CLIP_INFO_INIT(&eclip);
	eclip.num_rect = count; eclip.wid = RT_NULL;

	/* send to the activated thread of panel */
	tid = rtgui_panel_get_active_thread(panel);
	rtgui_thread_send(tid, &eclip.parent, sizeof(struct rtgui_event_clip_info));
}
#else
void rtgui_topwin_update_clip_to_panel(struct rtgui_panel* panel)
{
	rt_uint32_t count;
	rt_thread_t tid;
	struct rtgui_list_node* node;
	struct rtgui_event_clip_info* eclip;

	/* get topwin count  */
	count = 0;
	node = _rtgui_topwin_show_list.next;
	while (node != RT_NULL)
	{
		count ++;
		node = node->next;
	}

	eclip = (struct rtgui_event_clip_info*)rtgui_malloc(sizeof(struct rtgui_event_clip_info)
		+ (count + 1)* sizeof(struct rtgui_rect));
	if (eclip == RT_NULL)
	{
		/* no memory */
		return ;
	}

	/* reset clip info to top window */
	RTGUI_EVENT_CLIP_INFO_INIT(eclip);
	eclip->num_rect = count; eclip->wid = RT_NULL;

	count = 0;
	for (node = _rtgui_topwin_show_list.next; node != RT_NULL; node  = node->next)
	{
		struct rtgui_topwin* wnd;
		struct rtgui_rect* rect;

		wnd = rtgui_list_entry(node, struct rtgui_topwin, list);

		rect = RTGUI_EVENT_GET_RECT(eclip, count++);
		*rect = (wnd->title != RT_NULL)? RTGUI_WIDGET(wnd->title)->extent : wnd->extent;
	}

	/* send to the activated thread of panel */
	tid = rtgui_panel_get_active_thread(panel);
	rtgui_thread_send(tid, (struct rtgui_event*)eclip, sizeof(struct rtgui_event_clip_info)
		+ count* sizeof(struct rtgui_rect));

	/* release clip info event */
	rtgui_free(eclip);
}
#endif

/* hide a window */
void rtgui_topwin_hide(struct rtgui_event_win* event)
{
	struct rtgui_topwin* topwin;
	struct rtgui_win* wid = event->wid;

	/* find in show list */
	topwin = rtgui_topwin_search_in_list(wid, &_rtgui_topwin_show_list);

	/* found it */
	if (topwin)
	{
		/* remove node from show list */
		rtgui_list_remove(&_rtgui_topwin_show_list, &(topwin->list));

		/* add node to hidden list */
		rtgui_list_insert(&_rtgui_topwin_hide_list, &(topwin->list));

		/* show window title */
		if (topwin->title != RT_NULL)
		{
			RTGUI_WIDGET_HIDE(RTGUI_WIDGET(topwin->title));
		}

		/* update clip info */
		rtgui_topwin_update_clip();

		/* redraw the old rect */
		rtgui_topwin_redraw(&(topwin->extent));

		if (rtgui_server_focus_topwin == topwin)
		{
			/* activate the next window */
			if (_rtgui_topwin_show_list.next != RT_NULL)
			{
				/* get the topwin */
				topwin = rtgui_list_entry(_rtgui_topwin_show_list.next,
					struct rtgui_topwin, list);

				rtgui_server_focus_topwin = RT_NULL;
				rtgui_topwin_activate_win(topwin);
			}
			else
			{
				/* there is no shown window right now */
				rtgui_server_focus_topwin = RT_NULL;
			}
		}
	}
	else
	{
		rtgui_thread_ack(RTGUI_EVENT(event), RTGUI_STATUS_ERROR);
		return;
	}

	rtgui_thread_ack(RTGUI_EVENT(event), RTGUI_STATUS_OK);
}

/* move top window */
void rtgui_topwin_move(struct rtgui_event_win_move* event)
{
	struct rtgui_topwin* topwin;

	/* find in show list */
	topwin = rtgui_topwin_search_in_list(event->wid, &_rtgui_topwin_show_list);
	if (topwin != RT_NULL)
	{
		int dx, dy;
		rtgui_rect_t rect; /* the old topwin coverage area */
		struct rtgui_list_node* node;

		/* send status ok */
		rtgui_thread_ack(RTGUI_EVENT(event), RTGUI_STATUS_OK);

		/* get the delta move x, y */
		dx = event->x - topwin->extent.x1;
		dy = event->y - topwin->extent.y1;

		rect = topwin->extent;
		/* move window rect */
		rtgui_rect_moveto(&(topwin->extent), dx, dy);

		/* move window title */
		if (topwin->title != RT_NULL)
		{
			rect = RTGUI_WIDGET(topwin->title)->extent;
			rtgui_widget_move_to_logic(RTGUI_WIDGET(topwin->title), dx, dy);
		}

		/* move the monitor rect list */
		rtgui_list_foreach(node, &(topwin->monitor_list))
		{
			struct rtgui_mouse_monitor* monitor = rtgui_list_entry(node,
				struct rtgui_mouse_monitor,
				list);
			rtgui_rect_moveto(&(monitor->rect), dx, dy);
		}

		/* update windows clip info */
		rtgui_topwin_update_clip();

		/* update top window title */
		if (topwin->title != RT_NULL) rtgui_theme_draw_win(topwin);
		if (rtgui_rect_is_intersect(&rect, &(topwin->extent)) != RT_EOK)
		{
			/*
			 * the old rect is not intersect with moved rect,
			 * re-paint window
			 */
			struct rtgui_event_paint epaint;
			RTGUI_EVENT_PAINT_INIT(&epaint);
			epaint.wid = topwin->wid;
			rtgui_thread_send(topwin->tid, &(epaint.parent), sizeof(epaint));
		}

		/* update old window coverage area */
		rtgui_topwin_redraw(&rect);
	}
	else
	{
		rtgui_thread_ack(RTGUI_EVENT(event), RTGUI_STATUS_ERROR);
	}
}

/*
 * resize a top win
 * Note: currently, only support resize hidden window
 */
void rtgui_topwin_resize(struct rtgui_win* wid, rtgui_rect_t* r)
{
	struct rtgui_topwin* topwin;

	/* find in show list */
	topwin = rtgui_topwin_search_in_list(wid, &_rtgui_topwin_hide_list);
	if (topwin)
	{
		topwin->extent = *r;

		if (topwin->title != RT_NULL)
		{
			/* get win extent */
			rtgui_rect_t rect = topwin->extent;

			/* add border rect */
			if (topwin->flag & WINTITLE_BORDER)
			{
				rtgui_rect_inflate(&rect, WINTITLE_BORDER_SIZE);
			}

			/* add title rect */
			if (!(topwin->flag & WINTITLE_NO)) rect.y1 -= WINTITLE_HEIGHT;

			RTGUI_WIDGET(topwin->title)->extent = rect;

			/* update title & border clip info */
			rtgui_toplevel_update_clip(RTGUI_TOPLEVEL(topwin->title));
			rtgui_region_subtract_rect(&(RTGUI_WIDGET(topwin->title)->clip),
				&(RTGUI_WIDGET(topwin->title)->clip),
				&(topwin->extent));
		}
	}
}

struct rtgui_topwin* rtgui_topwin_get_wnd(int x, int y)
{
	struct rtgui_list_node* node;
	struct rtgui_topwin* topwin;

	/* search in list */
	rtgui_list_foreach(node, &(_rtgui_topwin_show_list))
	{
		topwin = rtgui_list_entry(node, struct rtgui_topwin, list);

		/* is this window? */
		if ((topwin->title != RT_NULL) &&
			rtgui_rect_contains_point(&(RTGUI_WIDGET(topwin->title)->extent), x, y) == RT_EOK)
		{
			return topwin;
		}
		else if (rtgui_rect_contains_point(&(topwin->extent), x, y) == RT_EOK)
		{
			return topwin;
		}
	}

	return RT_NULL;
}

extern struct rtgui_list_node _rtgui_panel_list;
static void rtgui_topwin_update_clip()
{
	rt_int32_t count = 0;
	struct rtgui_event_clip_info eclip;
	struct rtgui_list_node* node = _rtgui_topwin_show_list.next;

	RTGUI_EVENT_CLIP_INFO_INIT(&eclip);

	rtgui_list_foreach(node, &_rtgui_topwin_show_list)
	{
		struct rtgui_topwin* wnd;
		wnd = rtgui_list_entry(node, struct rtgui_topwin, list);

		eclip.num_rect = count;
		eclip.wid = wnd->wid;

		count ++;

		/* send to destination window */
		rtgui_thread_send(wnd->tid, &(eclip.parent), sizeof(struct rtgui_event_clip_info));

		/* update clip in win title */
		if (wnd->title != RT_NULL)
		{
			/* reset clip info */
			rtgui_toplevel_update_clip(RTGUI_TOPLEVEL(wnd->title));
			rtgui_region_subtract_rect(&(RTGUI_WIDGET(wnd->title)->clip),
				&(RTGUI_WIDGET(wnd->title)->clip),
				&(wnd->extent));
		}
	}

	/* send clip info to each panel */
	eclip.wid = RT_NULL;
	eclip.num_rect = count;

	rtgui_list_foreach(node, &(_rtgui_panel_list))
	{
		struct rtgui_panel* panel;
		struct rtgui_list_node* panel_node;

		panel = rtgui_list_entry(node, struct rtgui_panel, sibling);

		rtgui_list_foreach(panel_node, &(panel->thread_list))
		{
			struct rtgui_panel_thread* thread;
			thread = rtgui_list_entry(panel_node, struct rtgui_panel_thread, list);

			/* send clip info to panel */
			rtgui_thread_send(thread->tid, &(eclip.parent),	sizeof(struct rtgui_event_clip_info));
		}
	}
}

static void rtgui_topwin_redraw(struct rtgui_rect* rect)
{
	struct rtgui_list_node* node;
	struct rtgui_event_paint epaint;
	RTGUI_EVENT_PAINT_INIT(&epaint);
	epaint.wid = RT_NULL;

	rtgui_list_foreach(node, &_rtgui_topwin_show_list)
	{
		struct rtgui_topwin* wnd = rtgui_list_entry(node, struct rtgui_topwin, list);

		if (rtgui_rect_is_intersect(rect, &(wnd->extent)) == RT_EOK)
		{
			/* draw window */
			epaint.wid = wnd->wid;
			rtgui_thread_send(wnd->tid, &(epaint.parent), sizeof(epaint));

			/* draw title */
			if (wnd->title != RT_NULL)
			{
				rtgui_theme_draw_win(wnd);
			}
		}
	}

	/* redraw the panel */
	rtgui_list_foreach(node, &(_rtgui_panel_list))
	{
		struct rtgui_panel* panel;
		panel = rtgui_list_entry(node, struct rtgui_panel, sibling);

		if (rtgui_rect_is_intersect(rect, &(panel->extent)) == RT_EOK)
		{
			rt_thread_t tid;

			tid = rtgui_panel_get_active_thread(panel);
			if (tid != RT_NULL)
			{
				/* draw panel */
				epaint.wid = RT_NULL;
				rtgui_thread_send(tid, &(epaint.parent), sizeof(epaint));
			}
		}
	}
}

void rtgui_topwin_title_onmouse(struct rtgui_topwin* win, struct rtgui_event_mouse* event)
{
	rtgui_rect_t rect;

	/* let window to process this mouse event */
	if (rtgui_rect_contains_point(&win->extent, event->x, event->y) == RT_EOK)
	{
		/* send mouse event to thread */
		rtgui_thread_send(win->tid, &(event->parent), sizeof(struct rtgui_event_mouse));
		return;
	}

	/* get close button rect (device value) */
	rect.x1 = RTGUI_WIDGET(win->title)->extent.x2 - WINTITLE_BORDER_SIZE - WINTITLE_CB_WIDTH - 3;
	rect.y1 = RTGUI_WIDGET(win->title)->extent.y1 + WINTITLE_BORDER_SIZE + 3;
	rect.x2 = rect.x1 + WINTITLE_CB_WIDTH;
	rect.y2 = rect.y1 + WINTITLE_CB_HEIGHT;

	if (event->button & RTGUI_MOUSE_BUTTON_LEFT)
	{
		if (event->button & RTGUI_MOUSE_BUTTON_DOWN)
		{
			if (rtgui_rect_contains_point(&rect, event->x, event->y) == RT_EOK)
			{
				win->flag |= WINTITLE_CB_PRESSED;
				rtgui_theme_draw_win(win);
			}
#ifdef RTGUI_USING_WINMOVE
			else
			{
				/* maybe move window */
				rtgui_winrect_set(win);
			}
#endif
		}
		else if (event->button & RTGUI_MOUSE_BUTTON_UP)
		{
			if (rtgui_rect_contains_point(&rect, event->x, event->y) == RT_EOK)
			{
				struct rtgui_event_win event;

				win->flag &= ~WINTITLE_CB_PRESSED;
				rtgui_theme_draw_win(win);

				/* send close event to window */
				RTGUI_EVENT_WIN_CLOSE_INIT(&event);
				event.wid = win->wid;
				rtgui_thread_send(win->tid, &(event.parent), sizeof(struct rtgui_event_win));
			}
		}
	}
}

void rtgui_topwin_append_monitor_rect(struct rtgui_win* wid, rtgui_rect_t* rect)
{
	struct rtgui_topwin* win;

	/* parameters check */
	if (wid == RT_NULL || rect == RT_NULL) return;

	/* find topwin */
	win = rtgui_topwin_search_in_list(wid, &_rtgui_topwin_show_list);
	if (win == RT_NULL)
		win = rtgui_topwin_search_in_list(wid, &_rtgui_topwin_hide_list);

	if (win == RT_NULL) return;

	/* append rect to top window monitor rect list */
	rtgui_mouse_monitor_append(&(win->monitor_list), rect);
}

void rtgui_topwin_remove_monitor_rect(struct rtgui_win* wid, rtgui_rect_t* rect)
{
	struct rtgui_topwin* win;

	/* parameters check */
	if (wid == RT_NULL || rect == RT_NULL) return;

	/* find topwin */
	win = rtgui_topwin_search_in_list(wid, &_rtgui_topwin_show_list);
	if (win == RT_NULL)
		win = rtgui_topwin_search_in_list(wid, &_rtgui_topwin_hide_list);

	if (win == RT_NULL) return;

	/* remove rect from top window monitor rect list */
	rtgui_mouse_monitor_remove(&(win->monitor_list), rect);
}

/**
 * do clip for topwin list
 * widget, the clip widget to be done clip
 */
void rtgui_topwin_do_clip(rtgui_widget_t* widget)
{
	rtgui_widget_t* wid;
	struct rtgui_rect* rect;
	struct rtgui_topwin* topwin;
	struct rtgui_list_node* node;

	/* get toplevel wid */
	wid = widget->toplevel;

	rt_sem_take(&_rtgui_topwin_lock, RT_WAITING_FOREVER);
	/* get all of topwin rect list */
	rtgui_list_foreach(node, &_rtgui_topwin_show_list)
	{
		topwin = rtgui_list_entry(node, struct rtgui_topwin, list);

		if (topwin->wid == (rtgui_win_t*)(wid) ||
			RTGUI_WIDGET(topwin->title) == widget) break; /* it's self window, break */

		/* get extent */
		if (topwin->title != RT_NULL) 
			rect = &(RTGUI_WIDGET(topwin->title)->extent);
		else 
			rect = &(topwin->extent);

		/* subtract the topwin rect */
		rtgui_region_subtract_rect(&(widget->clip), &(widget->clip), rect);
	}
	rt_sem_release(&_rtgui_topwin_lock);
}