add basic files of RTGUI

git-svn-id: https://rt-thread.googlecode.com/svn/trunk@69 bbd45198-f89e-11dd-88c7-29a3b14d5316

20 files changed, 5098 insertions, 0 deletions

diff --git a/rtgui/common/rtgui_object.c b/rtgui/common/rtgui_object.c
new file mode 100644
index 0000000000..a0f0d71fba
--- /dev/null
+++ b/rtgui/common/rtgui_object.c
@@ -0,0 +1,242 @@
+/*
+ * File      : rtgui_object.c
+ * This file is part of RTGUI in 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-04     Bernard      first version
+ */
+
+#include <rtgui/rtgui_object.h>
+#include <rtgui/rtgui_system.h>

+
+static void _rtgui_object_constructor(rtgui_object_t *object)
+{
+   if (!object) return;
+
+   object->is_static = RT_FALSE;
+}
+
+/* Destroys the object */
+static void _rtgui_object_destructor(rtgui_object_t *object)
+{
+	/* nothing */
+}
+
+rtgui_type_t *rtgui_type_create(const char *type_name, rtgui_type_t *parent_type,
+						 int type_size, rtgui_constructor_t constructor,
+						 rtgui_destructor_t destructor)
+{
+	rtgui_type_t *new_type;
+
+	if (!type_name)
+		return RT_NULL;
+
+	new_type = rtgui_malloc(sizeof(rtgui_type_t));
+	new_type->name = rt_strdup(type_name);
+	new_type->size = type_size;
+	new_type->constructor = constructor;
+	new_type->destructor = destructor;
+
+	if (!parent_type)
+	{
+		new_type->hierarchy_depth = 0;
+		new_type->hierarchy = RT_NULL;
+	}
+	else
+	{
+		/* Build the type hierarchy */
+		new_type->hierarchy_depth = parent_type->hierarchy_depth + 1;
+		new_type->hierarchy = rtgui_malloc(sizeof(rtgui_type_t *) * new_type->hierarchy_depth);
+
+		new_type->hierarchy[0] = parent_type;
+		rt_memcpy(new_type->hierarchy + 1, parent_type->hierarchy,
+				  parent_type->hierarchy_depth * sizeof(rtgui_type_t *));
+	}
+
+	return new_type;
+}
+
+void rtgui_type_destroy(rtgui_type_t *type)
+{
+	if (!type) return;
+
+	if (type->hierarchy) rtgui_free(type->hierarchy);
+
+	rtgui_free(type->name);
+	rtgui_free(type);
+}
+
+void rtgui_type_object_construct(rtgui_type_t *type, rtgui_object_t *object)
+{
+	int i;
+
+	if (!type || !object) return;
+
+	/* Call the constructors */
+	for (i = type->hierarchy_depth - 1; i >= 0; i--)
+	{
+		if (type->hierarchy[i]->constructor)
+			type->hierarchy[i]->constructor(object);
+	}
+	if (type->constructor) type->constructor(object);
+}
+
+void rtgui_type_destructors_call(rtgui_type_t *type, rtgui_object_t *object)
+{
+	int i;
+
+	if (!type || !object) return;
+
+	if (type->destructor) type->destructor(object);
+	for (i = 0; i < type->hierarchy_depth; i++)
+	{
+		if (type->hierarchy[i]->destructor)
+			type->hierarchy[i]->destructor(object);
+	}
+}
+
+rt_bool_t rtgui_type_inherits_from(rtgui_type_t *type, rtgui_type_t *parent)
+{
+	int i;
+
+	if (!type || !parent) return RT_FALSE;
+
+	if (type == parent) return RT_TRUE;
+
+	for (i = 0; i < type->hierarchy_depth; i++)
+	{
+		if (type->hierarchy[i] == parent) return RT_TRUE;
+	}
+
+	return RT_FALSE;
+}
+
+rtgui_type_t *rtgui_type_parent_type_get(rtgui_type_t *type)
+{
+	if (!type || !type->hierarchy) return RT_NULL;
+
+	return type->hierarchy[0];
+}
+
+const char *rtgui_type_name_get(rtgui_type_t *type)
+{
+	if (!type) return RT_NULL;
+
+	return type->name;
+}
+
+struct rtgui_object_information
+{
+	rt_uint32_t objs_number;
+	rt_uint32_t allocated_size;
+	rt_uint32_t max_allocated;
+};
+struct rtgui_object_information obj_info = {0, 0, 0};
+
+/**
+ * @brief Creates a new object: it calls the corresponding constructors (from the constructor of the base class to the
+ * constructor of the more derived class) and then sets the values of the given properties
+ * @param object_type the type of object to create
+ * @return Returns the new Etk_Object of type @a object_type
+ */
+rtgui_object_t *rtgui_object_create(rtgui_type_t *object_type)
+{
+	rtgui_object_t *new_object;
+
+	if (!object_type)
+		return RT_NULL;
+
+	new_object = rtgui_malloc(object_type->size);
+	if (new_object == RT_NULL) return RT_NULL;
+
+	obj_info.objs_number ++;
+	obj_info.allocated_size += object_type->size;
+	if (obj_info.allocated_size > obj_info.max_allocated)
+		obj_info.max_allocated = obj_info.allocated_size;
+
+	new_object->type = object_type;
+	new_object->is_static = RT_FALSE;
+
+	rtgui_type_object_construct(object_type, new_object);
+
+	return new_object;
+}
+
+/**
+ * @brief Destroys the object: it first sets the weak-pointers to RT_NULL, emits the "destroyed" signal, and then
+ * queues the object in the list of objects to free. Thus, the destructors will only be called at the beginning of the
+ * next main loop iteration (from the destructor of the more derived class to the destructor of the ultimate base class).
+ * @param object the object to destroy
+ * @warning You should not assume that this function will call directly the destructors of the object!
+ */
+void rtgui_object_destroy(rtgui_object_t *object)
+{
+	if (!object || object->is_static == RT_TRUE) return;
+
+	obj_info.objs_number --;
+	obj_info.allocated_size -= object->type->size;
+
+	/* call destructor */
+	RT_ASSERT(object->type != RT_NULL);
+	rtgui_type_destructors_call(object->type, object);
+
+	/* release object */
+	rtgui_free(object);
+}
+
+/**
+ * @internal
+ * @brief Gets the type of a rtgui_object
+ * @return Returns the type of a rtgui_object
+ */
+rtgui_type_t *rtgui_object_type_get(void)
+{
+	static rtgui_type_t *object_type = RT_NULL;
+
+	if (!object_type)
+	{
+		object_type = rtgui_type_create("object", RT_NULL,
+			sizeof(rtgui_object_t), RTGUI_CONSTRUCTOR(_rtgui_object_constructor),
+			RTGUI_DESTRUCTOR(_rtgui_object_destructor));
+	}
+
+	return object_type;
+}
+
+/**
+ * @brief Checks if @a object can be cast to @a type.
+ * If @a object doesn't inherit from @a type, a warning is displayed in the console but the object is returned anyway.
+ * @param object the object to cast
+ * @param type the type to which we cast the object
+ * @return Returns the object
+ * @note You usually do not need to call this function, use specific macros instead (ETK_IS_WIDGET() for example)
+ */
+rtgui_object_t *rtgui_object_check_cast(rtgui_object_t *object, rtgui_type_t *type)
+{
+	if (!object) return RT_NULL;
+
+	if (!rtgui_type_inherits_from(object->type, type))
+	{
+		rt_kprintf("Invalid cast from \"%s\" to \"%s\"\n", rtgui_type_name_get(object->type), rtgui_type_name_get(type));
+	}
+
+	return object;
+}
+
+/**
+ * @brief Gets the type of the object
+ * @param object an object
+ * @return Returns the type of @a object (RT_NULL on failure)
+ */
+rtgui_type_t *rtgui_object_object_type_get(rtgui_object_t *object)
+{
+	if (!object) return RT_NULL;
+
+	return object->type;
+}
diff --git a/rtgui/common/rtgui_system.c b/rtgui/common/rtgui_system.c
new file mode 100644
index 0000000000..f1bbf2bd37
--- /dev/null
+++ b/rtgui/common/rtgui_system.c
@@ -0,0 +1,667 @@
+/*
+ * File      : rtgui_system.c
+ * This file is part of RTGUI in 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-04     Bernard      first version
+ */
+
+#include <rtgui/rtgui.h>
+#include <rtgui/driver.h>
+#include <rtgui/image.h>
+#include <rtgui/rtgui_system.h>
+#include <rtgui/rtgui_server.h>
+#include <rtgui/widgets/window.h>
+
+#ifdef __WIN32__
+#define RTGUI_EVENT_DEBUG
+#define RTGUI_MEM_TRACE
+#endif
+
+void rtgui_system_server_init()
+{
+	/* init rtgui_thread */
+	rtgui_thread_system_init();
+
+	/* init image */
+	rtgui_system_image_init();
+	/* init font */
+	rtgui_font_system_init();
+
+	/* init rtgui server */
+	rtgui_panel_init();
+	rtgui_topwin_init();
+	rtgui_server_init();
+}
+
+void rtgui_system_app_init()
+{
+	/* init launcher thread */
+	rtgui_launcher_init();
+
+	/* init pyim */
+	// rtgui_pyim_init();
+
+	/* init term win */
+	// rtgui_term_init();
+}
+
+/************************************************************************/
+/* RTGUI Thread Wrapper                                                 */
+/************************************************************************/
+#ifdef RTGUI_EVENT_DEBUG
+const char *event_string[] =
+{
+	/* panel event */
+	"PANEL_ATTACH",			/* attach to a panel	*/
+	"PANEL_DETACH",			/* detach from a panel	*/
+	"PANEL_SHOW",			/* show in a panel		*/
+	"PANEL_HIDE",			/* hide from a panel	*/
+	"PANEL_INFO",			/* panel information 	*/
+	"PANEL_RESIZE",			/* resize panel 		*/
+	"PANEL_FULLSCREEN",		/* to full screen 		*/
+	"PANEL_NORMAL",			/* to normal screen 	*/
+
+	/* window event */
+	"WIN_CREATE",			/* create a window 	*/
+	"WIN_DESTROY",			/* destroy a window 	*/
+	"WIN_SHOW",				/* show a window 		*/
+	"WIN_HIDE",				/* hide a window 		*/
+	"WIN_ACTIVATE", 		/* activate a window 	*/
+	"WIN_DEACTIVATE",		/* deactivate a window 	*/
+	"WIN_CLOSE",			/* close a window 		*/
+	"WIN_MOVE",				/* move a window 		*/
+	"WIN_RESIZE", 			/* resize a window 		*/
+
+	"SET_WM", 				/* set window manager	*/
+
+	"UPDATE_BEGIN",			/* begin of update rect */
+	"UPDATE_END",			/* end of update rect	*/
+	"MONITOR_ADD",			/* add a monitor rect 	*/
+	"MONITOR_REMOVE", 		/* remove a monitor rect*/
+	"PAINT",				/* paint on screen 		*/
+	"TIMER",				/* timer 				*/
+
+	/* clip rect information */
+	"CLIP_INFO",			/* clip rect info		*/
+
+	/* mouse and keyboard event */
+	"MOUSE_MOTION",			/* mouse motion */
+	"MOUSE_BUTTON",			/* mouse button info 	*/
+	"KBD",					/* keyboard info		*/
+
+	/* user command event */
+	"COMMAND",				/* user command 		*/
+
+	/* request's status event */
+	"STATUS",				/* request result 		*/
+	"SCROLLED",           	/* scroll bar scrolled  */
+	"RESIZE",				/* widget resize 		*/
+};
+
+#define DBG_MSG(x)	rt_kprintf x
+
+static void rtgui_event_dump(rt_thread_t tid, rtgui_event_t* event)
+{
+	char* sender = "(unknown)";
+
+	if (event->sender != RT_NULL) sender = event->sender->name;
+
+	if (event->type == RTGUI_EVENT_TIMER)
+	{
+		/* don't dump timer event */
+		return ;
+	}
+
+	rt_kprintf("%s -- %s --> %s ", sender, event_string[event->type], tid->name);
+	switch (event->type)
+	{
+	case RTGUI_EVENT_PAINT:
+		{
+			struct rtgui_event_paint *paint = (struct rtgui_event_paint *)event;
+
+			if(paint->wid != RT_NULL)
+				rt_kprintf("win: %s", paint->wid->title);
+		}
+		break;
+
+	case RTGUI_EVENT_CLIP_INFO:
+		{
+			struct rtgui_event_clip_info *info = (struct rtgui_event_clip_info *)event;
+
+			if(info->wid != RT_NULL)
+				rt_kprintf("win: %s", info->wid->title);
+		}
+		break;
+
+	case RTGUI_EVENT_WIN_CREATE:
+		{
+			struct rtgui_event_win_create *create = (struct rtgui_event_win_create*)event;
+
+			rt_kprintf(" win: %s at (x1:%d, y1:%d, x2:%d, y2:%d)",
+				create->title,
+				create->extent.x1,
+				create->extent.y1,
+				create->extent.x2,
+				create->extent.y2);
+		}
+		break;
+
+	case RTGUI_EVENT_UPDATE_END:
+		{
+			struct rtgui_event_update_end* update_end = (struct rtgui_event_update_end*)event;
+			rt_kprintf("(x:%d, y1:%d, x2:%d, y2:%d)", update_end->rect.x1,
+				update_end->rect.y1,
+				update_end->rect.x2,
+				update_end->rect.y2);
+		}
+		break;
+
+	case RTGUI_EVENT_WIN_ACTIVATE:
+	case RTGUI_EVENT_WIN_DEACTIVATE:
+	case RTGUI_EVENT_WIN_SHOW:
+		{
+			struct rtgui_event_win *win = (struct rtgui_event_win *)event;
+
+			if(win->wid != RT_NULL)
+				rt_kprintf("win: %s", win->wid->title);
+		}
+		break;
+
+	case RTGUI_EVENT_WIN_MOVE:
+		{
+			struct rtgui_event_win_move *win = (struct rtgui_event_win_move *)event;
+
+			if(win->wid != RT_NULL)
+				rt_kprintf("win: %s", win->wid->title);
+		}
+		break;
+
+	case RTGUI_EVENT_WIN_RESIZE:
+		{
+			struct rtgui_event_win_resize* win = (struct rtgui_event_win_resize *)event;
+
+			if (win->wid != RT_NULL)
+			{
+				rt_kprintf("win: %s, rect(x1:%d, y1:%d, x2:%d, y2:%d)", win->wid->title,
+					RTGUI_WIDGET(win->wid)->extent.x1,
+					RTGUI_WIDGET(win->wid)->extent.y1,
+					RTGUI_WIDGET(win->wid)->extent.x2,
+					RTGUI_WIDGET(win->wid)->extent.y2);
+			}
+		}
+		break;
+
+	case RTGUI_EVENT_MOUSE_BUTTON:
+	case RTGUI_EVENT_MOUSE_MOTION:
+		{
+			struct rtgui_event_mouse *mouse = (struct rtgui_event_mouse*)event;
+
+			if (mouse->button & RTGUI_MOUSE_BUTTON_LEFT) rt_kprintf("left ");
+			else rt_kprintf("right ");
+
+			if (mouse->button & RTGUI_MOUSE_BUTTON_DOWN) rt_kprintf("down ");
+			else rt_kprintf("up ");
+
+			if (mouse->wid != RT_NULL)
+				rt_kprintf("win: %s at (%d, %d)", mouse->wid->title,
+				mouse->x, mouse->y);
+			else
+				rt_kprintf("(%d, %d)", mouse->x, mouse->y);
+		}
+		break;
+
+	case RTGUI_EVENT_MONITOR_ADD:
+		{
+			struct rtgui_event_monitor *monitor = (struct rtgui_event_monitor*)event;
+			if (monitor->panel != RT_NULL)
+			{
+#if 0
+				rt_kprintf("panel: %s, the rect is:(%d, %d) - (%d, %d)", monitor->panel->name,
+					monitor->rect.x1, monitor->rect.y1,
+					monitor->rect.x2, monitor->rect.y2);
+#endif
+				rt_kprintf("the rect is:(%d, %d) - (%d, %d)",
+					monitor->rect.x1, monitor->rect.y1,
+					monitor->rect.x2, monitor->rect.y2);
+			}
+			else if (monitor->wid != RT_NULL)
+			{
+				rt_kprintf("win: %s, the rect is:(%d, %d) - (%d, %d)", monitor->wid->title,
+					monitor->rect.x1, monitor->rect.y1,
+					monitor->rect.x2, monitor->rect.y2);
+			}
+		}
+		break;
+	}
+
+	rt_kprintf("\n");
+}
+#else
+#define DBG_MSG(x)
+#define rtgui_event_dump(tid, event)
+#endif
+
+struct rt_semaphore _rtgui_thread_hash_semaphore;
+
+void rtgui_thread_system_init()
+{
+	rt_sem_init(&_rtgui_thread_hash_semaphore, "rtgui", 1, RT_IPC_FLAG_FIFO);
+}
+
+rtgui_thread_t* rtgui_thread_register(rt_thread_t tid, rt_mq_t mq)
+{
+	rtgui_thread_t* thread = rtgui_malloc(sizeof(struct rtgui_thread));
+
+	if (thread != RT_NULL)
+	{
+		DBG_MSG(("register a rtgui thread: %s, tid: 0x%p\n", tid->name, tid));
+
+		/* set tid and mq */
+		thread->tid			= tid;
+		thread->mq			= mq;
+		thread->widget		= RT_NULL;
+
+		/* take semaphore */
+		rt_sem_take(&_rtgui_thread_hash_semaphore, RT_WAITING_FOREVER);
+		/* set user thread */
+		tid->user_data = (rt_uint32_t)thread;
+		/* release semaphore */
+		rt_sem_release(&_rtgui_thread_hash_semaphore);
+	}
+
+	return thread;
+}
+
+void rtgui_thread_deregister(rt_thread_t tid)
+{
+	struct rtgui_thread* thread;
+
+	/* find rtgui_thread */
+	thread = (struct rtgui_thread*) (tid->user_data);
+
+	if (thread != RT_NULL)
+	{
+		/* take semaphore */
+		rt_sem_take(&_rtgui_thread_hash_semaphore, RT_WAITING_FOREVER);
+		/* remove rtgui_thread */
+		tid->user_data = 0;
+		/* release semaphore */
+		rt_sem_release(&_rtgui_thread_hash_semaphore);
+
+		/* free rtgui_thread */
+		rtgui_free(thread);
+	}
+}
+
+extern rt_thread_t rt_thread_find(char* name);
+rt_thread_t rtgui_thread_get_server()
+{
+	return rt_thread_find("rtgui");
+}
+
+void rtgui_thread_set_widget(struct rtgui_widget* widget)
+{
+	struct rtgui_thread* thread;
+
+	/* get rtgui_thread */
+	thread = (struct rtgui_thread*) (rt_thread_self()->user_data);
+
+	if (thread != RT_NULL) thread->widget = widget;
+}
+
+struct rtgui_widget* rtgui_thread_get_widget()
+{
+	struct rtgui_thread* thread;
+
+	/* get rtgui_thread */
+	thread = (struct rtgui_thread*) (rt_thread_self()->user_data);
+
+	return thread == RT_NULL? RT_NULL : thread->widget;
+}
+
+rt_err_t rtgui_thread_send(rt_thread_t tid, rtgui_event_t* event, rt_size_t event_size)
+{
+	struct rtgui_thread* thread;
+
+	rtgui_event_dump(tid, event);
+
+	/* find rtgui_thread */
+	thread = (struct rtgui_thread*) (tid->user_data);
+	if (thread == RT_NULL) return -RT_ERROR;
+
+	return rt_mq_send(thread->mq, event, event_size);
+}
+
+rt_err_t rtgui_thread_send_urgent(rt_thread_t tid, rtgui_event_t* event, rt_size_t event_size)
+{
+	struct rtgui_thread* thread;
+
+	rtgui_event_dump(tid, event);
+
+	/* find rtgui_thread */
+	thread = (struct rtgui_thread*) (tid->user_data);
+	if (thread == RT_NULL) return -RT_ERROR;
+
+	return rt_mq_urgent(thread->mq, event, event_size);
+}
+
+rt_err_t rtgui_thread_send_sync(rt_thread_t tid, rtgui_event_t* event, rt_size_t event_size)
+{
+	rt_err_t r;
+	struct rtgui_thread* thread;
+	rt_int32_t ack_buffer, ack_status;
+	struct rt_mailbox ack_mb;
+
+	rtgui_event_dump(tid, event);
+
+	/* init ack mailbox */
+	r = rt_mb_init(&ack_mb, "ack", &ack_buffer, 1, 0);
+	if ( r!= RT_EOK) goto __return;
+
+	/* find rtgui_thread */
+	thread = (struct rtgui_thread*) (tid->user_data);
+	if (thread == RT_NULL){ r = RT_ERROR; goto __return; }
+
+	event->ack = &ack_mb;
+	r = rt_mq_send(thread->mq, event, event_size);
+	if (r != RT_EOK) goto __return;
+
+	r = rt_mb_recv(&ack_mb, (rt_uint32_t*)&ack_status, RT_WAITING_FOREVER);
+	if ( r!= RT_EOK) goto __return;
+
+	if (ack_status != RTGUI_STATUS_OK) r = -RT_ERROR;
+	else r = RT_EOK;
+
+	/* fini ack mailbox */
+	rt_mb_detach(&ack_mb);
+
+__return:
+	return r;
+}
+
+rt_err_t rtgui_thread_ack(rtgui_event_t* event, rt_int32_t status)
+{
+	if (event != RT_NULL &&
+		event->ack != RT_NULL)
+	{
+		rt_mb_send(event->ack, status);
+	}
+
+	return RT_EOK;
+}
+
+rt_err_t rtgui_thread_recv(rtgui_event_t* event, rt_size_t event_size)
+{
+	struct rtgui_thread* thread;
+	rt_err_t r;
+
+	/* find rtgui_thread */
+	thread = (struct rtgui_thread*) (rt_thread_self()->user_data);
+	if (thread == RT_NULL) return -RT_ERROR;
+
+	r = rt_mq_recv(thread->mq, event, event_size, RT_WAITING_FOREVER);
+
+	return r;
+}
+
+rt_err_t rtgui_thread_recv_filter(rt_uint32_t type, rtgui_event_t* event, rt_size_t event_size)
+{
+	struct rtgui_thread* thread;
+
+	/* find rtgui_thread */
+	thread = (struct rtgui_thread*) (rt_thread_self()->user_data);
+	if (thread == RT_NULL) return -RT_ERROR;
+
+	while (rt_mq_recv(thread->mq, event, event_size, RT_WAITING_FOREVER) == RT_EOK)
+	{
+		if (event->type == type)
+		{
+			return RT_EOK;
+		}
+		else
+		{
+			/* let widget to handle event */
+			if (thread->widget != RT_NULL &&
+				thread->widget->event_handler != RT_NULL)
+			{
+				thread->widget->event_handler(thread->widget, event);
+			}
+		}
+	}
+
+	return -RT_ERROR;
+}
+
+/************************************************************************/
+/* RTGUI Timer                                                          */
+/************************************************************************/
+static void rtgui_time_out(void* parameter)
+{
+	rtgui_timer_t* timer;
+	struct rtgui_event_timer event;
+	timer = (rtgui_timer_t*)parameter;
+
+	/*
+	* Note: event_timer can not use RTGUI_EVENT_TIMER_INIT to init, for there is no
+	* thread context
+	*/
+	event.parent.type = RTGUI_EVENT_TIMER;
+	event.parent.sender = RT_NULL;
+
+	event.callback = timer->timeout;
+	event.parameter = timer->user_data;
+
+	rtgui_thread_send(timer->tid, &(event.parent), sizeof(struct rtgui_event_timer));
+}
+
+rtgui_timer_t* rtgui_timer_create(rt_int32_t time, rt_base_t flag, rtgui_timeout_func timeout, void* parameter)
+{
+	rtgui_timer_t* timer;
+
+	timer = (rtgui_timer_t*) rtgui_malloc(sizeof(struct rtgui_timer));
+	timer->tid = rt_thread_self();
+	timer->timeout = timeout;
+	timer->user_data = parameter;
+
+	/* init rt-thread timer */
+	rt_timer_init(&(timer->timer), "rtgui", rtgui_time_out, timer, time, (rt_uint8_t)flag);
+
+	return timer;
+}
+
+void rtgui_timer_destory(rtgui_timer_t* timer)
+{
+	RT_ASSERT(timer != RT_NULL);
+
+	/* stop timer firstly */
+	rtgui_timer_stop(timer);
+
+	/* detach rt-thread timer */
+	rt_timer_detach(&(timer->timer));
+
+	rtgui_free(timer);
+}
+
+void rtgui_timer_start(rtgui_timer_t* timer)
+{
+	RT_ASSERT(timer != RT_NULL);
+
+	/* start rt-thread timer */
+	rt_timer_start(&(timer->timer));
+}
+
+void rtgui_timer_stop (rtgui_timer_t* timer)
+{
+	RT_ASSERT(timer != RT_NULL);
+
+	/* stop rt-thread timer */
+	rt_timer_stop(&(timer->timer));
+}
+
+/************************************************************************/
+/* RTGUI Memory Management                                              */
+/************************************************************************/
+#ifdef RTGUI_MEM_TRACE
+struct rtgui_mem_info
+{
+	rt_uint32_t allocated_size;
+	rt_uint32_t max_allocated;
+};
+struct rtgui_mem_info mem_info;
+
+#define MEMTRACE_MAX		4096
+#define MEMTRACE_HASH_SIZE	256
+
+struct rti_memtrace_item
+{
+	void*		mb_ptr;		/* memory block pointer */
+	rt_uint32_t mb_len;		/* memory block length */
+
+	struct rti_memtrace_item* next;
+};
+struct rti_memtrace_item trace_list[MEMTRACE_MAX];
+struct rti_memtrace_item *item_hash[MEMTRACE_HASH_SIZE];
+struct rti_memtrace_item *item_free;
+
+rt_bool_t rti_memtrace_inited = 0;
+void rti_memtrace_init()
+{
+	struct rti_memtrace_item *item;
+	rt_uint32_t index;
+
+	rt_memset(trace_list, 0, sizeof(trace_list));
+	rt_memset(item_hash, 0, sizeof(item_hash));
+
+	item_free = &trace_list[0];
+	item = &trace_list[0];
+
+	for (index = 1; index < MEMTRACE_HASH_SIZE; index ++)
+	{
+		item->next = &trace_list[index];
+		item = item->next;
+	}
+
+	item->next = RT_NULL;
+}
+
+void rti_malloc_hook(void* ptr, rt_uint32_t len)
+{
+	rt_uint32_t index;
+	struct rti_memtrace_item* item;
+
+	if (item_free == RT_NULL) return;
+
+	mem_info.allocated_size += len;
+	if (mem_info.max_allocated < mem_info.allocated_size)
+		mem_info.max_allocated = mem_info.allocated_size;
+
+	/* lock context */
+	item = item_free;
+	item_free = item->next;
+
+	item->mb_ptr = ptr;
+	item->mb_len = len;
+	item->next   = RT_NULL;
+
+	/* get hash item index */
+	index = ((rt_uint32_t)ptr) % MEMTRACE_HASH_SIZE;
+	if (item_hash[index] != RT_NULL)
+	{
+		/* add to list */
+		item->next = item_hash[index];
+		item_hash[index] = item;
+	}
+	else
+	{
+		/* set list header */
+		item_hash[index] = item;
+	}
+	/* unlock context */
+}
+
+void rti_free_hook(void* ptr)
+{
+	rt_uint32_t index;
+	struct rti_memtrace_item *item;
+
+	/* get hash item index */
+	index = ((rt_uint32_t)ptr) % MEMTRACE_HASH_SIZE;
+	if (item_hash[index] != RT_NULL)
+	{
+		item = item_hash[index];
+		if (item->mb_ptr == ptr)
+		{
+			/* delete item from list */
+			item_hash[index] = item->next;
+		}
+		else
+		{
+			/* find ptr in list */
+			while (item->next != RT_NULL && item->next->mb_ptr != ptr)
+				item = item->next;
+
+			/* delete item from list */
+			if (item->next != RT_NULL)
+			{
+				struct rti_memtrace_item* i;
+
+				i = item->next;
+				item->next = item->next->next;
+
+				item = i;
+			}
+			else
+			{
+				/* not found */
+				return;
+			}
+		}
+
+		/* reduce allocated size */
+		mem_info.allocated_size -= item->mb_len;
+
+		/* clear item */
+		rt_memset(item, 0, sizeof(struct rti_memtrace_item));
+
+		/* add item to the free list */
+		item->next = item_free;
+		item_free = item;
+	}
+}
+#endif
+
+void* rtgui_malloc(rt_size_t size)
+{
+	void* ptr;
+
+	ptr = rt_malloc(size);
+#ifdef RTGUI_MEM_TRACE
+	if (rti_memtrace_inited == 0)
+	{
+		rti_memtrace_init();
+		rti_memtrace_inited = 1;
+	}
+
+	if (ptr != RT_NULL)
+		rti_malloc_hook(ptr, size);
+#endif
+
+	return ptr;
+}
+
+void rtgui_free(void* ptr)
+{
+#ifdef RTGUI_MEM_TRACE
+	if (ptr != RT_NULL)
+		rti_free_hook(ptr);
+#endif
+
+	rt_free(ptr);
+}
diff --git a/rtgui/common/rtgui_theme.c b/rtgui/common/rtgui_theme.c
new file mode 100644
index 0000000000..7a875ae222
--- /dev/null
+++ b/rtgui/common/rtgui_theme.c
@@ -0,0 +1,439 @@
+/*

+ * File      : rtgui_theme.c

+ * This file is part of RTGUI in 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-04     Bernard      first version

+ */

+

+#include <rtgui/rtgui.h>

+#include <rtgui/dc.h>

+#include <rtgui/widgets/widget.h>

+#include <rtgui/widgets/button.h>

+#include <rtgui/widgets/label.h>

+#include <rtgui/widgets/textbox.h>

+#include <rtgui/widgets/iconbox.h>

+#include <rtgui/rtgui_theme.h>

+#include <rtgui/rtgui_server.h>

+

+#define WINTITLE_CB_WIDTH		14

+#define WINTITLE_CB_HEIGHT		14

+

+static const char * close_unpressed_xpm[] = {

+	"14 14 55 1",

+	" 	c None",

+	".	c #DCDFEA",

+	"+	c #A4ADD3",

+	"@	c #8F9ACA",

+	"#	c #98A2CD",

+	"$	c #D2D6E6",

+	"%	c #F7F7F7",

+	"&	c #F6F6F6",

+	"*	c #B9C1D0",

+	"=	c #7A8AAA",

+	"-	c #D6DAE2",

+	";	c #D8DCE3",

+	">	c #7485A5",

+	",	c #455C89",

+	"'	c #516690",

+	")	c #D3D8E0",

+	"!	c #536891",

+	"~	c #6D7FA1",

+	"{	c #F5F5F5",

+	"]	c #D1D6DF",

+	"^	c #D2D7DF",

+	"/	c #D5D9E1",

+	"(	c #4E648E",

+	"_	c #CFD4DE",

+	":	c #F4F4F4",

+	"<	c #D0D5DE",

+	"[	c #CED3DD",

+	"}	c #F3F3F3",

+	"|	c #CFD4DD",

+	"1	c #CDD2DC",

+	"2	c #F2F2F2",

+	"3	c #D3D7DF",

+	"4	c #526790",

+	"5	c #D0D5DD",

+	"6	c #F1F1F1",

+	"7	c #D2D6DE",

+	"8	c #CFD4DC",

+	"9	c #F0F0F0",

+	"0	c #D1D5DD",

+	"a	c #C9CED8",

+	"b	c #CDD2DB",

+	"c	c #50658F",

+	"d	c #CED3DB",

+	"e	c #7283A3",

+	"f	c #6E80A2",

+	"g	c #EFEFEF",

+	"h	c #B2BACA",

+	"i	c #7081A2",

+	"j	c #C8CDD7",

+	"k	c #CCD1DA",

+	"l	c #ACB5C7",

+	"m	c #D0D4E2",

+	"n	c #EEEEEE",

+	"o	c #D2D5E3",

+	"p	c #97A1CC",

+	".+@@@@@@@@@@+.",

+	"#$%%%%%%%%%%$#",

+	"@&*=-&&&&;=*&@",

+	"@&>,')&&-!,~&@",

+	"@{]','^/!,(_{@",

+	"@::<','!,([::@",

+	"@}}}|',,(1}}}@",

+	"@22234,,'5222@",

+	"@6674,(','866@",

+	"@904,(abc,cd9@",

+	"@9e,(a99bc,f9@",

+	"@ghijggggkelg@",

+	"#mnnnnnnnnnnm#",

+	"op@@@@@@@@@@po"};

+

+static const char * close_pressed_xpm[] = {

+	"14 14 66 1",

+	" 	c None",

+	".	c #CED4EE",

+	"+	c #7E90DD",

+	"@	c #6076D7",

+	"#	c #6C80D9",

+	"$	c #BFC8EA",

+	"%	c #F2F3F5",

+	"&	c #F0F2F3",

+	"*	c #A5B6D7",

+	"=	c #587ABB",

+	"-	c #C9D3E4",

+	";	c #CBD5E4",

+	">	c #EEF0F2",

+	",	c #5073B7",

+	"'	c #1746A3",

+	")	c #2551A8",

+	"!	c #C5CFE2",

+	"~	c #C8D1E3",

+	"{	c #2853A8",

+	"]	c #496DB4",

+	"^	c #ECEEF1",

+	"/	c #C0CCE0",

+	"(	c #C3CEE1",

+	"_	c #C6D0E2",

+	":	c #224FA7",

+	"<	c #BEC9DF",

+	"[	c #EAECF0",

+	"}	c #BFCAE0",

+	"|	c #2551A7",

+	"1	c #224EA7",

+	"2	c #BCC8DF",

+	"3	c #E8EBEE",

+	"4	c #BDCADE",

+	"5	c #BAC7DD",

+	"6	c #E6E9ED",

+	"7	c #C1CBDF",

+	"8	c #2753A8",

+	"9	c #BECADE",

+	"0	c #E4E7EB",

+	"a	c #BFCADD",

+	"b	c #224EA6",

+	"c	c #BDC8DC",

+	"d	c #E1E5EA",

+	"e	c #2752A8",

+	"f	c #B3C0D9",

+	"g	c #B8C5DB",

+	"h	c #2451A7",

+	"i	c #BAC6DB",

+	"j	c #DFE2E8",

+	"k	c #4C70B4",

+	"l	c #B2BED8",

+	"m	c #B6C2D9",

+	"n	c #2450A7",

+	"o	c #486BB3",

+	"p	c #DCE0E7",

+	"q	c #96A8CE",

+	"r	c #496CB3",

+	"s	c #AFBCD7",

+	"t	c #B4C1D8",

+	"u	c #4B6FB4",

+	"v	c #8EA4CC",

+	"w	c #6C80D8",

+	"x	c #B4BEDF",

+	"y	c #DADEE5",

+	"z	c #B5BEDE",

+	"A	c #6A7ED7",

+	".+@@@@@@@@@@+.",

+	"#$%%%%%%%%%%$#",

+	"@&*=-&&&&;=*&@",

+	"@>,')!>>~{']>@",

+	"@^/)')(_{':<^@",

+	"@[[}|'|{'12[[@",

+	"@3334|''15333@",

+	"@66678''|9666@",

+	"@00a8'b|'|c00@",

+	"@dce'bfgh'hid@",

+	"@jk'bljjmn'oj@",

+	"@pqrspppptuvp@",

+	"wxyyyyyyyyyyxw",

+	"zA@@@@@@@@@@Az"};

+

+static rtgui_image_t* close_pressed = RT_NULL;

+static rtgui_image_t* close_unpressed = RT_NULL;

+

+/* window drawing */

+void rtgui_theme_draw_win(struct rtgui_topwin* win)

+{

+	struct rtgui_dc* dc;

+	rtgui_rect_t rect;

+

+	/* init close box image */

+	if (close_pressed == RT_NULL)

+		close_pressed = rtgui_image_create_from_mem("xpm", close_pressed_xpm, sizeof(close_pressed_xpm));

+	if (close_unpressed == RT_NULL)

+		close_unpressed = rtgui_image_create_from_mem("xpm", close_unpressed_xpm, sizeof(close_unpressed_xpm));

+

+	/* begin drawing */

+	dc = rtgui_dc_begin_drawing(RTGUI_WIDGET(win->title));

+

+	/* get rect */

+	rtgui_widget_get_rect(RTGUI_WIDGET(win->title), &rect);

+

+	/* draw border */

+	if (win->flag & WINTITLE_BORDER)

+	{

+		RTGUI_WIDGET_FOREGROUND(RTGUI_WIDGET(win->title)) = RTGUI_RGB(219, 210, 243);

+		rtgui_dc_draw_rect(dc, &rect);

+

+		/* shrink border */

+		rect.x1 += WINTITLE_BORDER_SIZE;

+		rect.y1 += WINTITLE_BORDER_SIZE;

+		rect.x2 -= WINTITLE_BORDER_SIZE;

+		rect.y2 -= WINTITLE_BORDER_SIZE;

+	}

+

+	/* draw title */

+	if (!(win->flag & WINTITLE_NO))

+	{

+		if (win->flag & WINTITLE_ACTIVATE)

+		{

+			RTGUI_WIDGET_BACKGROUND(RTGUI_WIDGET(win->title)) = RTGUI_RGB(229, 236, 249);

+			RTGUI_WIDGET_FOREGROUND(RTGUI_WIDGET(win->title)) = RTGUI_RGB( 51, 102, 204);

+		}

+		else

+		{

+			RTGUI_WIDGET_BACKGROUND(RTGUI_WIDGET(win->title)) = RTGUI_RGB(242, 245, 252);

+			RTGUI_WIDGET_FOREGROUND(RTGUI_WIDGET(win->title)) = RTGUI_RGB(153, 178, 229);

+		}

+		rtgui_dc_fill_rect(dc, &rect);

+

+		rect.x1 += 4;

+		rect.y1 += 2;

+		rtgui_dc_draw_text(dc, rtgui_wintitle_get_title(win->title), &rect);

+

+		if (win->flag & WINTITLE_CLOSEBOX)

+		{

+			/* get close button rect */

+			rect.x1 = rtgui_rect_width(RTGUI_WIDGET(win->title)->extent) -

+				WINTITLE_BORDER_SIZE - WINTITLE_CB_WIDTH - 3;

+			rect.y1 = 3;

+			rect.x2 = rect.x1 + WINTITLE_CB_WIDTH;

+			rect.y2 = rect.y1 + WINTITLE_CB_HEIGHT;

+

+			/* draw close box */

+			if(win->flag & WINTITLE_CB_PRESSED) rtgui_image_blit(close_pressed, dc, &rect);

+			else rtgui_image_blit(close_unpressed, dc, &rect);

+		}

+	}

+

+	rtgui_dc_end_drawing(dc);

+}

+

+/* widget drawing */

+void rtgui_theme_draw_button(rtgui_button_t* btn)

+{

+	/* draw button */

+	struct rtgui_dc* dc;

+	struct rtgui_rect rect;

+

+	/* begin drawing */

+	dc = rtgui_dc_begin_drawing(RTGUI_WIDGET(btn));

+	if (dc == RT_NULL) return;

+

+	rtgui_widget_get_rect(RTGUI_WIDGET(btn), &rect);

+

+	/* fill button rect with background color */

+	// RTGUI_WIDGET_BACKGROUND(RTGUI_WIDGET(btn)) = RTGUI_RGB(212, 208, 200);

+	rtgui_dc_fill_rect(dc, &rect);

+

+	if (btn->flag & RTGUI_BUTTON_TYPE_PUSH && btn->flag & RTGUI_BUTTON_FLAG_PRESS)

+	{

+		/* draw border */

+		RTGUI_WIDGET_FOREGROUND(RTGUI_WIDGET(btn)) = RTGUI_RGB(64, 64, 64);

+		rtgui_dc_draw_hline(dc, rect.x1, rect.x2, rect.y1);

+		rtgui_dc_draw_vline(dc, rect.x1, rect.y1, rect.y2);

+

+		RTGUI_WIDGET_FOREGROUND(RTGUI_WIDGET(btn)) = RTGUI_RGB(128, 128, 128);

+		rtgui_dc_draw_hline(dc, rect.x1, rect.x2 - 1, rect.y1 + 1);

+		rtgui_dc_draw_vline(dc, rect.x1 + 1, rect.y1 + 1, rect.y2 - 2);

+

+		RTGUI_WIDGET_FOREGROUND(RTGUI_WIDGET(btn)) = RTGUI_RGB(255, 255, 255);

+		rtgui_dc_draw_hline(dc, rect.x1, rect.x2 + 1, rect.y2 - 1);

+		rtgui_dc_draw_vline(dc, rect.x2 - 1, rect.y1, rect.y2);

+

+		if (btn->pressed_image != RT_NULL)

+		{

+			rtgui_rect_t image_rect = {0, 0, btn->unpressed_image->w, btn->unpressed_image->h};

+			rtgui_rect_moveto_align(&rect, &image_rect, RTGUI_ALIGN_CENTER_HORIZONTAL | RTGUI_ALIGN_CENTER_VERTICAL);

+

+			rtgui_image_blit(btn->pressed_image, dc, &image_rect);

+		}

+	}

+	else if (btn->flag & RTGUI_BUTTON_FLAG_PRESS)

+	{

+		if (btn->pressed_image != RT_NULL)

+		{

+			rtgui_rect_t image_rect = {0, 0, btn->unpressed_image->w, btn->unpressed_image->h};

+			rtgui_rect_moveto_align(&rect, &image_rect, RTGUI_ALIGN_CENTER_HORIZONTAL | RTGUI_ALIGN_CENTER_VERTICAL);

+

+			rtgui_image_blit(btn->pressed_image, dc, &image_rect);

+		}

+		else

+		{

+			/* draw border */

+			RTGUI_WIDGET(btn)->gc.foreground = RTGUI_RGB(0, 0, 0);

+			rtgui_dc_draw_rect(dc, &rect);

+

+			RTGUI_WIDGET(btn)->gc.foreground = RTGUI_RGB(128, 128, 128);

+			rect.x1 += 1; rect.y1 += 1; rect.x2 -= 1; rect.y2 -= 1;

+			rtgui_dc_draw_rect(dc, &rect);

+		}

+	}

+	else

+	{

+		if (btn->unpressed_image != RT_NULL)

+		{

+			rtgui_rect_t image_rect = {0, 0, btn->unpressed_image->w, btn->unpressed_image->h};

+			rtgui_rect_moveto_align(&rect, &image_rect, RTGUI_ALIGN_CENTER_HORIZONTAL | RTGUI_ALIGN_CENTER_VERTICAL);

+

+			rtgui_image_blit(btn->unpressed_image, dc, &image_rect);

+		}

+		else

+		{

+			/* draw border */

+			RTGUI_WIDGET(btn)->gc.foreground = RTGUI_RGB(255, 255, 255);

+			rtgui_dc_draw_hline(dc, rect.x1, rect.x2, rect.y1);

+			rtgui_dc_draw_vline(dc, rect.x1, rect.y1, rect.y2);

+

+			RTGUI_WIDGET(btn)->gc.foreground = RTGUI_RGB(0, 0, 0);

+			rtgui_dc_draw_hline(dc, rect.x1, rect.x2 + 1, rect.y2);

+			rtgui_dc_draw_vline(dc, rect.x2, rect.y1, rect.y2);

+

+			RTGUI_WIDGET(btn)->gc.foreground = RTGUI_RGB(128, 128, 128);

+			rtgui_dc_draw_hline(dc, rect.x1 + 1, rect.x2, rect.y2 - 1);

+			rtgui_dc_draw_vline(dc, rect.x2 - 1, rect.y1 + 1, rect.y2 - 1);

+		}

+	}

+

+	if (btn->pressed_image == RT_NULL)

+	{

+		/* re-set foreground and get default rect */

+		RTGUI_WIDGET(btn)->gc.foreground = RTGUI_RGB(0, 0, 0);

+		rtgui_widget_get_rect(RTGUI_WIDGET(btn), &rect);

+

+		/* remove border */

+		rtgui_rect_inflate(&rect, -2);

+

+		/* draw text */

+		rtgui_dc_draw_text(dc, rtgui_label_get_text(RTGUI_LABEL(btn)), &rect);

+	}

+

+	/* end drawing */

+	rtgui_dc_end_drawing(dc);

+}

+

+void rtgui_theme_draw_label(rtgui_label_t* label)

+{

+	/* draw label */

+	struct rtgui_dc* dc;

+	struct rtgui_rect rect;

+

+	/* begin drawing */

+	dc = rtgui_dc_begin_drawing(RTGUI_WIDGET(label));

+	if (dc == RT_NULL) return;

+

+	rtgui_widget_get_rect(RTGUI_WIDGET(label), &rect);

+	rtgui_dc_fill_rect(dc, &rect);

+

+	/* default left and center draw */

+	rect.y1 = rect.y1 + (rtgui_rect_height(rect) - 8)/2;

+	rtgui_dc_draw_text(dc, rtgui_label_get_text(label), &rect);

+

+	/* end drawing */

+	rtgui_dc_end_drawing(dc);

+}

+

+#define RTGUI_TEXTBOX_MARGIN	3

+void rtgui_theme_draw_textbox(rtgui_textbox_t* box)

+{

+	/* draw button */

+	struct rtgui_dc* dc;

+	struct rtgui_rect rect;

+

+	/* begin drawing */

+	dc = rtgui_dc_begin_drawing(RTGUI_WIDGET(box));

+	if (dc == RT_NULL) return;

+

+	/* get widget rect */

+	rtgui_widget_get_rect(RTGUI_WIDGET(box), &rect);

+

+	/* fill widget rect with background color */

+	rtgui_dc_fill_rect(dc, &rect);

+

+	/* draw border */

+	rtgui_dc_draw_border(dc, &rect, RTGUI_BORDER_STATIC);

+

+	/* draw text */

+	if (box->text != RT_NULL)

+	{

+		rect.x1 += RTGUI_TEXTBOX_MARGIN;

+

+		rtgui_dc_draw_text(dc, box->text, &rect);

+	}

+

+	/* end drawing */

+	rtgui_dc_end_drawing(dc);

+}

+

+void rtgui_theme_draw_iconbox(rtgui_iconbox_t* iconbox)

+{

+	struct rtgui_dc* dc;

+	struct rtgui_rect rect;

+

+	/* begin drawing */

+	dc = rtgui_dc_begin_drawing(RTGUI_WIDGET(iconbox));

+	if (dc == RT_NULL) return;

+

+	/* get widget rect */

+	rtgui_widget_get_rect(RTGUI_WIDGET(iconbox), &rect);

+

+	/* draw icon */

+	rtgui_image_blit(iconbox->image, dc, &rect);

+

+	/* draw text */

+	if (iconbox->text_position == RTGUI_ICONBOX_TEXT_BELOW && iconbox->text != RT_NULL)

+	{

+		rect.y1 = iconbox->image->h + RTGUI_WIDGET_DEFAULT_MARGIN;

+		rtgui_dc_draw_text(dc, iconbox->text, &rect);

+	}

+	else if (iconbox->text_position == RTGUI_ICONBOX_TEXT_RIGHT && iconbox->text != RT_NULL)

+	{

+		rect.x1 = iconbox->image->w + RTGUI_WIDGET_DEFAULT_MARGIN;

+		rtgui_dc_draw_text(dc, iconbox->text, &rect);

+	}

+

+	/* end drawing */

+	rtgui_dc_end_drawing(dc);

+}

diff --git a/rtgui/include/rtgui/driver.h b/rtgui/include/rtgui/driver.h
new file mode 100644
index 0000000000..859a51b79b
--- /dev/null
+++ b/rtgui/include/rtgui/driver.h
@@ -0,0 +1,58 @@
+/*

+ * File      : driver.h

+ * This file is part of RTGUI in 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-04     Bernard      first version

+ */

+#ifndef __RTGUI_DRIVER_H__

+#define __RTGUI_DRIVER_H__

+

+#include <rtgui/list.h>

+#include <rtgui/color.h>

+

+struct rtgui_graphic_driver

+{

+	/* driver name */

+	char* name;

+

+	/* byte per pixel */

+	rt_uint16_t byte_per_pixel;

+

+	/* screen width and height */

+	rt_uint16_t width;

+	rt_uint16_t height;

+

+	/* screen update */

+	void (*screen_update)(rtgui_rect_t* rect);

+

+	/* get video frame buffer */

+	rt_uint8_t* (*get_framebuffer)(void);

+

+	/* set and get pixel in (x, y) */

+	void (*set_pixel) (rtgui_color_t *c, rt_base_t x, rt_base_t y);

+	void (*get_pixel) (rtgui_color_t *c, rt_base_t x, rt_base_t y);

+

+	void (*draw_hline)(rtgui_color_t *c, rt_base_t x1, rt_base_t x2, rt_base_t y);

+	void (*draw_vline)(rtgui_color_t *c, rt_base_t x , rt_base_t y1, rt_base_t y2);

+

+	/* the driver list */

+	rtgui_list_t list;

+};

+

+void rtgui_graphic_driver_add(struct rtgui_graphic_driver* driver);

+void rtgui_graphic_driver_remove(struct rtgui_graphic_driver* driver);

+

+struct rtgui_graphic_driver* rtgui_graphic_driver_find(char* name);

+struct rtgui_graphic_driver* rtgui_graphic_driver_get_default(void);

+

+void rtgui_graphic_driver_get_rect(struct rtgui_graphic_driver *driver, rtgui_rect_t *rect);

+void rtgui_graphic_driver_get_default_rect(rtgui_rect_t *rect);

+

+#endif

diff --git a/rtgui/include/rtgui/event.h b/rtgui/include/rtgui/event.h
new file mode 100644
index 0000000000..5a94107ee9
--- /dev/null
+++ b/rtgui/include/rtgui/event.h
@@ -0,0 +1,425 @@
+/*

+ * File      : event.h

+ * This file is part of RTGUI in 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-04     Bernard      first version

+ */

+#ifndef __RTGUI_EVENT_H__

+#define __RTGUI_EVENT_H__

+

+#include <rtgui/rtgui.h>

+#include <rtgui/kbddef.h>

+

+enum _rtgui_event_type

+{

+	/* panel event */

+	RTGUI_EVENT_PANEL_ATTACH = 0,	/* attach to a panel	*/

+	RTGUI_EVENT_PANEL_DETACH,		/* detach from a panel	*/

+	RTGUI_EVENT_PANEL_SHOW,			/* show in a panel		*/

+	RTGUI_EVENT_PANEL_HIDE,			/* hide from a panel	*/

+	RTGUI_EVENT_PANEL_INFO,			/* panel information 	*/

+	RTGUI_EVENT_PANEL_RESIZE,		/* resize panel 		*/

+	RTGUI_EVENT_PANEL_FULLSCREEN,	/* to full screen 		*/

+	RTGUI_EVENT_PANEL_NORMAL,		/* to normal screen 	*/

+

+	/* window event */

+	RTGUI_EVENT_WIN_CREATE,			/* create a window 		*/

+	RTGUI_EVENT_WIN_DESTROY,		/* destroy a window 	*/

+	RTGUI_EVENT_WIN_SHOW,			/* show a window 		*/

+	RTGUI_EVENT_WIN_HIDE,			/* hide a window 		*/

+	RTGUI_EVENT_WIN_ACTIVATE, 		/* activate a window 	*/

+	RTGUI_EVENT_WIN_DEACTIVATE,		/* deactivate a window 	*/

+	RTGUI_EVENT_WIN_CLOSE,			/* close a window 		*/

+	RTGUI_EVENT_WIN_MOVE,			/* move a window 		*/

+	RTGUI_EVENT_WIN_RESIZE, 		/* resize a window 		*/

+

+	/* WM event */

+	RTGUI_EVENT_SET_WM,				/* set window manager   */

+

+	RTGUI_EVENT_UPDATE_BEGIN,		/* update a rect 		*/

+	RTGUI_EVENT_UPDATE_END,			/* update a rect 		*/

+	RTGUI_EVENT_MONITOR_ADD,		/* add a monitor rect 	*/

+	RTGUI_EVENT_MONITOR_REMOVE,		/* remove a monitor rect*/

+	RTGUI_EVENT_PAINT,				/* paint on screen 		*/

+	RTGUI_EVENT_TIMER,				/* timer 				*/

+

+	/* clip rect information */

+	RTGUI_EVENT_CLIP_INFO,			/* clip rect info		*/

+

+	/* mouse and keyboard event */

+	RTGUI_EVENT_MOUSE_MOTION,		/* mouse motion */

+	RTGUI_EVENT_MOUSE_BUTTON,		/* mouse button info 	*/

+	RTGUI_EVENT_KBD,				/* keyboard info		*/

+

+	/* user command event */

+	RTGUI_EVENT_COMMAND,			/* user command 		*/

+

+	/* widget event */

+	RTGUI_EVENT_FOCUSED,			/* widget focused       */

+	RTGUI_EVENT_SCROLLED,           /* scroll bar scrolled  */

+	RTGUI_EVENT_RESIZE,				/* widget resize 		*/

+};

+typedef enum _rtgui_event_type rtgui_event_type;

+

+enum {

+	RTGUI_STATUS_OK = 0,		/* status ok 		*/

+	RTGUI_STATUS_ERROR,			/* generic error 	*/

+	RTGUI_STATUS_NRC,			/* no resource 		*/

+};

+

+struct rtgui_event

+{

+	/* the event type */

+	rt_uint32_t type;

+

+	/* the event sender */

+	rt_thread_t sender;

+

+	/* mailbox to acknowledge request */

+	rt_mailbox_t ack;

+};

+typedef struct rtgui_event rtgui_event_t;

+#define RTGUI_EVENT(e)	((struct rtgui_event*)(e))

+

+#define RTGUI_EVENT_INIT(e, t)	do		\

+{										\

+	(e)->type = (t);					\

+	(e)->sender = rt_thread_self();		\

+	(e)->ack = RT_NULL;					\

+} while (0)

+

+/*

+ * RTGUI Panel Event

+ */

+struct rtgui_event_panel_attach

+{

+	struct rtgui_event parent;

+

+	/* the panel name to be attached */

+	char panel_name[RTGUI_NAME_MAX];

+

+	/* workbench, wm field */

+	rtgui_workbench_t* workbench;

+};

+

+struct rtgui_event_panel_detach

+{

+	struct rtgui_event parent;

+

+	/* the panel which thread belong to */

+	rtgui_panel_t* panel;

+

+	/* workbench, wm field */

+	rtgui_workbench_t* workbench;

+};

+

+struct rtgui_event_panel_show

+{

+	struct rtgui_event parent;

+

+	/* the panel which thread belong to */

+	rtgui_panel_t* panel;

+

+	/* workbench, wm field */

+	rtgui_workbench_t* workbench;

+};

+

+struct rtgui_event_panel_hide

+{

+	struct rtgui_event parent;

+

+	/* the panel which thread belong to */

+	rtgui_panel_t* panel;

+

+	/* workbench, wm field */

+	rtgui_workbench_t* workbench;

+};

+

+struct rtgui_event_panel_info

+{

+	struct rtgui_event parent;

+

+	/* panel info */

+	rtgui_panel_t* panel;

+	rtgui_rect_t extent;

+};

+

+#define RTGUI_EVENT_PANEL_ATTACH_INIT(e)	RTGUI_EVENT_INIT(&((e)->parent), RTGUI_EVENT_PANEL_ATTACH)

+#define RTGUI_EVENT_PANEL_DETACH_INIT(e)	RTGUI_EVENT_INIT(&((e)->parent), RTGUI_EVENT_PANEL_DETACH)

+#define RTGUI_EVENT_PANEL_SHOW_INIT(e)		RTGUI_EVENT_INIT(&((e)->parent), RTGUI_EVENT_PANEL_SHOW)

+#define RTGUI_EVENT_PANEL_HIDE_INIT(e)		RTGUI_EVENT_INIT(&((e)->parent), RTGUI_EVENT_PANEL_HIDE)

+#define RTGUI_EVENT_PANEL_INFO_INIT(e)		RTGUI_EVENT_INIT(&((e)->parent), RTGUI_EVENT_PANEL_INFO)

+

+/*

+ * RTGUI Window Event

+ */

+struct rtgui_event_win

+{

+	struct rtgui_event parent;

+

+	/* the window id */

+	rtgui_win_t* wid;

+};

+

+struct rtgui_event_win_create

+{

+	struct rtgui_event parent;

+

+	/* the window event mask */

+	rt_uint32_t mask;

+

+	/* the window flag */

+	rt_uint32_t flag;

+

+	/* the window title */

+	rt_uint8_t title[RTGUI_NAME_MAX];

+

+	/* the window id */

+	rtgui_win_t* wid;

+	/* the window extent */

+	struct rtgui_rect extent;

+};

+

+struct rtgui_event_win_move

+{

+	struct rtgui_event parent;

+

+	/* the window id */

+	rtgui_win_t* wid;

+

+	rt_int16_t x, y;

+};

+

+struct rtgui_event_win_resize

+{

+	struct rtgui_event parent;

+

+	/* the window id */

+	rtgui_win_t* wid;

+

+	rtgui_rect_t rect;

+};

+

+#define	rtgui_event_win_destroy 	rtgui_event_win

+#define	rtgui_event_win_show 		rtgui_event_win

+#define	rtgui_event_win_hide 		rtgui_event_win

+#define	rtgui_event_win_activate	rtgui_event_win

+#define rtgui_event_win_deactivate 	rtgui_event_win

+#define rtgui_event_win_close 		rtgui_event_win

+
+/* window event init */

+#define RTGUI_EVENT_WIN_CREATE_INIT(e)		RTGUI_EVENT_INIT(&((e)->parent), RTGUI_EVENT_WIN_CREATE)

+#define RTGUI_EVENT_WIN_DESTROY_INIT(e)		RTGUI_EVENT_INIT(&((e)->parent), RTGUI_EVENT_WIN_DESTROY)

+#define RTGUI_EVENT_WIN_SHOW_INIT(e)		RTGUI_EVENT_INIT(&((e)->parent), RTGUI_EVENT_WIN_SHOW)

+#define RTGUI_EVENT_WIN_HIDE_INIT(e)		RTGUI_EVENT_INIT(&((e)->parent), RTGUI_EVENT_WIN_HIDE)

+#define RTGUI_EVENT_WIN_ACTIVATE_INIT(e)	RTGUI_EVENT_INIT(&((e)->parent), RTGUI_EVENT_WIN_ACTIVATE)

+#define RTGUI_EVENT_WIN_DEACTIVATE_INIT(e)	RTGUI_EVENT_INIT(&((e)->parent), RTGUI_EVENT_WIN_DEACTIVATE)

+#define RTGUI_EVENT_WIN_CLOSE_INIT(e)		RTGUI_EVENT_INIT(&((e)->parent), RTGUI_EVENT_WIN_CLOSE)

+#define RTGUI_EVENT_WIN_MOVE_INIT(e)		RTGUI_EVENT_INIT(&((e)->parent), RTGUI_EVENT_WIN_MOVE)

+#define RTGUI_EVENT_WIN_RESIZE_INIT(e)		RTGUI_EVENT_INIT(&((e)->parent), RTGUI_EVENT_WIN_RESIZE)

+

+/*

+ * RTGUI Workbench Manager Event

+ */

+struct rtgui_event_set_wm

+{

+	struct rtgui_event parent;

+

+	/* the panel name to be managed */

+	char panel_name[RTGUI_NAME_MAX];

+};

+/* window event init */

+#define RTGUI_EVENT_SET_WM_INIT(e)		RTGUI_EVENT_INIT(&((e)->parent), RTGUI_EVENT_SET_WM)

+

+/*

+ * RTGUI Other Event

+ */

+struct rtgui_event_update_begin

+{

+	struct rtgui_event parent;

+

+	/* the update rect */

+	rtgui_rect_t rect;

+};

+

+struct rtgui_event_update_end

+{

+	struct rtgui_event parent;

+

+	/* the update rect */

+	rtgui_rect_t rect;

+};

+

+struct rtgui_event_monitor

+{

+	struct rtgui_event parent;

+

+	/* the monitor rect */

+	rtgui_rect_t rect;

+

+	/* under panel */

+	rtgui_panel_t* panel;

+

+	/* or under window */

+	rtgui_win_t* wid;

+};

+

+struct rtgui_event_paint

+{

+	struct rtgui_event parent;

+

+	rtgui_win_t* wid;		/* destination window */

+};

+

+struct rtgui_timer;

+struct rtgui_event_timer

+{

+	struct rtgui_event parent;

+

+	void (*callback)(struct rtgui_timer* timer, void* parameter);

+	void *parameter;

+};

+

+struct rtgui_event_clip_info

+{

+	struct rtgui_event parent;

+

+	/* destination window */

+	rtgui_win_t* wid;

+

+	/* the number of rects */

+	rt_uint32_t num_rect;

+

+	struct rtgui_rect rects[0];

+};

+#define RTGUI_EVENT_GET_RECT(e, i)		(&(e->rects[0]) + i)

+

+#define RTGUI_EVENT_UPDATE_BEGIN_INIT(e)	RTGUI_EVENT_INIT(&((e)->parent), RTGUI_EVENT_UPDATE_BEGIN)

+#define RTGUI_EVENT_UPDATE_END_INIT(e)		RTGUI_EVENT_INIT(&((e)->parent), RTGUI_EVENT_UPDATE_END)

+#define RTGUI_EVENT_MONITOR_ADD_INIT(e)		RTGUI_EVENT_INIT(&((e)->parent), RTGUI_EVENT_MONITOR_ADD)

+#define RTGUI_EVENT_MONITOR_REMOVE_INIT(e)	RTGUI_EVENT_INIT(&((e)->parent), RTGUI_EVENT_MONITOR_REMOVE)

+#define RTGUI_EVENT_CLIP_INFO_INIT(e)		RTGUI_EVENT_INIT(&((e)->parent), RTGUI_EVENT_CLIP_INFO)

+#define RTGUI_EVENT_PAINT_INIT(e)			RTGUI_EVENT_INIT(&((e)->parent), RTGUI_EVENT_PAINT)

+#define RTGUI_EVENT_TIMER_INIT(e)			RTGUI_EVENT_INIT(&((e)->parent), RTGUI_EVENT_TIMER)

+

+/*

+ * RTGUI Mouse and Keyboard Event

+ */

+struct rtgui_event_mouse

+{

+	struct rtgui_event parent;

+

+	rtgui_win_t* wid;		/* destination window */

+

+	rt_uint16_t x, y;

+	rt_uint16_t button;

+};

+#define RTGUI_MOUSE_BUTTON_LEFT			0x01

+#define RTGUI_MOUSE_BUTTON_RIGHT		0x02

+#define RTGUI_MOUSE_BUTTON_MIDDLE		0x03

+#define RTGUI_MOUSE_BUTTON_WHEELUP		0x04

+#define RTGUI_MOUSE_BUTTON_WHEELDOWN	0x08

+

+#define RTGUI_MOUSE_BUTTON_DOWN			0x10

+#define RTGUI_MOUSE_BUTTON_UP			0x20

+

+struct rtgui_event_kbd

+{

+	struct rtgui_event parent;

+

+	rtgui_win_t* wid;		/* destination window */

+

+	RTGUI_KBD_TYPE type;	/* key down or up */

+	RTGUI_KBD_KEY key;		/* current key */

+	RTGUI_KBD_MOD mod;		/* current key modifiers */

+	rt_uint16_t unicode;	/* translated character */

+};

+#define RTGUI_KBD_IS_SET_CTRL(e)	((e)->mod & (RTGUI_KMOD_LCTRL | RTGUI_KMOD_RCTRL)))

+#define RTGUI_KBD_IS_SET_ALT(e)		((e)->mod & (RTGUI_KMOD_LALT  | RTGUI_KMOD_RALT))

+#define RTGUI_KBD_IS_SET_SHIFT(e)	((e)->mod & (RTGUI_KMOD_LSHIFT| RTGUI_KMOD_RSHIFT))

+#define RTGUI_KBD_IS_UP(e)			((e)->type == RTGUI_KEYUP)

+#define RTGUI_KBD_IS_DOWN(e)		((e)->flag == RTGUI_KEYDOWN)

+

+#define RTGUI_EVENT_MOUSE_MOTION_INIT(e)	RTGUI_EVENT_INIT(&((e)->parent), RTGUI_EVENT_MOUSE_MOTION)

+#define RTGUI_EVENT_MOUSE_BUTTON_INIT(e)	RTGUI_EVENT_INIT(&((e)->parent), RTGUI_EVENT_MOUSE_BUTTON)

+#define RTGUI_EVENT_KBD_INIT(e)				RTGUI_EVENT_INIT(&((e)->parent), RTGUI_EVENT_KBD)

+

+struct rtgui_event_command

+{

+	struct rtgui_event parent;

+

+	/* command type */

+	rt_int32_t type;

+

+	/* command id */

+	rt_int32_t command_id;

+

+	/* command integer */

+	rt_int32_t command_int;

+

+	/* command string */

+	char command_string[RTGUI_NAME_MAX];

+};

+#define RTGUI_EVENT_COMMAND_INIT(e)	RTGUI_EVENT_INIT(&((e)->parent), RTGUI_EVENT_COMMAND)

+

+#define RTGUI_CMD_UNKNOWN		0x00

+#define RTGUI_CMD_WM_CLOSE		0x10

+

+#define RTGUI_CMD_USER_INT		0x20

+#define RTGUI_CMD_USER_STRING	0x21

+

+/************************************************************************/

+/* Widget Event                                                         */

+/************************************************************************/

+#define RTGUI_WIDGET_EVENT_INIT(e, t)	do		\

+{										\

+	(e)->type = (t);					\

+	(e)->sender = RT_NULL;				\

+	(e)->ack = RT_NULL;					\

+} while (0)

+

+/*

+ * RTGUI Scrollbar Event

+ */

+struct rtgui_event_scrollbar

+{

+    struct rtgui_event parent;

+

+    rt_uint8_t event;

+};

+#define RTGUI_SCROLL_LINEUP             0x01

+#define RTGUI_SCROLL_LINEDOWN           0x02

+#define RTGUI_SCROLL_PAGEUP             0x03

+#define RTGUI_SCROLL_PAGEDOWN           0x04

+#define RTGUI_EVENT_SCROLLED_INIT(e)	RTGUI_EVENT_INIT(&((e)->parent), RTGUI_EVENT_SCROLLED)

+

+/*

+ * RTGUI Widget Focused Event

+ */

+struct rtgui_event_focused

+{

+    struct rtgui_event parent;

+

+	struct rtgui_widget* widget;

+};

+#define RTGUI_EVENT_FOCUSED_INIT(e)		RTGUI_EVENT_INIT(&((e)->parent), RTGUI_EVENT_FOCUSED)

+

+/*

+ * RTGUI Widget Resize Event

+ */

+struct rtgui_event_resize

+{

+	struct rtgui_event parent;

+	rt_int16_t x, y;

+	rt_int16_t w, h;

+};

+#define RTGUI_EVENT_RESIZE_INIT(e) RTGUI_EVENT_INIT(&((e)->parent), RTGUI_EVENT_RESIZE)

+
+#endif

diff --git a/rtgui/include/rtgui/rtgui.h b/rtgui/include/rtgui/rtgui.h
new file mode 100644
index 0000000000..bc820b76c0
--- /dev/null
+++ b/rtgui/include/rtgui/rtgui.h
@@ -0,0 +1,103 @@
+/*
+ * File      : rtgui.h
+ * This file is part of RTGUI in 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-04     Bernard      first version
+ */
+#ifndef __RT_GUI_H__
+#define __RT_GUI_H__
+
+#include <rtthread.h>
+
+/* RTGUI options */
+#define RTGUI_IMAGE_JPEG
+
+#define RTGUI_NAME_MAX		32
+
+#define RT_INT16_MAX		32767
+#define RT_INT16_MIN		(-RT_INT16_MAX-1)
+
+struct rtgui_panel;
+struct rtgui_event;
+
+struct rtgui_widget;
+struct rtgui_win;
+
+typedef struct rtgui_panel rtgui_panel_t;
+typedef struct rtgui_win rtgui_win_t;

+typedef struct rtgui_workbench rtgui_workbench_t;
+typedef rt_bool_t (*rtgui_event_handler_ptr)(struct rtgui_widget* widget, struct rtgui_event* event);
+
+struct rtgui_point
+{
+	rt_int16_t x, y;
+};
+typedef struct rtgui_point rtgui_point_t;
+
+struct rtgui_rect
+{
+	rt_int16_t x1, y1, x2, y2;
+};
+typedef struct rtgui_rect rtgui_rect_t;
+#define rtgui_rect_width(r)		((r).x2 - (r).x1)
+#define rtgui_rect_height(r)	((r).y2 - (r).y1)
+
+enum RTGUI_MARGIN_STYLE
+{
+	RTGUI_MARGIN_LEFT	= 0x01,
+	RTGUI_MARGIN_RIGHT	= 0x02,
+	RTGUI_MARGIN_TOP	= 0x04,
+	RTGUI_MARGIN_BOTTOM = 0x08,
+	RTGUI_MARGIN_ALL = RTGUI_MARGIN_LEFT | RTGUI_MARGIN_RIGHT | RTGUI_MARGIN_TOP | RTGUI_MARGIN_BOTTOM
+};
+enum RTGUI_BORDER_STYLE
+{
+	RTGUI_BORDER_NONE = 0,
+	RTGUI_BORDER_SIMPLE,
+	RTGUI_BORDER_RAISE,
+	RTGUI_BORDER_SUNKEN,
+	RTGUI_BORDER_BOX,
+	RTGUI_BORDER_STATIC,
+	RTGUI_BORDER_EXTRA
+};
+#define RTGUI_BORDER_DEFAULT_WIDTH	2
+#define RTGUI_WIDGET_DEFAULT_MARGIN	3
+
+enum RTGUI_ORIENTATION
+{
+    RTGUI_HORIZONTAL		= 0x01,
+	RTGUI_VERTICAL			= 0x02,
+	RTGUI_ORIENTATION_BOTH	= RTGUI_HORIZONTAL | RTGUI_VERTICAL
+};
+
+enum RTGUI_ALIGN
+{
+	RTGUI_ALIGN_NOT					= 0x00,
+	RTGUI_ALIGN_CENTER_HORIZONTAL	= 0x01,
+	RTGUI_ALIGN_LEFT				= RTGUI_ALIGN_NOT,
+	RTGUI_ALIGN_TOP					= RTGUI_ALIGN_NOT,
+	RTGUI_ALIGN_RIGHT				= 0x02,
+	RTGUI_ALIGN_BOTTOM				= 0x04,
+	RTGUI_ALIGN_CENTER_VERTICAL		= 0x08,
+	RTGUI_ALIGN_EXPAND				= 0x10,
+	RTGUI_ALIGN_STRETCH				= 0x20
+};
+
+enum RTGUI_ARRAW
+{
+	RTGUI_ARRAW_UP = 0,
+	RTGUI_ARRAW_DOWN,
+	RTGUI_ARRAW_LEFT,
+	RTGUI_ARRAW_RIGHT
+};
+
+#include <rtgui/rtgui_object.h>
+
+#endif
diff --git a/rtgui/include/rtgui/rtgui_object.h b/rtgui/include/rtgui/rtgui_object.h
new file mode 100644
index 0000000000..9c06137701
--- /dev/null
+++ b/rtgui/include/rtgui/rtgui_object.h
@@ -0,0 +1,109 @@
+/*

+ * File      : rtgui_object.h

+ * This file is part of RTGUI in 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-04     Bernard      first version

+ */

+#ifndef __RTGUI_OBJECT_H__

+#define __RTGUI_OBJECT_H__

+

+

+#include <rtthread.h>

+

+#ifdef __cplusplus

+extern "C" {

+#endif

+

+/* rtgui object type */

+

+/** Casts the function pointer to an rtgui_constructor */

+#define RTGUI_CONSTRUCTOR(constructor)                ((rtgui_constructor_t)(constructor))

+/** Casts the function pointer to an rtgui_constructor */

+#define RTGUI_DESTRUCTOR(destructor)                  ((rtgui_destructor_t)(destructor))

+

+/* pre-definetion */

+struct rtgui_object;

+typedef struct rtgui_object rtgui_object_t;

+typedef void (*rtgui_constructor_t)(rtgui_object_t *object);

+typedef void (*rtgui_destructor_t)(rtgui_object_t *object);

+

+/* rtgui type structure */

+struct rtgui_type

+{

+	/* type name */

+	char* name;

+

+	/* hierarchy and depth */

+	struct rtgui_type **hierarchy;

+	int hierarchy_depth;

+

+	/* constructor and destructor */

+	rtgui_constructor_t constructor;

+	rtgui_destructor_t destructor;

+

+	/* size of type */

+	int size;

+};

+typedef struct rtgui_type rtgui_type_t;

+

+rtgui_type_t	*rtgui_type_create(const char *type_name, rtgui_type_t *parent_type,

+                           int type_size, rtgui_constructor_t constructor,

+                           rtgui_destructor_t destructor);

+void          rtgui_type_destroy(rtgui_type_t *type);

+

+void          rtgui_type_object_construct(rtgui_type_t *type, rtgui_object_t *object);

+void          rtgui_type_destructors_call(rtgui_type_t *type, rtgui_object_t *object);

+rt_bool_t     rtgui_type_inherits_from(rtgui_type_t *type, rtgui_type_t *parent);

+rtgui_type_t  *rtgui_type_parent_type_get(rtgui_type_t *type);

+const char	  *rtgui_type_name_get(rtgui_type_t *type);

+rtgui_type_t  *rtgui_type_get_from_name(const char *name);

+

+#ifdef RTGUI_USING_CAST_CHECK

+	#define RTGUI_OBJECT_CAST(obj, rtgui_type_t, c_type) \

+		((c_type *)rtgui_object_check_cast((rtgui_object_t *)(obj), (rtgui_type_t)))

+#else

+	#define RTGUI_OBJECT_CAST(obj, rtgui_type_t, c_type)     ((c_type *)(obj))

+#endif

+

+#define RTGUI_OBJECT_CHECK_TYPE(_obj, _type) \

+	(rtgui_type_inherits_from(((rtgui_object_t *)(_obj))->type, (_type)))

+

+/** Gets the type of an object */

+#define RTGUI_OBJECT_TYPE       (rtgui_object_type_get())

+/** Casts the object to an rtgui_object_t */

+#define RTGUI_OBJECT(obj)       (RTGUI_OBJECT_CAST((obj), RTGUI_OBJECT_TYPE, rtgui_object_t))

+/** Checks if the object is an rtgui_Object */

+#define RTGUI_IS_OBJECT(obj)    (RTGUI_OBJECT_CHECK_TYPE((obj), RTGUI_OBJECT_TYPE))

+

+/* rtgui base object */

+struct rtgui_object

+{

+	/* object type */

+	rtgui_type_t* type;

+

+	char *name;

+	rt_bool_t is_static;

+};

+rtgui_type_t *rtgui_object_type_get(void);

+

+rtgui_object_t *rtgui_object_create(rtgui_type_t *object_type);

+void         rtgui_object_destroy(rtgui_object_t *object);

+

+void         rtgui_object_name_set(rtgui_object_t *object, const char *name);

+const char   *rtgui_object_name_get(rtgui_object_t *object);

+

+rtgui_object_t *rtgui_object_check_cast(rtgui_object_t *object, rtgui_type_t *type);

+rtgui_type_t   *rtk_object_object_type_get(rtgui_object_t *object);

+

+#ifdef __cplusplus

+}

+#endif

+

+#endif

diff --git a/rtgui/include/rtgui/rtgui_server.h b/rtgui/include/rtgui/rtgui_server.h
new file mode 100644
index 0000000000..a9463ecb38
--- /dev/null
+++ b/rtgui/include/rtgui/rtgui_server.h
@@ -0,0 +1,70 @@
+/*

+ * File      : rtgui_server.h

+ * This file is part of RTGUI in 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-04     Bernard      first version

+ */

+#ifndef __RTGUI_SERVER_H__

+#define __RTGUI_SERVER_H__

+

+#include <rtgui/list.h>

+

+/* RTGUI server definitions */

+

+/* top window definitions in server */

+enum

+{

+	WINTITLE_NO			= 0x01,

+	WINTITLE_BORDER		= 0x02,

+	WINTITLE_ACTIVATE	= 0x04,

+	WINTITLE_CLOSEBOX	= 0x08,

+	WINTITLE_MOVE		= 0x0C,

+	WINTITLE_CB_PRESSED	= 0x10,

+	WINTITLE_NOFOCUS	= 0x20

+};

+

+#define WINTITLE_HEIGHT			20

+#define WINTITLE_BORDER_SIZE	1

+

+struct rtgui_topwin

+{

+	/* the window flag */

+	rt_uint32_t flag;

+	/* event mask */

+	rt_uint32_t mask;

+

+	struct rtgui_wintitle* title;

+

+	/* the window id */

+	struct rtgui_win* wid;

+

+	/* the thread id */

+	rt_thread_t tid;

+

+	/* the extent information */

+	rtgui_rect_t extent;

+

+	/* the top window list */

+	rtgui_list_t list;

+

+	/* the monitor rect list */

+	rtgui_list_t monitor_list;

+};

+typedef struct rtgui_topwin rtgui_topwin_t;

+

+/* top win manager init */

+void rtgui_topwin_init(void);

+void rtgui_panel_init (void);

+void rtgui_server_init(void);

+

+/* post an event to server */

+void rtgui_server_post_event(struct rtgui_event* event, rt_size_t size);

+

+#endif

diff --git a/rtgui/include/rtgui/rtgui_system.h b/rtgui/include/rtgui/rtgui_system.h
new file mode 100644
index 0000000000..e0ceae6f2b
--- /dev/null
+++ b/rtgui/include/rtgui/rtgui_system.h
@@ -0,0 +1,81 @@
+/*

+ * File      : rtgui_system.h

+ * This file is part of RTGUI in 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-04     Bernard      first version

+ */

+#ifndef __RTGUI_SYSTEM_H__

+#define __RTGUI_SYSTEM_H__

+

+#include <rtthread.h>

+#include <rtgui/rtgui.h>

+

+struct rtgui_dc;

+struct rtgui_event;

+struct rtgui_widget;

+

+struct rtgui_thread

+{

+	/* the thread id */

+	rt_thread_t tid;

+

+	/* the message queue of thread */

+	rt_mq_t mq;

+

+	/* the owner of thread */

+	struct rtgui_widget* widget;

+};

+typedef struct rtgui_thread rtgui_thread_t;

+struct rtgui_timer;

+typedef void (*rtgui_timeout_func)(struct rtgui_timer* timer, void* parameter);

+

+struct rtgui_timer

+{

+	/* context thread id */

+	rt_thread_t tid;

+	/* rt timer */

+	struct rt_timer timer;

+

+	/* timeout function and user data */

+	rtgui_timeout_func timeout;

+	void* user_data;

+};

+typedef struct rtgui_timer rtgui_timer_t;

+

+rtgui_timer_t* rtgui_timer_create(rt_int32_t time, rt_base_t flag, rtgui_timeout_func timeout, void* parameter);

+void rtgui_timer_destory(rtgui_timer_t* timer);

+

+void rtgui_timer_start(rtgui_timer_t* timer);

+void rtgui_timer_stop (rtgui_timer_t* timer);

+

+void rtgui_thread_system_init(void);

+rtgui_thread_t* rtgui_thread_register(rt_thread_t tid, rt_mq_t mq);

+void rtgui_thread_deregister(rt_thread_t tid);

+

+rt_thread_t rtgui_thread_get_server(void);

+

+void rtgui_thread_set_widget(struct rtgui_widget* widget);

+struct rtgui_widget* rtgui_thread_get_widget(void);

+

+rt_err_t rtgui_thread_send(rt_thread_t tid, struct rtgui_event* event, rt_size_t event_size);

+rt_err_t rtgui_thread_send_urgent(rt_thread_t tid, struct rtgui_event* event, rt_size_t event_size);

+rt_err_t rtgui_thread_send_sync(rt_thread_t tid, struct rtgui_event* event, rt_size_t event_size);

+rt_err_t rtgui_thread_recv(struct rtgui_event* event, rt_size_t event_size);

+rt_err_t rtgui_thread_recv_filter(rt_uint32_t type, struct rtgui_event* event, rt_size_t event_size);

+rt_err_t rtgui_thread_ack(struct rtgui_event* event, rt_int32_t status);

+

+/* rtgui system initialization function */

+void rtgui_system_server_init(void);

+void rtgui_system_app_init(void);

+

+void* rtgui_malloc(rt_size_t size);

+void rtgui_free(void* ptr);

+

+#endif

diff --git a/rtgui/include/rtgui/rtgui_theme.h b/rtgui/include/rtgui/rtgui_theme.h
new file mode 100644
index 0000000000..eb6738d6b5
--- /dev/null
+++ b/rtgui/include/rtgui/rtgui_theme.h
@@ -0,0 +1,38 @@
+/*

+ * File      : rtgui_theme.h

+ * This file is part of RTGUI in 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-04     Bernard      first version

+ */

+#ifndef __RTGUI_THEME_H__

+#define __RTGUI_THEME_H__

+

+#include <rtgui/rtgui.h>

+

+#include <rtgui/widgets/label.h>

+#include <rtgui/widgets/button.h>

+#include <rtgui/widgets/textbox.h>

+#include <rtgui/widgets/iconbox.h>

+

+#ifdef __cplusplus

+extern "C" {

+#endif

+

+void rtgui_theme_draw_win(struct rtgui_topwin* win);

+void rtgui_theme_draw_button(rtgui_button_t* btn);

+void rtgui_theme_draw_label(rtgui_label_t* label);

+void rtgui_theme_draw_textbox(rtgui_textbox_t* box);

+void rtgui_theme_draw_iconbox(rtgui_iconbox_t* iconbox);

+

+#ifdef __cplusplus

+}

+#endif

+

+#endif

diff --git a/rtgui/include/rtgui/widgets/widget.h b/rtgui/include/rtgui/widgets/widget.h
new file mode 100644
index 0000000000..9d0508390b
--- /dev/null
+++ b/rtgui/include/rtgui/widgets/widget.h
@@ -0,0 +1,197 @@
+/*
+ * File      : widget.h
+ * This file is part of RTGUI in 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-04     Bernard      first version
+ */
+#ifndef __RTGUI_WIDGET_H__
+#define __RTGUI_WIDGET_H__
+
+#include <rtgui/rtgui.h>
+#include <rtgui/list.h>
+#include <rtgui/region.h>
+#include <rtgui/event.h>
+#include <rtgui/color.h>
+#include <rtgui/font.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define RTGUI_WIDGET_FLAG_HIDE			0x01
+#define RTGUI_WIDGET_FLAG_DISABLE		0x02
+#define RTGUI_WIDGET_FLAG_FOCUS			0x04
+#define RTGUI_WIDGET_FLAG_TRANSPARENT	0x08
+#define RTGUI_WIDGET_FLAG_FOCUSABLE		0x10
+#define RTGUI_WIDGET_FLAG_DEFAULT		0x00
+
+#define RTGUI_WIDGET_UNHIDE(w)			(w)->flag &= ~RTGUI_WIDGET_FLAG_HIDE
+#define RTGUI_WIDGET_HIDE(w)			(w)->flag |= RTGUI_WIDGET_FLAG_HIDE
+#define RTGUI_WIDGET_IS_HIDE(w)			((w)->flag & RTGUI_WIDGET_FLAG_HIDE)
+
+#define RTGUI_WIDGET_ENABLE(w)			(w)->flag &= ~RTGUI_WIDGET_FLAG_DISABLE
+#define RTGUI_WIDGET_DISABLE(w)			(w)->flag |= RTGUI_WIDGET_FLAG_DISABLE
+#define RTGUI_WIDGET_IS_ENABLE(w)		!(w->flag & RTGUI_WIDGET_FLAG_DISABLE)
+
+#define RTGUI_WIDGET_UNFOCUS(w)			(w)->flag &= ~RTGUI_WIDGET_FLAG_FOCUS
+#define RTGUI_WIDGET_FOCUS(w)			(w)->flag |= RTGUI_WIDGET_FLAG_FOCUS
+#define RTGUI_WIDGET_IS_FOCUS(w)		((w)->flag & RTGUI_WIDGET_FLAG_FOCUS)
+
+#define RTGUI_WIDGET_IS_FOCUSABLE(w) 	((w)->flag & RTGUI_WIDGET_FLAG_FOCUSABLE)
+
+/* get rtgui widget object */
+#define RTGUI_WIDGET_FOREGROUND(w) 		((w)->gc.foreground)
+#define RTGUI_WIDGET_BACKGROUND(w)		((w)->gc.background)
+#define RTGUI_WIDGET_TEXTALIGN(w)		((w)->gc.textalign)
+#define RTGUI_WIDGET_FONT(w)			((w)->gc.font)
+#define RTGUI_WIDGET_FLAG(w)			((w)->flag)
+
+/** Gets the type of a widget */
+#define RTGUI_WIDGET_TYPE       (rtgui_widget_type_get())
+/** Casts the object to a rtgui_widget */
+#define RTGUI_WIDGET(obj)       (RTGUI_OBJECT_CAST((obj), RTGUI_WIDGET_TYPE, rtgui_widget_t))
+/** Check if the object is a rtgui_widget */
+#define RTGUI_IS_WIDGET(obj)    (RTGUI_OBJECT_CHECK_TYPE((obj), RTGUI_WIDGET_TYPE))
+
+struct rtgui_gc
+{
+	/* foreground and background color */
+	rtgui_color_t foreground, background;
+
+	/* text align */
+	rt_base_t textalign;
+
+	/* font */
+	rtgui_font_t* font;
+};
+typedef struct rtgui_gc rtgui_gc_t;
+
+/*
+ * the base widget object
+ */
+struct rtgui_widget
+{
+   /* inherit from rtgui_object */
+	struct rtgui_object object;
+
+	/* the parent and root widget */
+	struct rtgui_widget *parent, *toplevel;
+	/* the widget children and sibling */
+	rtgui_list_t sibling;
+
+	/* widget flag */
+	rt_int32_t flag;
+	/* widget align */
+	rt_int32_t align;
+
+	/* the graphic context of widget */
+	rtgui_gc_t gc;
+
+	/* the widget extent */
+	rtgui_rect_t extent;
+	rt_int16_t mini_width, mini_height;
+	rt_int16_t margin, margin_style;
+
+	/* the rect clip */
+	rtgui_region_t clip;
+	rt_uint32_t clip_sync;
+
+	/* the event handler */
+	rt_bool_t (*event_handler)	(struct rtgui_widget* widget, struct rtgui_event* event);
+
+	/* call back */
+	rt_bool_t (*on_draw)		(struct rtgui_widget* widget, struct rtgui_event* event);
+	rt_bool_t (*on_focus_in)	(struct rtgui_widget* widget, struct rtgui_event* event);
+	rt_bool_t (*on_focus_out)	(struct rtgui_widget* widget, struct rtgui_event* event);
+	rt_bool_t (*on_mouseclick)	(struct rtgui_widget* widget, struct rtgui_event* event);
+	rt_bool_t (*on_key)			(struct rtgui_widget* widget, struct rtgui_event* event);
+	rt_bool_t (*on_size)		(struct rtgui_widget* widget, struct rtgui_event* event);
+	rt_bool_t (*on_command)		(struct rtgui_widget* widget, struct rtgui_event* event);
+};
+typedef struct rtgui_widget rtgui_widget_t;
+
+rtgui_type_t *rtgui_widget_type_get(void);
+rtgui_widget_t *rtgui_widget_create(rtgui_type_t *widget_type);
+void rtgui_widget_destroy(rtgui_widget_t* widget);
+
+/* initial a widget */
+void rtgui_widget_init(rtgui_widget_t* widget, rtgui_type_t type, rtgui_rect_t* rect);
+/* detach a widget */
+void rtgui_widget_detach(rtgui_widget_t* widget);
+
+/* update toplevel widget */
+void rtgui_widget_update_toplevel(rtgui_widget_t* widget);
+
+/* set the event handler of widget */
+void rtgui_widget_set_event_handler(rtgui_widget_t* widget, rtgui_event_handler_ptr handler);
+/* widget default event handler */
+rt_bool_t rtgui_widget_event_handler(rtgui_widget_t* widget, rtgui_event_t* event);
+
+/* dispatch event to child widget */
+rt_bool_t rtgui_widget_dispatch_event(rtgui_widget_t* widget, rtgui_event_t* event);
+rt_bool_t rtgui_widget_dispatch_mouse_event(rtgui_widget_t* widget, struct rtgui_event_mouse* event);
+
+/* set and get widget label */
+char* rtgui_widget_get_label(rtgui_widget_t* widget);
+void rtgui_widget_set_label(rtgui_widget_t* widget, const char* label);
+
+/* focus and unfocus */
+void rtgui_widget_focus(rtgui_widget_t * widget);
+void rtgui_widget_unfocus(rtgui_widget_t *widget);
+
+/* event handler for each command */
+void rtgui_widget_set_ondraw(rtgui_widget_t* widget, rtgui_event_handler_ptr handler);
+void rtgui_widget_set_onfocus(rtgui_widget_t* widget, rtgui_event_handler_ptr handler);
+void rtgui_widget_set_onunfocus(rtgui_widget_t* widget, rtgui_event_handler_ptr handler);
+void rtgui_widget_set_onmouseclick(rtgui_widget_t* widget, rtgui_event_handler_ptr handler);
+void rtgui_widget_set_onkey(rtgui_widget_t* widget, rtgui_event_handler_ptr handler);
+void rtgui_widget_set_onsize(rtgui_widget_t* widget, rtgui_event_handler_ptr handler);
+void rtgui_widget_set_oncommand(rtgui_widget_t* widget, rtgui_event_handler_ptr handler);
+
+/* get and set rect of widget */
+void rtgui_widget_get_rect(rtgui_widget_t* widget, rtgui_rect_t *rect);
+void rtgui_widget_set_rect(rtgui_widget_t* widget, rtgui_rect_t* rect);
+
+void rtgui_widget_set_miniwidth(rtgui_widget_t* widget, int width);
+void rtgui_widget_set_miniheight(rtgui_widget_t* widget, int height);
+
+/* get the physical position of a logic point on widget */
+void rtgui_widget_point_to_device(rtgui_widget_t * widget, rtgui_point_t * point);
+/* get the physical position of a logic rect on widget */
+void rtgui_widget_rect_to_device(rtgui_widget_t * widget, rtgui_rect_t * rect);
+
+/* get the logic position of a physical point on widget */
+void rtgui_widget_point_to_logic(rtgui_widget_t* widget, rtgui_point_t * point);
+/* get the logic position of a physical rect on widget */
+void rtgui_widget_rect_to_logic(rtgui_widget_t* widget, rtgui_rect_t* rect);
+
+/* move widget and its children to a logic point */
+void rtgui_widget_move_to_logic(rtgui_widget_t* widget, int dx, int dy);
+
+/* update the clip info of widget */
+void rtgui_widget_update_clip(rtgui_widget_t* widget);
+
+/* get the toplevel widget of widget */
+rtgui_widget_t* rtgui_widget_get_toplevel(rtgui_widget_t* widget);
+
+void rtgui_widget_show(rtgui_widget_t* widget);
+void rtgui_widget_hide(rtgui_widget_t* widget);
+void rtgui_widget_update(rtgui_widget_t* widget);
+
+/* get the next sibling of widget */
+rtgui_widget_t* rtgui_widget_get_next_sibling(rtgui_widget_t* widget);
+/* get the prev sibling of widget */
+rtgui_widget_t* rtgui_widget_get_prev_sibling(rtgui_widget_t* widget);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/rtgui/include/rtgui/widgets/window.h b/rtgui/include/rtgui/widgets/window.h
new file mode 100644
index 0000000000..ee7f8a6b66
--- /dev/null
+++ b/rtgui/include/rtgui/widgets/window.h
@@ -0,0 +1,91 @@
+/*

+ * File      : window.h

+ * This file is part of RTGUI in 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-04     Bernard      first version

+ */

+#ifndef __RTGUI_WINDOW_H__

+#define __RTGUI_WINDOW_H__

+

+#include <rtgui/rtgui.h>

+#include <rtgui/list.h>

+#include <rtgui/widgets/widget.h>

+#include <rtgui/widgets/toplevel.h>

+#include <rtgui/widgets/box.h>

+

+/** Gets the type of a win */

+#define RTGUI_WIN_TYPE       (rtgui_win_type_get())

+/** Casts the object to an rtgui_win */

+#define RTGUI_WIN(obj)       (RTGUI_OBJECT_CAST((obj), RTGUI_WIN_TYPE, rtgui_win_t))

+/** Checks if the object is an rtgui_win */

+#define RTGUI_IS_WIN(obj)    (RTGUI_OBJECT_CHECK_TYPE((obj), RTGUI_WIN_TYPE))

+

+#define RTGUI_WIN_STYLE_MODAL		0x00

+#define RTGUI_WIN_STYLE_MODAL_LESS	0x01

+#define RTGUI_WIN_STYLE_NO_TITLE	0x02

+#define RTGUI_WIN_STYLE_NO_BORDER	0x04

+#define RTGUI_WIN_STYLE_SHOW		0x08

+#define RTGUI_WIN_STYLE_CLOSEBOX	0x10

+#define RTGUI_WIN_STYLE_MINIBOX		0x20

+#define RTGUI_WIN_STYLE_ACTIVATE	0x40

+#define RTGUI_WIN_STYLE_NO_FOCUS	0x80

+

+#define RTGUI_WIN_STYLE_DEFAULT		(RTGUI_WIN_STYLE_CLOSEBOX | RTGUI_WIN_STYLE_MINIBOX)

+
+struct rtgui_win_title;

+struct rtgui_win_area;

+

+struct rtgui_win

+{

+	/* inherit from toplevel */

+	struct rtgui_toplevel parent;

+

+	/* top window style */

+	rt_uint32_t style;

+

+	/* window title */

+	char* title;

+

+	/* call back */

+	rt_bool_t (*on_activate)	(struct rtgui_widget* widget, struct rtgui_event* event);
+	rt_bool_t (*on_deactivate)	(struct rtgui_widget* widget, struct rtgui_event* event);

+	rt_bool_t (*on_close)		(struct rtgui_widget* widget, struct rtgui_event* event);

+

+	/* reserved user data */

+	rt_uint32_t user_data;
+};

+

+rtgui_type_t *rtgui_win_type_get(void);

+

+rtgui_win_t* rtgui_win_create(const char* title, rtgui_rect_t *rect, rt_uint32_t flag);

+void rtgui_win_destroy(rtgui_win_t* win);

+

+void rtgui_win_show(rtgui_win_t* win);

+void rtgui_win_hiden(rtgui_win_t* win);

+rt_bool_t rtgui_win_is_activated(struct rtgui_win* win);

+

+void rtgui_win_move(struct rtgui_win* win, int x, int y);

+

+/* reset extent of window */

+void rtgui_win_set_rect(rtgui_win_t* win, rtgui_rect_t* rect);

+void rtgui_win_set_box(rtgui_win_t* win, rtgui_box_t* box);

+

+void rtgui_win_set_onactivate(rtgui_win_t* win, rtgui_event_handler_ptr handler);

+void rtgui_win_set_ondeactivate(rtgui_win_t* win, rtgui_event_handler_ptr handler);

+void rtgui_win_set_onclose(rtgui_win_t* win, rtgui_event_handler_ptr handler);

+

+rt_bool_t rtgui_win_event_handler(rtgui_widget_t* win, struct rtgui_event* event);

+

+void rtgui_win_event_loop(rtgui_win_t* wnd);

+

+void rtgui_win_set_title(rtgui_win_t* win, const char *title);

+char* rtgui_win_get_title(rtgui_win_t* win);

+

+#endif

diff --git a/rtgui/include/rtgui/widgets/workbench.h b/rtgui/include/rtgui/widgets/workbench.h
new file mode 100644
index 0000000000..354cc6b474
--- /dev/null
+++ b/rtgui/include/rtgui/widgets/workbench.h
@@ -0,0 +1,77 @@
+/*

+ * File      : workbench.h

+ * This file is part of RTGUI in 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-04     Bernard      first version

+ */

+#ifndef __RTGUI_WORKBENCH_H__

+#define __RTGUI_WORKBENCH_H__

+

+#include <rtgui/rtgui.h>

+#include <rtgui/list.h>

+#include <rtgui/region.h>

+#include <rtgui/dc.h>

+

+#include <rtgui/widgets/view.h>

+#include <rtgui/widgets/toplevel.h>

+

+#define RTGUI_WORKBENCH_FLAG_VISIBLE	0x00

+#define RTGUI_WORKBENCH_FLAG_INVISIBLE	0x01

+#define RTGUI_WORKBENCH_FLAG_FULLSCREEN	0x02

+

+#define RTGUI_WORKBENCH_FLAG_CLOSEBLE	0x00

+#define RTGUI_WORKBENCH_FLAG_UNCLOSEBLE	0x10

+

+#define RTGUI_WORKBENCH_FLAG_DEFAULT	RTGUI_WORKBENCH_FLAG_VISIBLE | RTGUI_WORKBENCH_FLAG_CLOSEBLE

+

+/** Gets the type of a workbench */

+#define RTGUI_WORKBENCH_TYPE       (rtgui_workbench_type_get())

+/** Casts the object to an rtgui_workbench */

+#define RTGUI_WORKBENCH(obj)       (RTGUI_OBJECT_CAST((obj), RTGUI_WORKBENCH_TYPE, rtgui_workbench_t))

+/** Checks if the object is an rtgui_workbench */

+#define RTGUI_IS_WORKBENCH(obj)    (RTGUI_OBJECT_CHECK_TYPE((obj), RTGUI_WORKBENCH_TYPE))

+

+struct rtgui_workbench

+{

+	/* inherit from toplevel */

+	struct rtgui_toplevel parent;

+

+	/* panel id */

+	rtgui_panel_t* panel;

+

+	/* workbench flag */

+	rt_uint8_t flag;

+

+	/* workbench title */

+	unsigned char* title;

+};

+

+rtgui_workbench_t *rtgui_workbench_create(const char* panel_name, const unsigned char* title);

+void rtgui_workbench_destroy(rtgui_workbench_t* workbench);

+

+rtgui_type_t* rtgui_workbench_type_get(void);

+

+rt_bool_t rtgui_workbench_event_handler(rtgui_widget_t* widget, rtgui_event_t* event);

+

+void rtgui_workbench_set_flag(rtgui_workbench_t* workbench, rt_uint8_t flag);

+

+void rtgui_workbench_event_loop(rtgui_workbench_t* workbench);

+

+rt_err_t rtgui_workbench_show (rtgui_workbench_t* workbench);

+rt_err_t rtgui_workbench_hide (rtgui_workbench_t* workbench);

+

+void rtgui_workbench_add_view(rtgui_workbench_t* workbench, rtgui_view_t* view);

+void rtgui_workbench_remove_view(rtgui_workbench_t* workbench, rtgui_view_t* view);

+void rtgui_workbench_show_view(rtgui_workbench_t* workbench, rtgui_view_t* view);

+void rtgui_workbench_hide_view(rtgui_workbench_t* workbench, rtgui_view_t* view);

+

+rtgui_view_t *rtgui_workbench_get_current_view(rtgui_workbench_t * workbench);

+

+#endif

diff --git a/rtgui/server/driver.c b/rtgui/server/driver.c
new file mode 100644
index 0000000000..2805ad1e56
--- /dev/null
+++ b/rtgui/server/driver.c
@@ -0,0 +1,67 @@
+/*

+ * File      : driver.c

+ * This file is part of RTGUI in 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-04     Bernard      first version

+ */

+#include <rtgui/driver.h>

+

+struct rtgui_list_node _rtgui_graphic_driver_list = {RT_NULL};

+

+void rtgui_graphic_driver_add(struct rtgui_graphic_driver* driver)

+{

+	rtgui_list_insert(&_rtgui_graphic_driver_list, &(driver->list));

+}

+

+void rtgui_graphic_driver_remove(struct rtgui_graphic_driver* driver)

+{

+	rtgui_list_remove(&_rtgui_graphic_driver_list, &(driver->list));

+}

+

+struct rtgui_graphic_driver* rtgui_graphic_driver_find(char* name)

+{

+	struct rtgui_list_node* node;

+	struct rtgui_graphic_driver* driver;

+

+	/* search in list */

+	rtgui_list_foreach(node, &(_rtgui_graphic_driver_list))

+	{

+		driver = rtgui_list_entry(node, struct rtgui_graphic_driver, list);

+

+		/* find it */

+		if (rt_strncmp(driver->name, name, RTGUI_NAME_MAX) == 0)

+		{

+			return driver;

+		}

+	}

+

+	return RT_NULL;

+}

+

+struct rtgui_graphic_driver* rtgui_graphic_driver_get_default()

+{

+	return rtgui_list_entry(_rtgui_graphic_driver_list.next,

+		struct rtgui_graphic_driver, list);

+}

+

+void rtgui_graphic_driver_get_rect(struct rtgui_graphic_driver *driver, rtgui_rect_t *rect)

+{

+	if (rect == RT_NULL || driver == RT_NULL) return;

+

+	rect->x1 = rect->y1 = 0;

+	rect->x2 = driver->width;

+	rect->y2 = driver->height;

+}

+

+void rtgui_graphic_driver_get_default_rect(rtgui_rect_t *rect)

+{

+	/* return default the extent of default driver */

+	rtgui_graphic_driver_get_rect(rtgui_graphic_driver_get_default(), rect);

+}

diff --git a/rtgui/server/panel.c b/rtgui/server/panel.c
new file mode 100644
index 0000000000..744fa5b3f7
--- /dev/null
+++ b/rtgui/server/panel.c
@@ -0,0 +1,293 @@
+/*

+ * File      : panel.c

+ * This file is part of RTGUI in 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-04     Bernard      first version

+ */

+

+#include "panel.h"

+#include "mouse.h"

+

+#include <rtgui/rtgui_system.h>

+

+/* the global parameter */

+struct rtgui_list_node _rtgui_panel_list;

+

+void rtgui_panel_init()

+{

+	rtgui_list_init(&_rtgui_panel_list);

+}

+

+void rtgui_panel_register(char* name, rtgui_rect_t* extent)

+{

+	register rt_base_t temp;

+	struct rtgui_panel* panel;

+

+	panel = rtgui_panel_find(name);

+	if (panel != RT_NULL )

+	{

+		/* there are already a same named panel exist. */

+		return;

+	}

+

+	panel = rtgui_malloc(sizeof(struct rtgui_panel));

+	if (panel == RT_NULL)

+	{

+		/* can't alloc memory */

+		return;

+	}

+

+	/* copy name */

+	for (temp = 0; temp < RTGUI_NAME_MAX; temp ++)

+	{

+		panel->name[temp] = name[temp];

+	}

+

+	/* copy extent */

+	panel->extent = *extent;

+

+	panel->wm_thread = RT_NULL;

+

+	/* init list */

+	rtgui_list_init(&(panel->sibling));

+	rtgui_list_init(&(panel->thread_list));

+

+	/* add panel to panel list */

+	rtgui_list_insert(&_rtgui_panel_list, &(panel->sibling));

+}

+

+void rtgui_panel_deregister(char* name)

+{

+	struct rtgui_panel* panel;

+

+	panel = rtgui_panel_find(name);

+	if (panel != RT_NULL)

+	{

+		rtgui_list_remove(&_rtgui_panel_list, &(panel->sibling));

+

+		/* free pane node */

+		rtgui_free(panel);

+	}

+}

+

+struct rtgui_panel* rtgui_panel_find(char* name)

+{

+	struct rtgui_list_node* node;

+	struct rtgui_panel* panel;

+

+	rtgui_list_foreach(node, &_rtgui_panel_list)

+	{

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

+

+		if (rt_strncmp(panel->name, name, RTGUI_NAME_MAX) == 0)

+		{

+			return panel;

+		}

+	}

+

+	return RT_NULL;

+}

+

+struct rtgui_panel* rtgui_panel_thread_add(char* name, rt_thread_t tid)

+{

+	struct rtgui_panel* panel;

+

+	panel = rtgui_panel_find(name);

+	if (panel != RT_NULL )

+	{

+		struct rtgui_panel_thread* thread;

+

+		/* allocate panel thread node */

+		thread = rtgui_malloc(sizeof(struct rtgui_panel_thread));

+		if (thread == RT_NULL)

+		{

+			return RT_NULL;

+		}

+

+		/* construct panel thread node */

+		thread->tid = tid;

+

+		/* init list */

+		rtgui_list_init(&(thread->list));

+		rtgui_list_init(&(thread->monitor_list));

+

+		/* append thread to the list */

+		rtgui_list_append(&(panel->thread_list), &(thread->list));

+	}

+

+	return panel;

+}

+

+void rtgui_panel_thread_remove(rtgui_panel_t* panel, rt_thread_t tid)

+{

+	if (panel != RT_NULL )

+	{

+		struct rtgui_list_node* node;

+		struct rtgui_panel_thread* thread;

+

+		rtgui_list_foreach(node, &(panel->thread_list))

+		{

+			thread = rtgui_list_entry(node, struct rtgui_panel_thread, list);

+			if (thread->tid == tid)

+			{

+				/* remove node from list */

+				rtgui_list_remove(&(panel->thread_list), &(thread->list));

+

+				/* free the panel thread node */

+				rtgui_free(thread);

+				return;

+			}

+		}

+	}

+}

+

+rt_thread_t rtgui_panel_get_active_thread(rtgui_panel_t* panel)

+{

+	if (panel != RT_NULL)

+	{

+		if (panel->thread_list.next != RT_NULL)

+		{

+			struct rtgui_panel_thread* thread;

+			thread = rtgui_list_entry(panel->thread_list.next, struct rtgui_panel_thread, list);

+

+			return thread->tid;

+		}

+	}

+

+	return RT_NULL;

+}

+

+void rtgui_panel_set_active_thread(rtgui_panel_t* panel, rt_thread_t tid)

+{

+	/* get old active thread */

+	rt_thread_t prev_actived = rtgui_panel_get_active_thread(panel);

+	if (prev_actived != tid)

+	{

+		/* de-active old active workbench */

+		struct rtgui_event_panel_hide ehide;

+		RTGUI_EVENT_PANEL_HIDE_INIT(&ehide);

+

+		ehide.panel = panel;

+		ehide.workbench = RT_NULL;

+		rtgui_thread_send_urgent(prev_actived, &(ehide.parent), sizeof (ehide));

+	}

+

+	if (panel != RT_NULL )

+	{

+		struct rtgui_list_node* node;

+		struct rtgui_panel_thread* thread;

+

+		rtgui_list_foreach(node, &(panel->thread_list))

+		{

+			thread = rtgui_list_entry(node, struct rtgui_panel_thread, list);

+			if (thread->tid == tid)

+			{

+				/* remove node from list */

+				rtgui_list_remove(&(panel->thread_list), &(thread->list));

+

+				/* insert node to the header */

+				rtgui_list_insert(&(panel->thread_list), &(thread->list));

+				return;

+			}

+		}

+	}

+}

+

+/* deactivate current activated thread -- move it to the end of list */

+void rtgui_panel_deactive_thread(rtgui_panel_t* panel)

+{

+	RT_ASSERT(panel == RT_NULL);

+

+	if (panel->thread_list.next != RT_NULL)

+	{

+		struct rtgui_panel_thread* thread;

+		thread = rtgui_list_entry(panel->thread_list.next, struct rtgui_panel_thread, list);

+

+		/* remove it */

+		panel->thread_list.next = thread->list.next;

+

+		/* append to the tail of thread list */

+		rtgui_list_append(&(panel->thread_list), &(thread->list));

+	}

+}

+

+/**

+ * get the panel which contains a point(x, y)

+ */

+rtgui_panel_t* rtgui_panel_get_contain(int x, int y)

+{

+	struct rtgui_list_node* node;

+	struct rtgui_panel* panel;

+

+	rtgui_list_foreach(node, &(_rtgui_panel_list))

+	{

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

+		if (rtgui_rect_contains_point(&(panel->extent), x, y) == RT_EOK)

+		{

+			return panel;

+		}

+	}

+

+	return RT_NULL;

+}

+

+/**

+ * append a rect to panel mouse monitor rect list

+ */

+void rtgui_panel_append_monitor_rect(rtgui_panel_t* panel, rt_thread_t tid, rtgui_rect_t* rect)

+{

+	if (panel != RT_NULL )

+	{

+		struct rtgui_list_node* node;

+		struct rtgui_panel_thread* thread;

+

+		rtgui_list_foreach(node, &(panel->thread_list))

+		{

+			thread = rtgui_list_entry(node, struct rtgui_panel_thread, list);

+			if (thread->tid == tid)

+			{

+				/* add the monitor rect to list */

+				rtgui_mouse_monitor_append(&(thread->monitor_list), rect);

+				return;

+			}

+		}

+	}

+}

+

+/**

+ * remove a rect from panel mouse monitor rect list

+ */

+void rtgui_panel_remove_monitor_rect(rtgui_panel_t* panel, rt_thread_t tid, rtgui_rect_t* rect)

+{

+	if (panel != RT_NULL )

+	{

+		struct rtgui_list_node* node;

+		struct rtgui_panel_thread* thread;

+

+		rtgui_list_foreach(node, &(panel->thread_list))

+		{

+			thread = rtgui_list_entry(node, struct rtgui_panel_thread, list);

+			if (thread->tid == tid)

+			{

+				/* remove the monitor rect from list */

+				rtgui_mouse_monitor_remove(&(thread->monitor_list), rect);

+				return;

+			}

+		}

+	}

+}

+

+void rtgui_panel_set_wm(rtgui_panel_t* panel, rt_thread_t wm)

+{

+	RT_ASSERT(wm != RT_NULL);

+	RT_ASSERT(panel != RT_NULL);

+

+	panel->wm_thread = wm;

+}

diff --git a/rtgui/server/panel.h b/rtgui/server/panel.h
new file mode 100644
index 0000000000..a524ede6a4
--- /dev/null
+++ b/rtgui/server/panel.h
@@ -0,0 +1,72 @@
+/*

+ * File      : panel.h

+ * This file is part of RTGUI in 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-04     Bernard      first version

+ */

+

+#ifndef __RT_PANEL_H__

+#define __RT_PANEL_H__

+

+#include <rtgui/rtgui.h>

+#include <rtgui/list.h>

+#include <rtgui/region.h>

+

+struct rtgui_panel_thread

+{

+	/* thread id */

+	rt_thread_t tid;

+

+	/* the list of thread */

+	rtgui_list_t list;

+

+	/* monitor rect list */

+	rtgui_list_t monitor_list;

+};

+typedef struct rtgui_panel_thread rtgui_panel_thread_list_t;

+

+struct rtgui_panel

+{

+	char name[RTGUI_NAME_MAX];

+

+	/* the extent of panel */

+	rtgui_rect_t extent;

+

+	/* the list of panel */

+	rtgui_list_t sibling;

+

+	/* the thread list in this panel */

+	rtgui_list_t thread_list;

+

+	/* the workbench manager thread */

+	rt_thread_t wm_thread;

+};

+

+/* register or deregister panel in server */

+void rtgui_panel_register(char* name, rtgui_rect_t* extent);

+void rtgui_panel_deregister(char* name);

+

+/* find panel by name */

+struct rtgui_panel* rtgui_panel_find(char* name);

+

+/* add or remove application thread from specified panel */

+rtgui_panel_t* rtgui_panel_thread_add(char* name, rt_thread_t tid);

+void rtgui_panel_thread_remove(rtgui_panel_t* panel, rt_thread_t tid);

+

+rt_thread_t rtgui_panel_get_active_thread(rtgui_panel_t* panel);

+void rtgui_panel_set_active_thread(rtgui_panel_t* panel, rt_thread_t tid);

+

+rtgui_panel_t* rtgui_panel_get_contain(int x, int y);

+void rtgui_panel_set_wm(rtgui_panel_t* panel, rt_thread_t wm);

+

+void rtgui_panel_append_monitor_rect(rtgui_panel_t* panel, rt_thread_t tid, rtgui_rect_t* rect);

+void rtgui_panel_remove_monitor_rect(rtgui_panel_t* panel, rt_thread_t tid, rtgui_rect_t* rect);

+

+#endif

diff --git a/rtgui/server/server.c b/rtgui/server/server.c
new file mode 100644
index 0000000000..78040ab344
--- /dev/null
+++ b/rtgui/server/server.c
@@ -0,0 +1,633 @@
+/*

+ * File      : server.c

+ * This file is part of RTGUI in 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-04     Bernard      first version

+ */

+

+#include <rtgui/rtgui.h>

+#include <rtgui/event.h>

+#include <rtgui/rtgui_system.h>
+#include <rtgui/driver.h>

+

+#include "mouse.h"

+#include "panel.h"

+#include "topwin.h"

+

+#define RTGUI_SVR_THREAD_PRIORITY		96

+#define RTGUI_SVR_THREAD_TIMESLICE		20

+

+#define RTGUI_APP_THREAD_PRIORITY		220

+#define RTGUI_APP_THREAD_TIMESLICE		20

+

+static char rtgui_server_stack[2048];

+static struct rt_thread rtgui_server_thread;

+

+static struct rt_messagequeue rtgui_server_mq;

+static char rtgui_server_msg_pool[2048];

+

+extern struct rtgui_topwin* rtgui_server_focus_topwin;

+static struct rtgui_panel* rtgui_server_focus_panel = RT_NULL;

+

+void rtgui_server_create_application(struct rtgui_event_panel_attach* event)

+{

+	struct rtgui_panel* panel = rtgui_panel_find(event->panel_name);

+

+	if (panel != RT_NULL)

+	{

+		struct rtgui_event_panel_info ep;

+		RTGUI_EVENT_PANEL_INFO_INIT(&ep);

+

+		if (panel->wm_thread != RT_NULL)

+		{

+			/* notify to workbench */

+			rtgui_thread_send(panel->wm_thread, &(event->parent), sizeof(struct rtgui_event_panel_attach));

+		}

+

+		/* send the responses - ok */

+		rtgui_thread_ack(RTGUI_EVENT(event), RTGUI_STATUS_OK);

+

+		/* send the panel info */

+		ep.panel = panel;

+		ep.extent = panel->extent;

+		rtgui_thread_send(event->parent.sender, (struct rtgui_event*)&ep, sizeof(ep));

+

+		rtgui_panel_thread_add(event->panel_name, event->parent.sender);

+	}

+	else

+	{

+		/* send the responses - failure */

+		rtgui_thread_ack(RTGUI_EVENT(event), RTGUI_STATUS_NRC);

+	}

+}

+

+void rtgui_server_destroy_application(struct rtgui_event_panel_detach* event)

+{

+	struct rtgui_panel* panel = event->panel;

+

+	if (panel != RT_NULL)

+	{

+		if (panel->wm_thread != RT_NULL)

+		{

+			/* notify to workbench */

+			rtgui_thread_send(panel->wm_thread, &(event->parent), sizeof(struct rtgui_event_panel_detach));

+		}

+

+		/* send the responses */

+		rtgui_thread_ack(RTGUI_EVENT(event), RTGUI_STATUS_OK);

+

+		rtgui_panel_thread_remove(panel, event->parent.sender);

+

+		{

+			/* get next thread and active it */

+			rt_thread_t tid = rtgui_panel_get_active_thread(panel);

+

+			/* let this thread repaint */

+			struct rtgui_event_paint epaint;

+			RTGUI_EVENT_PAINT_INIT(&epaint);

+			epaint.wid = RT_NULL;

+			rtgui_thread_send(tid, (struct rtgui_event*)&epaint, sizeof(epaint));

+		}

+	}

+	else

+	{

+		/* send the responses - failure */

+		rtgui_thread_ack(RTGUI_EVENT(event), RTGUI_STATUS_NRC);

+	}

+}

+

+void rtgui_server_thread_panel_show(struct rtgui_event_panel_show* event)

+{

+	struct rtgui_panel* panel = event->panel;

+

+	if (panel != RT_NULL)

+	{

+		struct rtgui_event_paint epaint;

+

+		/* send the responses */

+		rtgui_thread_ack(RTGUI_EVENT(event), RTGUI_STATUS_OK);

+

+		if (panel->wm_thread != RT_NULL)

+		{

+			/* notify to workbench */

+			rtgui_thread_send(panel->wm_thread, &(event->parent), sizeof(struct rtgui_event_panel_show));

+		}

+

+		rtgui_panel_set_active_thread(panel, event->parent.sender);

+

+		/* send all topwin clip info */

+		rtgui_topwin_update_clip_to_panel(panel);

+

+		/* send paint event */

+		RTGUI_EVENT_PAINT_INIT(&epaint);

+		epaint.wid = RT_NULL;

+		rtgui_thread_send(event->parent.sender, (struct rtgui_event*)&epaint,

+			sizeof(epaint));

+	}

+	else

+	{

+		/* send failed */

+		rtgui_thread_ack(RTGUI_EVENT(event), RTGUI_STATUS_ERROR);

+	}

+}

+

+void rtgui_server_thread_panel_hide(struct rtgui_event_panel_hide* event)

+{

+	struct rtgui_panel* panel = event->panel;

+

+	if (panel != RT_NULL)

+	{

+		rt_thread_t tid;

+		struct rtgui_event_paint epaint;

+

+		/* send the responses */

+		rtgui_thread_ack(RTGUI_EVENT(event), RTGUI_STATUS_OK);

+

+		if (panel->thread_list.next != RT_NULL)

+		{

+			struct rtgui_panel_thread* thread;

+			thread = rtgui_list_entry(panel->thread_list.next, struct rtgui_panel_thread, list);

+

+			/* remove it */

+			panel->thread_list.next = thread->list.next;

+

+			/* append to the tail of thread list */

+			rtgui_list_append(&(panel->thread_list), &(thread->list));

+		}

+

+		/* get new active thread */

+		tid = rtgui_panel_get_active_thread(panel);

+		/* send all topwin clip info */

+		rtgui_topwin_update_clip_to_panel(panel);

+

+		/* send paint event */

+		RTGUI_EVENT_PAINT_INIT(&epaint);

+		epaint.wid = RT_NULL;

+		rtgui_thread_send(tid, (struct rtgui_event*)&epaint, sizeof(epaint));

+	}

+	else

+	{

+		/* send failed */

+		rtgui_thread_ack(RTGUI_EVENT(event), RTGUI_STATUS_ERROR);

+	}

+}

+

+void rtgui_server_handle_set_wm(struct rtgui_event_set_wm *event)

+{

+	struct rtgui_panel* panel = rtgui_panel_find(event->panel_name);

+

+	if (panel != RT_NULL)

+	{

+		rtgui_panel_set_wm(panel, event->parent.sender);

+	}

+}

+

+void rtgui_server_handle_update(struct rtgui_event_update_end* event)

+{

+	struct rtgui_graphic_driver* driver = rtgui_graphic_driver_get_default();

+	if (driver != RT_NULL)

+	{

+		driver->screen_update(&(event->rect));

+	}

+}

+

+void rtgui_server_handle_monitor_add(struct rtgui_event_monitor* event)

+{

+	if (event->panel != RT_NULL)

+	{

+		/* append monitor rect to panel list */

+		rtgui_panel_append_monitor_rect(event->panel, event->parent.sender, &(event->rect));

+	}

+	else

+	{

+		/* add monitor rect to top window list */

+		rtgui_topwin_append_monitor_rect(event->wid, &(event->rect));

+	}

+}

+

+void rtgui_server_handle_monitor_remove(struct rtgui_event_monitor* event)

+{

+	if (event->panel != RT_NULL)

+	{

+		/* add monitor rect to panel list */

+		rtgui_panel_remove_monitor_rect(event->panel, event->parent.sender, &(event->rect));

+	}

+	else

+	{

+		/* add monitor rect to top window list */

+		rtgui_topwin_remove_monitor_rect(event->wid, &(event->rect));

+	}

+}

+

+void rtgui_server_handle_mouse_btn(struct rtgui_event_mouse* event)

+{

+	struct rtgui_topwin* wnd;

+	struct rtgui_panel* panel;

+

+	/* re-init to server thread */

+	RTGUI_EVENT_MOUSE_BUTTON_INIT(event);

+

+	if (rtgui_winrect_is_moved() &&

+		event->button & (RTGUI_MOUSE_BUTTON_LEFT | RTGUI_MOUSE_BUTTON_UP))

+	{

+		struct rtgui_topwin* topwin;

+		rtgui_rect_t rect;

+

+		if (rtgui_winrect_moved_done(&rect, &topwin) == RT_TRUE)

+		{

+			struct rtgui_event_win_move ewin;

+

+			/* move window */

+			RTGUI_EVENT_WIN_MOVE_INIT(&ewin);

+			ewin.wid = topwin->wid;

+			if (topwin->title != RT_NULL)

+			{

+				if (topwin->flag & WINTITLE_BORDER)

+				{

+					ewin.x = rect.x1 + WINTITLE_BORDER_SIZE;

+					ewin.y = rect.y1 + WINTITLE_BORDER_SIZE;

+				}

+				if (!(topwin->flag & WINTITLE_NO)) ewin.y += WINTITLE_HEIGHT;

+			}

+			else

+			{

+				ewin.x = rect.x1;

+				ewin.y = rect.y1;

+			}

+

+			/* send to client thread */

+			rtgui_thread_send(topwin->tid, &(ewin.parent), sizeof(ewin));

+

+			return;

+		}

+	}

+

+	/* get the wnd which contains the mouse */

+	wnd = rtgui_topwin_get_wnd(event->x, event->y);

+	if (wnd != RT_NULL)

+	{

+		event->wid = wnd->wid;

+

+		if (rtgui_server_focus_topwin != wnd)

+		{

+			/* raise this window */

+			rtgui_topwin_raise(wnd->wid, wnd->tid);

+			rtgui_server_focus_panel = RT_NULL;

+		}

+

+		if (wnd->title != RT_NULL &&

+			rtgui_rect_contains_point(&(RTGUI_WIDGET(wnd->title)->extent), event->x, event->y) == RT_EOK)

+		{

+			rtgui_topwin_title_onmouse(wnd, event);

+		}

+		else

+		{

+			/* send mouse event to thread */

+			rtgui_thread_send(wnd->tid, (struct rtgui_event*)event, sizeof(struct rtgui_event_mouse));

+		}

+		return ;

+	}

+

+	/* get the panel which contains the mouse */

+	panel = rtgui_panel_get_contain(event->x, event->y);

+	if (panel != RT_NULL)

+	{

+		/* deactivate old window */

+		if (rtgui_server_focus_topwin != RT_NULL)

+		{

+			rtgui_topwin_deactivate_win(rtgui_server_focus_topwin);

+		}

+

+		rtgui_server_focus_panel = panel;

+		rtgui_server_focus_topwin = RT_NULL;

+

+		/* set destination window to null */

+		event->wid = RT_NULL;

+

+		/* send mouse event to thread */

+		rtgui_thread_send(rtgui_panel_get_active_thread(panel),

+			(struct rtgui_event*)event,

+			sizeof(struct rtgui_event_mouse));

+	}

+}

+

+static struct rtgui_panel* last_monitor_panel = RT_NULL;

+static struct rtgui_topwin* last_monitor_topwin = RT_NULL;

+

+void rtgui_server_handle_mouse_motion(struct rtgui_event_mouse* event)

+{

+	/* the topwin contains current mouse */

+	struct rtgui_topwin* win 	= RT_NULL;

+	struct rtgui_panel* panel 	= RT_NULL;

+

+	/* re-init mouse event */

+	RTGUI_EVENT_MOUSE_MOTION_INIT(event);

+

+	/* find the panel or topwin which monitor the mouse motion */

+	win = rtgui_topwin_get_wnd(event->x, event->y);

+	if (win == RT_NULL)

+	{

+		/* try to find monitor on the panel */

+		panel = rtgui_panel_get_contain(event->x, event->y);

+

+		if (panel != RT_NULL)

+		{

+			struct rtgui_panel_thread* thread;

+

+			/* get active panel thread */

+			if (panel->thread_list.next != RT_NULL)

+			{

+				thread = rtgui_list_entry(panel->thread_list.next, struct rtgui_panel_thread, list);

+				if (!rtgui_mouse_monitor_contains_point(&(thread->monitor_list),

+					event->x, event->y) == RT_TRUE)

+				{

+					/* no monitor in this panel */

+					panel = RT_NULL;

+				}

+			}

+		}

+	}

+	else if (win->monitor_list.next != RT_NULL)

+	{

+		/* check whether the monitor exist */

+		if (rtgui_mouse_monitor_contains_point(&(win->monitor_list), event->x, event->y) != RT_TRUE)

+		{

+			win = RT_NULL;

+

+			/* try to find monitor on the panel */

+			panel = rtgui_panel_get_contain(event->x, event->y);

+			if (panel != RT_NULL)

+			{

+				struct rtgui_panel_thread* thread;

+

+				/* get active panel thread */

+				if (panel->thread_list.next != RT_NULL)

+				{

+					thread = rtgui_list_entry(panel->thread_list.next, struct rtgui_panel_thread, list);

+					if (!rtgui_mouse_monitor_contains_point(&(thread->monitor_list),

+						event->x, event->y) == RT_TRUE)

+					{

+						/* no monitor in this panel */

+						panel = RT_NULL;

+					}

+				}

+			}

+		}

+	}

+	else

+	{

+		win = RT_NULL;

+	}

+

+	/* check old panel or window */

+	if (last_monitor_panel != RT_NULL)

+	{

+		rt_thread_t tid = rtgui_panel_get_active_thread(last_monitor_panel);

+		event->wid = RT_NULL;

+

+		/* send mouse motion event */

+		rtgui_thread_send(tid, &(event->parent), sizeof(struct rtgui_event_mouse));

+	}

+	else if (last_monitor_topwin != RT_NULL)

+	{

+		event->wid = last_monitor_topwin->wid;

+

+		/* send mouse motion event */

+		rtgui_thread_send(last_monitor_topwin->tid, &(event->parent), sizeof(struct rtgui_event_mouse));

+	}

+

+	if (last_monitor_panel != panel)

+	{

+		last_monitor_panel = panel;

+		if (last_monitor_panel != RT_NULL)

+		{

+			rt_thread_t tid = rtgui_panel_get_active_thread(last_monitor_panel);

+			event->wid = RT_NULL;

+

+			/* send mouse motion event */

+			rtgui_thread_send(tid, &(event->parent), sizeof(struct rtgui_event_mouse));

+		}

+	}

+

+	if (last_monitor_topwin != win)

+	{

+		last_monitor_topwin = win;

+		if (last_monitor_topwin != RT_NULL)

+		{

+			event->wid = last_monitor_topwin->wid;

+

+			/* send mouse motion event */

+			rtgui_thread_send(last_monitor_topwin->tid, &(event->parent), sizeof(struct rtgui_event_mouse));

+		}

+	}

+

+	/* move mouse to (x, y) */

+	rtgui_mouse_moveto(event->x, event->y);

+}

+

+void rtgui_server_handle_kbd(struct rtgui_event_kbd* event)

+{

+	struct rtgui_topwin* wnd;

+	struct rtgui_panel* panel;

+

+	/* re-init to server thread */

+	RTGUI_EVENT_KBD_INIT(event);

+

+	/* todo: handle input method and global shortcut */

+

+	/* send to focus window or focus panel */

+	wnd = rtgui_server_focus_topwin;

+	if (wnd != RT_NULL && wnd->flag & WINTITLE_ACTIVATE)

+	{

+		/* send to focus window */

+		event->wid = wnd->wid;

+

+		/* send keyboard event to thread */

+		rtgui_thread_send(wnd->tid, (struct rtgui_event*)event, sizeof(struct rtgui_event_kbd));

+

+		return;

+	}

+

+	panel = rtgui_server_focus_panel;

+	if (panel != RT_NULL)

+	{

+		/* send to focus panel */

+		event->wid = RT_NULL;

+

+		/* send keyboard event to thread */

+		rtgui_thread_send(rtgui_panel_get_active_thread(panel),

+			(struct rtgui_event*)event, sizeof(struct rtgui_event_kbd));

+	}

+}

+

+#ifdef __WIN32__

+#include <windows.h>

+#endif

+

+/**

+ * rtgui server thread's entry

+ */

+static void rtgui_server_entry(void* parameter)

+{

+#ifdef __WIN32__

+	/* set the server thread to highest */

+	HANDLE hCurrentThread = GetCurrentThread();

+	SetThreadPriority(hCurrentThread, THREAD_PRIORITY_HIGHEST);

+#endif

+

+	/* init rtgui server msgq */

+	rt_mq_init(&rtgui_server_mq,

+		"rtgui",

+		&rtgui_server_msg_pool[0],

+		256,

+		sizeof(rtgui_server_msg_pool),

+		RT_IPC_FLAG_FIFO);

+

+	/* register rtgui server thread */

+	rtgui_thread_register(&rtgui_server_thread, &rtgui_server_mq);

+

+	/* init mouse and show */

+	rtgui_mouse_init();

+#ifdef RTGUI_USING_MOUSE_CURSOR

+	rtgui_mouse_show_cursor();

+#endif

+

+	while (1)

+	{

+		/* the buffer uses to receive event */

+		char event_buf[256];

+		struct rtgui_event* event = (struct rtgui_event*)&(event_buf[0]);

+

+		if (rtgui_thread_recv(event, sizeof(event_buf)) == RT_EOK)

+		{

+			/* dispatch event */

+			switch (event->type)

+			{

+			/* panel event */

+			case RTGUI_EVENT_PANEL_ATTACH:

+				/* register an application in panel */

+				rtgui_server_create_application((struct rtgui_event_panel_attach*)event);

+				break;

+

+			case RTGUI_EVENT_PANEL_DETACH:

+				/* unregister an application */

+				rtgui_server_destroy_application((struct rtgui_event_panel_detach*)event);

+				break;

+

+			case RTGUI_EVENT_PANEL_SHOW:

+				/* handle raise an application */

+				rtgui_server_thread_panel_show((struct rtgui_event_panel_show*)event);

+				break;

+

+			case RTGUI_EVENT_PANEL_HIDE:

+				/* handle hide an application */

+				rtgui_server_thread_panel_hide((struct rtgui_event_panel_hide*)event);

+				break;

+

+			case RTGUI_EVENT_SET_WM:

+				/* handle set workbench manager event */

+				rtgui_server_handle_set_wm((struct rtgui_event_set_wm*)event);

+				break;

+

+			/* window event */

+			case RTGUI_EVENT_WIN_CREATE:

+				rtgui_thread_ack(event, RTGUI_STATUS_OK);

+				rtgui_topwin_add((struct rtgui_event_win_create*)event);

+				break;

+

+			case RTGUI_EVENT_WIN_DESTROY:

+				if (rtgui_topwin_remove(((struct rtgui_event_win*)event)->wid) == RT_EOK)

+					rtgui_thread_ack(event, RTGUI_STATUS_OK);

+				else

+					rtgui_thread_ack(event, RTGUI_STATUS_ERROR);

+				break;

+

+			case RTGUI_EVENT_WIN_SHOW:

+				rtgui_topwin_show((struct rtgui_event_win*)event);

+				break;

+

+			case RTGUI_EVENT_WIN_HIDE:

+				rtgui_topwin_hide((struct rtgui_event_win*)event);

+				break;

+

+			case RTGUI_EVENT_WIN_MOVE:

+				rtgui_topwin_move((struct rtgui_event_win_move*)event);

+				break;

+

+			case RTGUI_EVENT_WIN_RESIZE:

+				rtgui_topwin_resize(((struct rtgui_event_win_resize*)event)->wid,

+					&(((struct rtgui_event_win_resize*)event)->rect));

+				break;

+

+			/* other event */

+			case RTGUI_EVENT_UPDATE_BEGIN:

+#ifdef RTGUI_USING_MOUSE_CURSOR

+				/* hide cursor */

+				rtgui_mouse_hide_cursor();

+#endif

+				break;

+

+			case RTGUI_EVENT_UPDATE_END:

+				/* handle screen update */

+				rtgui_server_handle_update((struct rtgui_event_update_end*)event);

+#ifdef RTGUI_USING_MOUSE_CURSOR

+				/* show cursor */

+				rtgui_mouse_show_cursor();

+#endif

+				break;

+

+			case RTGUI_EVENT_MONITOR_ADD:

+				/* handle mouse monitor */

+				rtgui_server_handle_monitor_add((struct rtgui_event_monitor*)event);

+				break;

+

+			/* mouse and keyboard event */

+			case RTGUI_EVENT_MOUSE_MOTION:

+				/* handle mouse motion event */

+				rtgui_server_handle_mouse_motion((struct rtgui_event_mouse*)event);

+				break;

+

+			case RTGUI_EVENT_MOUSE_BUTTON:

+				/* handle mouse button */

+				rtgui_server_handle_mouse_btn((struct rtgui_event_mouse*)event);

+				break;

+

+			case RTGUI_EVENT_KBD:

+				/* handle keyboard event */

+				rtgui_server_handle_kbd((struct rtgui_event_kbd*)event);

+				break;

+

+			case RTGUI_EVENT_COMMAND:

+				break;

+			}

+		}

+	}

+

+	/* unregister in rtgui thread */

+	// rtgui_thread_deregister(rt_thread_self());

+}

+

+void rtgui_server_post_event(struct rtgui_event* event, rt_size_t size)

+{

+	rt_mq_send(&rtgui_server_mq, event, size);

+}

+

+void rtgui_server_init()

+{

+	rt_thread_init(&rtgui_server_thread,

+		"rtgui",

+		rtgui_server_entry, RT_NULL,

+		&rtgui_server_stack[0], sizeof(rtgui_server_stack),

+		RTGUI_SVR_THREAD_PRIORITY,

+		RTGUI_SVR_THREAD_TIMESLICE);

+

+	/* start rtgui server thread */

+	rt_thread_startup(&rtgui_server_thread);

+}

diff --git a/rtgui/widgets/widget.c b/rtgui/widgets/widget.c
new file mode 100644
index 0000000000..4363baf1c1
--- /dev/null
+++ b/rtgui/widgets/widget.c
@@ -0,0 +1,497 @@
+/*
+ * File      : widget.c
+ * This file is part of RTGUI in 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-04     Bernard      first version
+ */
+#include <rtgui/widgets/widget.h>
+#include <rtgui/widgets/window.h>
+#include <rtgui/widgets/view.h>
+
+static void _rtgui_widget_constructor(rtgui_widget_t *widget)
+{
+   if (!widget) return;
+
+	/* set default flag */
+	widget->flag = RTGUI_WIDGET_FLAG_DEFAULT;
+
+	/* init list */
+	rtgui_list_init(&(widget->sibling));
+
+	/* init gc */
+	widget->gc.foreground = default_foreground;
+	widget->gc.background = default_background;
+	widget->gc.font = rtgui_font_default();
+	widget->gc.textalign = RTGUI_ALIGN_LEFT | RTGUI_ALIGN_TOP;
+	widget->align = RTGUI_ALIGN_LEFT | RTGUI_ALIGN_TOP;
+
+	/* set parent and toplevel root */
+	widget->parent			= RT_NULL;
+	widget->toplevel		= RT_NULL;
+
+	/* some common event handler */
+	widget->on_draw 		= RT_NULL;
+	widget->on_focus_in		= RT_NULL;
+	widget->on_focus_out	= RT_NULL;
+	widget->on_mouseclick 	= RT_NULL;
+	widget->on_key 			= RT_NULL;
+	widget->on_size 		= RT_NULL;
+	widget->on_command 		= RT_NULL;
+
+	/* set default event handler */
+	widget->event_handler = rtgui_widget_event_handler;
+
+	/* does not set widget extent and only set clip_sync to zero */
+	rtgui_region_init(&(widget->clip));
+	widget->clip_sync = 0;
+}
+
+/* Destroys the widget */
+static void _rtgui_widget_destructor(rtgui_widget_t *widget)
+{
+	if (widget == RT_NULL) return;
+
+	if (widget->parent != RT_NULL)
+	{
+		/* remove widget from parent's children list */
+		rtgui_list_remove(&(RTGUI_CONTAINER(widget->parent)->children), &(widget->sibling));
+
+		widget->parent = RT_NULL;
+	}
+
+	/* fini clip region */
+	rtgui_region_fini(&(widget->clip));
+	widget->clip_sync = 0;
+}
+
+rtgui_type_t *rtgui_widget_type_get(void)
+{
+	static rtgui_type_t *widget_type = RT_NULL;
+
+	if (!widget_type)
+	{
+		widget_type = rtgui_type_create("rtgui_widget", RTGUI_OBJECT_TYPE,
+			sizeof(rtgui_widget_t), RTGUI_CONSTRUCTOR(_rtgui_widget_constructor),
+			RTGUI_DESTRUCTOR(_rtgui_widget_destructor));
+	}
+
+	return widget_type;
+}
+
+rtgui_widget_t *rtgui_widget_create(rtgui_type_t *widget_type)
+{
+	struct rtgui_widget* widget;
+
+	widget = RTGUI_WIDGET(rtgui_object_create(widget_type));
+
+	return widget;
+}
+
+void rtgui_widget_destroy(rtgui_widget_t* widget)
+{
+	rtgui_object_destroy(RTGUI_OBJECT(widget));
+}
+
+void rtgui_widget_set_rect(rtgui_widget_t* widget, rtgui_rect_t* rect)
+{
+	if (widget == RT_NULL || rect == RT_NULL) return;
+
+	widget->extent = *rect;

+

+	/* reset mini width and height */

+	widget->mini_width  = rtgui_rect_width(widget->extent);

+	widget->mini_height = rtgui_rect_height(widget->extent);
+
+	/* it's not empty, fini it */
+	if (rtgui_region_not_empty(&(widget->clip)))
+	{
+		rtgui_region_fini(&(widget->clip));
+	}
+
+	/* reset clip info */
+	rtgui_region_init_with_extents(&(widget->clip), rect);
+}
+
+void rtgui_widget_set_miniwidth(rtgui_widget_t* widget, int width)
+{
+	RT_ASSERT(widget != RT_NULL);
+
+	widget->mini_width = width;
+}
+
+void rtgui_widget_set_miniheight(rtgui_widget_t* widget, int height)
+{
+	RT_ASSERT(widget != RT_NULL);
+
+	widget->mini_height = height;
+}
+
+/*
+ * This function moves widget and its children to a logic point
+ */
+void rtgui_widget_move_to_logic(rtgui_widget_t* widget, int dx, int dy)
+{
+	struct rtgui_list_node* node;
+	rtgui_widget_t* child;
+
+	if (widget == RT_NULL) return;
+
+	rtgui_rect_moveto(&(widget->extent), dx, dy);
+
+	/* move each child */
+	if (RTGUI_IS_CONTAINER(widget))
+	{
+		rtgui_list_foreach(node, &(RTGUI_CONTAINER(widget)->children))
+		{
+			child = rtgui_list_entry(node, rtgui_widget_t, sibling);
+
+			rtgui_widget_move_to_logic(child, dx, dy);
+		}
+	}
+}
+
+void rtgui_widget_set_event_handler(rtgui_widget_t* widget, rtgui_event_handler_ptr handler)
+{
+	RT_ASSERT(widget != RT_NULL);
+
+	widget->event_handler = handler;
+}
+
+void rtgui_widget_get_rect(rtgui_widget_t* widget, rtgui_rect_t *rect)
+{
+	RT_ASSERT(widget != RT_NULL);
+
+	if (rect != RT_NULL)
+	{
+		rect->x1 = rect->y1 = 0;
+		rect->x2 = widget->extent.x2 - widget->extent.x1;
+		rect->y2 = widget->extent.y2 - widget->extent.y1;
+	}
+}
+
+void rtgui_widget_set_ondraw(rtgui_widget_t* widget, rtgui_event_handler_ptr handler)
+{
+	RT_ASSERT(widget != RT_NULL);
+
+	widget->on_draw = handler;
+}
+
+void rtgui_widget_set_onfocus(rtgui_widget_t* widget, rtgui_event_handler_ptr handler)
+{
+	RT_ASSERT(widget != RT_NULL);
+
+	widget->on_focus_in = handler;
+}
+
+void rtgui_widget_set_onunfocus(rtgui_widget_t* widget, rtgui_event_handler_ptr handler)
+{
+	RT_ASSERT(widget != RT_NULL);
+
+	widget->on_focus_out = handler;
+}
+
+void rtgui_widget_set_onmouseclick(rtgui_widget_t* widget, rtgui_event_handler_ptr handler)
+{
+	RT_ASSERT(widget != RT_NULL);
+
+	widget->on_mouseclick = handler;
+}
+
+void rtgui_widget_set_onkey(rtgui_widget_t* widget, rtgui_event_handler_ptr handler)
+{
+	RT_ASSERT(widget != RT_NULL);
+
+	widget->on_key = handler;
+}
+
+void rtgui_widget_set_onsize(rtgui_widget_t* widget, rtgui_event_handler_ptr handler)
+{
+	RT_ASSERT(widget != RT_NULL);
+
+	widget->on_size = handler;
+}
+
+void rtgui_widget_set_oncommand(rtgui_widget_t* widget, rtgui_event_handler_ptr handler)
+{
+	RT_ASSERT(widget != RT_NULL);
+
+	widget->on_command = handler;
+}
+
+/**
+ * @brief Focuses the widget. The focused widget is the one which receives the keyboard events
+ * @param widget a widget
+ * @note The widget has to be attached to a toplevel widget, otherwise it will have no effect
+ */
+void rtgui_widget_focus(rtgui_widget_t *widget)
+{
+   rtgui_widget_t *focused;
+
+	if (!widget || !widget->toplevel || !RTGUI_WIDGET_IS_FOCUSABLE(widget) || !RTGUI_WIDGET_IS_ENABLE(widget))
+		return;
+
+	focused = rtgui_toplevel_get_focus(RTGUI_TOPLEVEL(widget->toplevel));
+
+	if ( focused != RT_NULL && widget == focused)
+		return;
+
+	if (focused != RT_NULL)
+	{
+		rtgui_widget_unfocus(focused);
+	}
+
+	rtgui_toplevel_set_focus(RTGUI_TOPLEVEL(widget->toplevel), widget);
+	widget->flag |= RTGUI_WIDGET_FLAG_FOCUS;
+
+	if (widget->on_focus_in)
+   		widget->on_focus_in(widget, RT_NULL);
+}
+
+/**
+ * @brief Unfocused the widget
+ * @param widget a widget
+ */
+void rtgui_widget_unfocus(rtgui_widget_t *widget)
+{
+	if (!widget || !widget->toplevel || !RTGUI_WIDGET_IS_FOCUS(widget))
+		return;
+
+	if (rtgui_toplevel_get_focus(RTGUI_TOPLEVEL(widget->toplevel)) == widget)
+	{
+		rtgui_toplevel_set_focus(RTGUI_TOPLEVEL(widget->toplevel), RT_NULL);
+	}
+
+	widget->flag &= ~RTGUI_WIDGET_FLAG_FOCUS;
+
+	if (widget->on_focus_out)
+   		widget->on_focus_out(widget, RT_NULL);
+}
+
+void rtgui_widget_point_to_device(rtgui_widget_t* widget, rtgui_point_t* point)
+{
+	RT_ASSERT(widget != RT_NULL);
+
+	if (point != RT_NULL)
+	{
+		point->x += widget->extent.x1;
+		point->y += widget->extent.y1;
+	}
+}
+
+void rtgui_widget_rect_to_device(rtgui_widget_t* widget, rtgui_rect_t* rect)
+{
+	RT_ASSERT(widget != RT_NULL);
+
+	if (rect != RT_NULL)
+	{
+		rect->x1 += widget->extent.x1;
+		rect->x2 += widget->extent.x1;
+
+		rect->y1 += widget->extent.y1;
+		rect->y2 += widget->extent.y1;
+	}
+}
+
+void rtgui_widget_point_to_logic(rtgui_widget_t* widget, rtgui_point_t* point)
+{
+	RT_ASSERT(widget != RT_NULL);
+
+	if (point != RT_NULL)
+	{
+		point->x -= widget->extent.x1;
+		point->y -= widget->extent.y1;
+	}
+}
+
+void rtgui_widget_rect_to_logic(rtgui_widget_t* widget, rtgui_rect_t* rect)
+{
+	RT_ASSERT(widget != RT_NULL);
+
+	if (rect != RT_NULL)
+	{
+		rect->x1 -= widget->extent.x1;
+		rect->x2 -= widget->extent.x1;
+
+		rect->y1 -= widget->extent.y1;
+		rect->y2 -= widget->extent.y1;
+	}
+}
+
+rtgui_widget_t* rtgui_widget_get_toplevel(rtgui_widget_t* widget)
+{
+	rtgui_widget_t* r;
+
+	RT_ASSERT(widget != RT_NULL);
+
+	if (widget->toplevel) return widget->toplevel;
+
+	r = widget;
+	/* get the toplevel widget */
+	while (r->parent != RT_NULL) r = r->parent;
+
+	/* set toplevel */
+	widget->toplevel = r;
+
+	return r;
+}
+
+rt_bool_t rtgui_widget_event_handler(rtgui_widget_t* widget, rtgui_event_t* event)
+{
+	switch (event->type)
+	{
+	case RTGUI_EVENT_PAINT:
+		if (widget->on_draw != RT_NULL) return widget->on_draw(widget, event);
+		break;
+
+	case RTGUI_EVENT_KBD:
+		if (widget->on_key != RT_NULL) return widget->on_key(widget, event);
+		break;
+
+	case RTGUI_EVENT_MOUSE_BUTTON:
+		if (widget->on_mouseclick != RT_NULL) return widget->on_mouseclick(widget, event);
+		break;
+
+	case RTGUI_EVENT_COMMAND:
+		if (widget->on_command != RT_NULL) return widget->on_command(widget, event);
+		break;
+
+	case RTGUI_EVENT_RESIZE:
+		if (widget->on_size != RT_NULL) return widget->on_size(widget, event);
+		break;
+	}
+
+	return RT_FALSE;
+}
+
+/*
+ * This function updates the clip info of widget
+ */
+void rtgui_widget_update_clip(rtgui_widget_t* widget)
+{
+	struct rtgui_list_node* node;
+	rtgui_widget_t *parent;
+
+	/* no widget or widget is hide, no update clip */
+	if (widget == RT_NULL || RTGUI_WIDGET_IS_HIDE(widget)) return;
+
+	parent = widget->parent;
+	/* if there is no parent, do not update clip (please use toplevel widget API) */
+	if (parent == RT_NULL) return;
+
+	/* increase clip sync */
+	widget->clip_sync ++;
+
+	/* reset clip to extent */
+	rtgui_region_reset(&(widget->clip), &(widget->extent));
+
+	/* limit widget extent in parent extent */
+	rtgui_region_intersect(&(widget->clip), &(widget->clip), &(parent->clip));
+
+	/* get the no transparent parent */
+	while (parent != RT_NULL && parent->flag & RTGUI_WIDGET_FLAG_TRANSPARENT)
+	{
+		parent = parent->parent;
+	}
+
+	if (parent != RT_NULL)
+	{
+		/* subtract widget clip in parent clip */
+		if (!(widget->flag & RTGUI_WIDGET_FLAG_TRANSPARENT))
+		{
+			rtgui_region_subtract_rect(&(parent->clip), &(parent->clip),
+				&(widget->extent));
+		}
+	}
+
+	/*
+	 * note: since the layout widget introduction, the sibling widget will not
+	 * intersect.
+	 */
+
+	/* if it's a container object, update the clip info of children */
+	if (RTGUI_IS_CONTAINER(widget))
+	{
+		rtgui_widget_t* child;
+		rtgui_list_foreach(node, &(RTGUI_CONTAINER(widget)->children))
+		{
+			child = rtgui_list_entry(node, rtgui_widget_t, sibling);
+
+			rtgui_widget_update_clip(child);
+		}
+	}
+}
+
+void rtgui_widget_show(rtgui_widget_t* widget)
+{
+	/* there is no parent or the parent is hide, no show at all */
+	if (widget->parent == RT_NULL ||
+		RTGUI_WIDGET_IS_HIDE(widget->parent)) return;
+
+	/* update the clip info of widget */
+	RTGUI_WIDGET_UNHIDE(widget);
+	rtgui_widget_update_clip(widget);
+}
+
+void rtgui_widget_hide(rtgui_widget_t* widget)
+{
+	/* hide this widget */
+	RTGUI_WIDGET_HIDE(widget);
+
+	/* update the clip info of widget parent */
+	rtgui_widget_update_clip(widget->parent);
+}
+
+void rtgui_widget_update(rtgui_widget_t* widget)
+{
+	struct rtgui_event_paint paint;
+	RTGUI_EVENT_PAINT_INIT(&paint);
+	paint.wid = RT_NULL;
+
+	RT_ASSERT(widget != RT_NULL);
+
+	if (widget->event_handler != RT_NULL)
+	{
+		widget->event_handler(widget, &paint.parent);
+	}
+}
+
+rtgui_widget_t* rtgui_widget_get_next_sibling(rtgui_widget_t* widget)
+{
+	rtgui_widget_t* sibling = RT_NULL;
+
+	if (widget->sibling.next != RT_NULL)
+	{
+		sibling = rtgui_list_entry(widget->sibling.next, rtgui_widget_t, sibling);
+	}
+
+	return sibling;
+}
+
+rtgui_widget_t* rtgui_widget_get_prev_sibling(rtgui_widget_t* widget)
+{
+	struct rtgui_list_node* node;
+	rtgui_widget_t *sibling, *parent;

+
+	node = RT_NULL; sibling = RT_NULL;
+	parent = widget->parent;
+	if (parent != RT_NULL)
+	{
+		rtgui_list_foreach(node, &(RTGUI_CONTAINER(parent)->children))
+		{
+			if (node->next == &(widget->sibling))
+				break;
+		}
+	}
+
+	if (node != RT_NULL)
+		sibling = rtgui_list_entry(node, rtgui_widget_t, sibling);
+
+	return sibling;
+}

diff --git a/rtgui/widgets/window.c b/rtgui/widgets/window.c
new file mode 100644
index 0000000000..d882181e17
--- /dev/null
+++ b/rtgui/widgets/window.c
@@ -0,0 +1,467 @@
+/*

+ * File      : window.c

+ * This file is part of RTGUI in 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-04     Bernard      first version

+ */

+#include <rtgui/dc.h>

+#include <rtgui/color.h>

+#include <rtgui/image.h>

+#include <rtgui/rtgui_system.h>

+
+#include <rtgui/widgets/window.h>

+#include <rtgui/widgets/button.h>

+

+static void _rtgui_win_constructor(rtgui_win_t *win)

+{

+	/* init window attribute */

+	win->on_activate	= RT_NULL;

+	win->on_deactivate	= RT_NULL;

+	win->on_close		= RT_NULL;

+	win->title			= RT_NULL;

+

+	/* set window hide */

+	RTGUI_WIDGET_HIDE(RTGUI_WIDGET(win));

+

+	/* set window style */

+	win->style = RTGUI_WIN_STYLE_DEFAULT;

+	rtgui_widget_set_event_handler(RTGUI_WIDGET(win), rtgui_win_event_handler);

+

+	/* init user data */

+	win->user_data = 0;

+}

+

+static void _rtgui_win_destructor(rtgui_win_t* win)

+{

+	struct rtgui_event_win_destroy edestroy;

+

+	if (RTGUI_TOPLEVEL(win)->server != RT_NULL)

+	{

+		/* destroy in server */

+		RTGUI_EVENT_WIN_DESTROY_INIT(&edestroy);

+		edestroy.wid = win;

+		if (rtgui_thread_send_sync(RTGUI_TOPLEVEL(win)->server, RTGUI_EVENT(&edestroy),

+			sizeof(struct rtgui_event_win_destroy)) != RT_EOK)

+		{

+			return;

+		}

+	}

+

+	/* release field */

+	rtgui_free(win->title);

+}

+

+static rt_bool_t _rtgui_win_create_in_server(rtgui_win_t* win)

+{

+	if (RTGUI_TOPLEVEL(win)->server == RT_NULL)

+	{

+		rt_thread_t server;

+		struct rtgui_event_win_create ecreate;

+		RTGUI_EVENT_WIN_CREATE_INIT(&ecreate);

+

+		/* get server thread id */

+		server = rtgui_thread_get_server();

+		if (server == RT_NULL)

+		{

+			rt_kprintf("RTGUI server is not running...\n");

+			return RT_FALSE;

+		}

+

+		/* send win create event to server */

+		ecreate.wid 	= win;

+		ecreate.extent 	= RTGUI_WIDGET(win)->extent;

+		ecreate.flag 	= win->style;

+		ecreate.mask 	= 0;

+		rt_strncpy((char*)ecreate.title, (char*)win->title, RTGUI_NAME_MAX);

+

+		if (rtgui_thread_send_sync(server, RTGUI_EVENT(&ecreate),

+			sizeof(struct rtgui_event_win_create)) != RT_EOK)

+		{

+			rt_kprintf("create win: %s failed\n", win->title);

+			return RT_FALSE;

+		}

+

+		/* set server */

+		RTGUI_TOPLEVEL(win)->server = server;

+	}

+

+	return RT_TRUE;

+}

+

+rtgui_type_t *rtgui_win_type_get(void)

+{

+	static rtgui_type_t *win_type = RT_NULL;

+

+	if (!win_type)

+	{

+		win_type = rtgui_type_create("win", RTGUI_TOPLEVEL_TYPE,

+			sizeof(rtgui_win_t),

+			RTGUI_CONSTRUCTOR(_rtgui_win_constructor),

+			RTGUI_DESTRUCTOR(_rtgui_win_destructor));

+	}

+

+	return win_type;

+}

+

+rtgui_win_t* rtgui_win_create(const char* title, rtgui_rect_t *rect, rt_uint32_t style)

+{

+	struct rtgui_win* win;

+

+	/* allocate win memory */

+	win = (struct rtgui_win*) rtgui_widget_create (RTGUI_WIN_TYPE);

+	if (win != RT_NULL)

+	{

+		/* 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)

+		{

+			rtgui_widget_destroy(RTGUI_WIDGET(win));

+			return RT_NULL;

+		}

+	}

+

+	return win;

+}

+

+void rtgui_win_destroy(struct rtgui_win* win)

+{

+	rtgui_widget_destroy(RTGUI_WIDGET(win));

+}

+

+void rtgui_win_show(struct rtgui_win* win)

+{

+	RT_ASSERT(win != RT_NULL);

+

+	/* 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;

+	}

+

+	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;

+		}

+

+		/* set window unhidden */

+		RTGUI_WIDGET_UNHIDE(RTGUI_WIDGET(win));

+	}

+	else rtgui_widget_update(RTGUI_WIDGET(win));

+}

+

+void rtgui_win_hiden(struct rtgui_win* win)

+{

+	RT_ASSERT(win != RT_NULL);

+

+	if (!RTGUI_WIDGET_IS_HIDE(RTGUI_WIDGET(win)) &&

+		RTGUI_TOPLEVEL(win)->server != RT_NULL)

+	{

+		/* send hidden message to server */

+		struct rtgui_event_win_hide ehide;

+		RTGUI_EVENT_WIN_HIDE_INIT(&ehide);

+		ehide.wid = win;

+

+		if (rtgui_thread_send_sync(RTGUI_TOPLEVEL(win)->server, RTGUI_EVENT(&ehide),

+			sizeof(struct rtgui_event_win_hide)) != RT_EOK)

+		{

+			rt_kprintf("hide win: %s failed\n", win->title);

+			return;

+		}

+

+		/* set window hide and deactivated */

+		RTGUI_WIDGET_HIDE(RTGUI_WIDGET(win));

+		win->style &= ~RTGUI_WIN_STYLE_ACTIVATE;

+	}

+}

+

+rt_bool_t rtgui_win_is_activated(struct rtgui_win* win)

+{

+	RT_ASSERT(win != RT_NULL);

+

+	return win->style & RTGUI_WIN_STYLE_ACTIVATE;

+}

+

+void rtgui_win_move(struct rtgui_win* win, int x, int y)

+{

+	struct rtgui_event_win_move emove;

+	RTGUI_EVENT_WIN_MOVE_INIT(&emove);

+

+	if (win == RT_NULL) return;

+

+	if (RTGUI_TOPLEVEL(win)->server != RT_NULL)

+	{

+		/* set win hide firstly */

+		RTGUI_WIDGET_HIDE(RTGUI_WIDGET(win));

+

+		emove.wid 	= win;

+		emove.x		= x;

+		emove.y		= y;

+		if (rtgui_thread_send_sync(RTGUI_TOPLEVEL(win)->server, RTGUI_EVENT(&emove),

+			sizeof(struct rtgui_event_win_move)) != RT_EOK)

+		{

+			return;

+		}

+	}

+

+	/* move window to logic position */

+	rtgui_widget_move_to_logic(RTGUI_WIDGET(win),

+		x - RTGUI_WIDGET(win)->extent.x1,

+		y - RTGUI_WIDGET(win)->extent.y1);

+

+	/* set window visible */

+	RTGUI_WIDGET_UNHIDE(RTGUI_WIDGET(win));

+

+	/* update window */

+	// rtgui_widget_update(RTGUI_WIDGET(win));

+	return;

+}

+

+static rt_bool_t rtgui_win_ondraw(struct rtgui_win* win)

+{

+	struct rtgui_dc* dc;

+	struct rtgui_rect rect;

+	struct rtgui_event_paint event;

+

+	/* begin drawing */

+	dc = rtgui_dc_begin_drawing(RTGUI_WIDGET(win));

+	if (dc == RT_NULL) return RT_FALSE;

+

+	/* get window rect */

+	rtgui_widget_get_rect(RTGUI_WIDGET(win), &rect);

+	/* fill area */

+	rtgui_dc_fill_rect(dc, &rect);

+

+	/* paint each widget */

+	RTGUI_EVENT_PAINT_INIT(&event);

+	event.wid = RT_NULL;

+	rtgui_container_dispatch_event(RTGUI_CONTAINER(win), (rtgui_event_t*)&event);

+

+	rtgui_dc_end_drawing(dc);

+

+	return RT_FALSE;

+}

+

+rt_bool_t rtgui_win_event_handler(struct rtgui_widget* widget, struct rtgui_event* event)

+{

+	struct rtgui_win* win = (struct rtgui_win*)widget;

+

+	RT_ASSERT((win != RT_NULL) && (event != RT_NULL));

+

+	switch (event->type)

+	{

+	case RTGUI_EVENT_WIN_SHOW:

+		rtgui_win_show(win);

+		break;

+

+	case RTGUI_EVENT_WIN_HIDE:

+		rtgui_win_hiden(win);

+		break;

+

+	case RTGUI_EVENT_WIN_CLOSE:

+		if (win->on_close != RT_NULL)

+		{

+			if (win->on_close(widget, event) == RT_FALSE) return RT_TRUE;

+		}

+

+		/* destroy window */

+		rtgui_win_destroy(win);

+

+		/* exit event loop */

+		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)))

+		{

+			rt_kprintf("activate window, but window is hide!\n");

+		}

+

+		win->style |= RTGUI_WIN_STYLE_ACTIVATE;

+		if (widget->on_draw != RT_NULL) widget->on_draw(widget, event);

+		else rtgui_win_ondraw(win);

+

+		if (win->on_activate != RT_NULL)

+		{

+			win->on_activate(widget, event);

+		}

+		break;

+

+	case RTGUI_EVENT_WIN_DEACTIVATE:

+		win->style &= ~RTGUI_WIN_STYLE_ACTIVATE;

+		if (widget->on_draw != RT_NULL) widget->on_draw(widget, event);

+		else rtgui_win_ondraw(win);

+

+		if (win->on_deactivate != RT_NULL)

+		{

+			win->on_deactivate(widget, event);

+		}

+		break;

+

+	case RTGUI_EVENT_PAINT:

+		if (widget->on_draw != RT_NULL) widget->on_draw(widget, event);

+		else rtgui_win_ondraw(win);

+		break;

+

+	case RTGUI_EVENT_MOUSE_BUTTON:

+		if (rtgui_container_dispatch_mouse_event(RTGUI_CONTAINER(win), (struct rtgui_event_mouse*)event) == RT_FALSE)

+		{

+			if (widget->on_mouseclick != RT_NULL)

+			{

+				return widget->on_mouseclick(widget, event);

+			}

+		}

+		break;

+

+	case RTGUI_EVENT_MOUSE_MOTION:

+#if 0

+		if (rtgui_widget_dispatch_mouse_event(widget,

+			(struct rtgui_event_mouse*)event) == RT_FALSE)

+		{

+			/* handle event in current widget */

+			if (widget->on_mousemotion != RT_NULL)

+			{

+				return widget->on_mousemotion(widget, event);

+			}

+		}

+		else return RT_TRUE;

+#endif

+		break;

+

+	default:

+		/* call parent event handler */

+		return rtgui_toplevel_event_handler(widget, event);

+	}

+

+	return RT_FALSE;

+}

+

+/* windows event loop */

+void rtgui_win_event_loop(rtgui_win_t* wnd)

+{

+	int quit = 0;

+

+	/* the buffer uses to receive event */

+	char event_buf[256];

+

+	struct rtgui_event* event = (struct rtgui_event*)&event_buf[0];

+

+	while (!quit)

+	{

+		if (rtgui_thread_recv(event, sizeof(event_buf)) == RT_EOK)

+		{

+			if (RTGUI_WIDGET(wnd)->event_handler != RT_NULL)

+			{

+				if (RTGUI_WIDGET(wnd)->event_handler(RTGUI_WIDGET(wnd), event) == RT_TRUE)

+					quit = 1;

+			}

+		}

+	}

+}

+

+void rtgui_win_set_rect(rtgui_win_t* win, rtgui_rect_t* rect)

+{

+	struct rtgui_event_win_resize event;

+

+	if (win == RT_NULL || rect == RT_NULL) return;

+

+	RTGUI_WIDGET(win)->extent = *rect;

+

+	if (RTGUI_TOPLEVEL(win)->server != RT_NULL)

+	{

+		/* set window resize event to server */

+		RTGUI_EVENT_WIN_RESIZE_INIT(&event);

+		event.wid = win;

+		event.rect = *rect;

+

+		rtgui_thread_send(RTGUI_TOPLEVEL(win)->server, &(event.parent), sizeof(struct rtgui_event_win_resize));

+	}

+}

+

+void rtgui_win_set_box(rtgui_win_t* win, rtgui_box_t* box)

+{

+	if (win == RT_NULL || box == RT_NULL) return;

+

+	rtgui_container_add_child(RTGUI_CONTAINER(win), RTGUI_WIDGET(box));

+	rtgui_widget_set_rect(RTGUI_WIDGET(box), &(RTGUI_WIDGET(win)->extent));

+}

+

+void rtgui_win_set_onactivate(rtgui_win_t* win, rtgui_event_handler_ptr handler)

+{

+	if (win != RT_NULL)

+	{

+		win->on_activate = handler;

+	}

+}

+

+void rtgui_win_set_ondeactivate(rtgui_win_t* win, rtgui_event_handler_ptr handler)

+{

+	if (win != RT_NULL)

+	{

+		win->on_deactivate = handler;

+	}

+}

+

+void rtgui_win_set_onclose(rtgui_win_t* win, rtgui_event_handler_ptr handler)

+{

+	if (win != RT_NULL)

+	{

+		win->on_close = handler;

+	}

+}

+

+void rtgui_win_set_title(rtgui_win_t* win, const char *title)

+{

+	/* send title to server */

+	if (RTGUI_TOPLEVEL(win)->server != RT_NULL)

+	{

+	}

+

+	/* modify in local side */

+	if (win->title != RT_NULL)

+	{

+		rtgui_free(win->title);

+		win->title = RT_NULL;

+	}

+

+	if (title != RT_NULL)

+	{

+		win->title = rt_strdup(title);

+	}

+}

+

+char* rtgui_win_get_title(rtgui_win_t* win)

+{

+	RT_ASSERT(win != RT_NULL);

+

+	return win->title;

+}

diff --git a/rtgui/widgets/workbench.c b/rtgui/widgets/workbench.c
new file mode 100644
index 0000000000..795b1378eb
--- /dev/null
+++ b/rtgui/widgets/workbench.c
@@ -0,0 +1,472 @@
+/*
+ * File      : workbench.c
+ * This file is part of RTGUI in 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-04     Bernard      first version
+ */
+#include <rtgui/rtgui_system.h>
+#include <rtgui/widgets/window.h>

+#include <rtgui/widgets/workbench.h>

+

+static void _rtgui_workbench_constructor(rtgui_workbench_t *workbench)

+{

+	/* set event handler */

+	rtgui_widget_set_event_handler(RTGUI_WIDGET(workbench), rtgui_workbench_event_handler);

+

+	/* set attributes */

+	workbench->panel = RT_NULL;

+	workbench->flag = RTGUI_WORKBENCH_FLAG_DEFAULT;

+}

+

+static void _rtgui_workbench_destructor(rtgui_workbench_t *workbench)

+{

+	RT_ASSERT(workbench != RT_NULL);

+

+	if (RTGUI_TOPLEVEL(workbench)->server != RT_NULL)

+	{

+		struct rtgui_event_panel_detach edetach;

+		RTGUI_EVENT_PANEL_DETACH_INIT(&edetach);

+

+		/* detach from panel */

+		edetach.panel = workbench->panel;

+

+		/* send PANEL DETACH to server */

+		if (rtgui_thread_send_sync(RTGUI_TOPLEVEL(workbench)->server,

+			RTGUI_EVENT(&edetach), sizeof(struct rtgui_event_panel_detach)) != RT_EOK)

+			return;

+

+		RTGUI_TOPLEVEL(workbench)->server = RT_NULL;

+	}

+

+	/* release title */

+	if (workbench->title != RT_NULL)

+	{

+		rtgui_free(workbench->title);

+	}

+}

+

+rtgui_type_t *rtgui_workbench_type_get(void)

+{

+	static rtgui_type_t *workbench_type = RT_NULL;

+

+	if (!workbench_type)

+	{

+		workbench_type = rtgui_type_create("workbench", RTGUI_TOPLEVEL_TYPE,

+			sizeof(rtgui_workbench_t),

+			RTGUI_CONSTRUCTOR(_rtgui_workbench_constructor),

+			RTGUI_DESTRUCTOR(_rtgui_workbench_destructor));

+	}

+

+	return workbench_type;

+}

+

+rtgui_workbench_t *rtgui_workbench_create(const char* panel_name, const unsigned char* title)

+{

+	struct rtgui_workbench* workbench;

+

+	/* the server thread id */

+	rt_thread_t server = rtgui_thread_get_server();

+	if (server == RT_NULL)

+	{

+		rt_kprintf("can't find rtgui server\n");

+		return RT_NULL;

+	}

+

+	/* create workbench */

+	workbench = (rtgui_workbench_t*) rtgui_widget_create (RTGUI_WORKBENCH_TYPE);

+	if (workbench != RT_NULL)

+	{

+		/* the buffer uses to receive event */

+		union

+		{

+			struct rtgui_event_panel_attach ecreate;

+			struct rtgui_event_panel_info epanel;

+

+			char buffer[256];	/* use to recv other information */

+		} event;

+

+		/* set workbench title */

+		workbench->title = (unsigned char*)rt_strdup((char*)title);

+

+		/* create application in server */

+		RTGUI_EVENT_PANEL_ATTACH_INIT(&(event.ecreate));

+

+		/* set the panel name and workbench */

+		rt_strncpy(event.ecreate.panel_name, panel_name, RTGUI_NAME_MAX);

+		event.ecreate.workbench = workbench;

+

+		/* send PANEL ATTACH to server */

+		if (rtgui_thread_send_sync(server,

+			&(event.ecreate.parent), sizeof(struct rtgui_event_panel_attach)) != RTGUI_STATUS_OK)

+		{

+			return RT_NULL;

+		}

+

+		/* get PANEL INFO */

+		rtgui_thread_recv_filter(RTGUI_EVENT_PANEL_INFO, &(event.epanel.parent), sizeof(event));

+

+		/* set panel */

+		workbench->panel = (struct rtgui_panel*)event.epanel.panel;

+

+		/* connected */

+		RTGUI_TOPLEVEL(workbench)->server = server;

+

+		/* set extent of workbench */

+		rtgui_widget_set_rect(RTGUI_WIDGET(workbench), &(event.epanel.extent));

+

+		/* set workbench in thread */

+		rtgui_thread_set_widget(RTGUI_WIDGET(workbench));

+	}

+

+	return workbench;

+}

+

+void rtgui_workbench_destroy(rtgui_workbench_t* workbench)

+{

+	RT_ASSERT(workbench != RT_NULL);

+

+	if (RTGUI_TOPLEVEL(workbench)->server != RT_NULL)

+	{

+		struct rtgui_event_panel_detach edetach;

+		RTGUI_EVENT_PANEL_DETACH_INIT(&edetach);

+

+		/* detach from panel */

+		edetach.panel = workbench->panel;

+

+		/* send PANEL DETACH to server */

+		if (rtgui_thread_send_sync(RTGUI_TOPLEVEL(workbench)->server,

+			RTGUI_EVENT(&edetach), sizeof(struct rtgui_event_panel_detach)) != RT_EOK)

+			return;

+

+			RTGUI_TOPLEVEL(workbench)->server = RT_NULL;

+	}

+

+	rtgui_widget_destroy(RTGUI_WIDGET(workbench));

+}

+

+void rtgui_workbench_set_flag(rtgui_workbench_t* workbench, rt_uint8_t flag)

+{

+	RT_ASSERT(workbench != RT_NULL);

+

+	workbench->flag = flag;

+}

+

+rtgui_view_t *rtgui_workbench_get_current_view(rtgui_workbench_t * workbench)

+{

+	struct rtgui_list_node* node;

+	struct rtgui_widget* view;

+

+	RT_ASSERT(workbench != RT_NULL);

+

+	/* find the first shown view */

+	rtgui_list_foreach(node, &(RTGUI_CONTAINER(workbench)->children))

+	{

+		view = rtgui_list_entry(node, struct rtgui_widget, sibling);

+

+		/* is it a shown view? */

+		if (!RTGUI_WIDGET_IS_HIDE(view))

+		{

+			return (rtgui_view_t*)view;

+		}

+	}

+

+	return RT_NULL;

+}

+

+void rtgui_workbench_event_loop(rtgui_workbench_t* workbench)

+{

+	int quit = 0;

+

+	/* the buffer uses to receive event */

+	char event_buf[256];

+	struct rtgui_event* event = (struct rtgui_event*)&event_buf[0];

+

+	/* show workbench firstly */

+	rtgui_workbench_show(workbench);

+

+	while (!quit)

+	{

+		if (rtgui_thread_recv(event, sizeof(event_buf)) == RT_EOK)

+		{

+			RTGUI_WIDGET(workbench)->event_handler(RTGUI_WIDGET(workbench), event);

+		}

+	}

+}

+

+rt_err_t rtgui_workbench_show(rtgui_workbench_t* workbench)

+{

+	RT_ASSERT(workbench != RT_NULL);

+

+	if (RTGUI_TOPLEVEL(workbench)->server != RT_NULL)

+	{

+		struct rtgui_event_panel_show eraise;

+		RTGUI_EVENT_PANEL_SHOW_INIT(&eraise);

+		eraise.workbench = workbench;

+

+		eraise.panel = workbench->panel;

+		if (rtgui_thread_send_sync(workbench->parent.server, RTGUI_EVENT(&eraise),

+			sizeof(struct rtgui_event_panel_show)) != RT_EOK)

+			return -RT_ERROR;

+

+		RTGUI_WIDGET_UNHIDE(RTGUI_WIDGET(workbench));

+		rtgui_toplevel_update_clip(RTGUI_TOPLEVEL(workbench));

+	}

+	else return -RT_ERROR;

+

+	return RT_EOK;

+}

+

+rt_err_t rtgui_workbench_hide(rtgui_workbench_t* workbench)

+{

+	if (RTGUI_TOPLEVEL(workbench)->server != RT_NULL)

+	{

+		struct rtgui_event_panel_hide ehide;

+		RTGUI_EVENT_PANEL_HIDE_INIT(&ehide);

+

+		RT_ASSERT(workbench != RT_NULL);

+		if (workbench->parent.server == RT_NULL) return -RT_ERROR;

+

+		ehide.panel = workbench->panel;

+		if (rtgui_thread_send_sync(RTGUI_TOPLEVEL(workbench)->server, RTGUI_EVENT(&ehide),

+			sizeof(struct rtgui_event_panel_hide)) != RT_EOK)

+			return -RT_ERROR;

+

+		RTGUI_WIDGET_HIDE(RTGUI_WIDGET(workbench));

+		rtgui_toplevel_update_clip(RTGUI_TOPLEVEL(workbench));

+	}

+

+	return RT_EOK;

+}

+

+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 = rtgui_workbench_get_current_view(workbench);

+				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

+			{

+				/* let viewer to handle it */

+				rtgui_view_t* view = rtgui_workbench_get_current_view(workbench);

+				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

+			{

+				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;

+

+				/* paint a view */

+				view = rtgui_workbench_get_current_view(workbench);

+				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);

+					}

+				}

+			}

+		}

+		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;

+}

+

+void rtgui_workbench_add_view(rtgui_workbench_t* workbench, rtgui_view_t* view)

+{

+	rtgui_container_add_child(RTGUI_CONTAINER(workbench), RTGUI_WIDGET(view));

+

+	/* reset view extent */

+	rtgui_widget_set_rect(RTGUI_WIDGET(view), &(RTGUI_WIDGET(workbench)->extent));

+}

+

+void rtgui_workbench_remove_view(rtgui_workbench_t* workbench, rtgui_view_t* view)

+{

+	rtgui_container_remove_child(RTGUI_CONTAINER(workbench), RTGUI_WIDGET(view));

+}

+

+void rtgui_workbench_show_view(rtgui_workbench_t* workbench, rtgui_view_t* view)

+{

+	RT_ASSERT(workbench != RT_NULL);

+	RT_ASSERT(view != RT_NULL);

+

+	if (rtgui_workbench_get_current_view(workbench) == view &&

+		!RTGUI_WIDGET_IS_HIDE(RTGUI_WIDGET(view))) return;

+

+	/* remove from child list */

+	rtgui_list_remove(&(RTGUI_CONTAINER(workbench)->children), &(RTGUI_WIDGET(view)->sibling));

+

+	/* insert to the head of child list */

+	rtgui_list_insert(&(RTGUI_CONTAINER(workbench)->children), &(RTGUI_WIDGET(view)->sibling));

+

+	/* show view */

+	RTGUI_WIDGET_UNHIDE(RTGUI_WIDGET(view));

+

+	/* update workbench clip */

+	rtgui_toplevel_update_clip(RTGUI_TOPLEVEL(workbench));

+

+	if (!RTGUI_WIDGET_IS_HIDE(RTGUI_WIDGET(workbench)))

+	{

+		rtgui_widget_update(RTGUI_WIDGET(view));

+	}

+}

+

+void rtgui_workbench_hide_view(rtgui_workbench_t* workbench, rtgui_view_t* view)

+{

+	RT_ASSERT(workbench != RT_NULL);

+	RT_ASSERT(view != RT_NULL);

+

+	/* remove from child list */

+	rtgui_list_remove(&(RTGUI_CONTAINER(workbench)->children), &(RTGUI_WIDGET(view)->sibling));

+

+	/* append to the end of child list */

+	rtgui_list_append(&(RTGUI_CONTAINER(workbench)->children), &(RTGUI_WIDGET(view)->sibling));

+

+	/* hide view */

+	RTGUI_WIDGET_HIDE(RTGUI_WIDGET(view));

+

+	/* update workbench clip */

+	rtgui_toplevel_update_clip(RTGUI_TOPLEVEL(workbench));

+

+	if (!RTGUI_WIDGET_IS_HIDE(RTGUI_WIDGET(workbench)))

+	{

+		view = rtgui_workbench_get_current_view(workbench);

+		rtgui_widget_update(RTGUI_WIDGET(view));

+	}

+}