sync RTGUI with github(https://github.com/RT-Thread/RTGUI) 126336387561442a0508b661595134deb28ad34b

As always, full log is in GitHub.

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

9 files changed, 282 insertions, 118 deletions

diff --git a/components/rtgui/common/dc.c b/components/rtgui/common/dc.c
index 1de54318a5..b9834312ae 100644
--- a/components/rtgui/common/dc.c
+++ b/components/rtgui/common/dc.c
@@ -38,6 +38,7 @@ void rtgui_dc_destory(struct rtgui_dc* dc)
 	dc->engine->fini(dc);
 	rtgui_free(dc);
 }
+RTM_EXPORT(rtgui_dc_destory);
 
 void rtgui_dc_draw_line (struct rtgui_dc* dc, int x1, int y1, int x2, int y2)
 {
@@ -106,6 +107,7 @@ void rtgui_dc_draw_line (struct rtgui_dc* dc, int x1, int y1, int x2, int y2)
 		}
 	}
 }
+RTM_EXPORT(rtgui_dc_draw_line);
 
 void rtgui_dc_draw_horizontal_line(struct rtgui_dc* dc, int x1, int x2, int y)
 {
@@ -127,6 +129,7 @@ void rtgui_dc_draw_horizontal_line(struct rtgui_dc* dc, int x1, int x2, int y)
 	/* restore color */
 	RTGUI_DC_FC(dc) = color;
 }
+RTM_EXPORT(rtgui_dc_draw_horizontal_line);
 
 void rtgui_dc_draw_vertical_line(struct rtgui_dc* dc, int x, int y1, int y2)
 {
@@ -148,6 +151,7 @@ void rtgui_dc_draw_vertical_line(struct rtgui_dc* dc, int x, int y1, int y2)
 	/* restore color */
 	RTGUI_DC_FC(dc) = color;
 }
+RTM_EXPORT(rtgui_dc_draw_vertical_line);
 
 void rtgui_dc_draw_rect (struct rtgui_dc* dc, struct rtgui_rect* rect)
 {
@@ -157,6 +161,7 @@ void rtgui_dc_draw_rect (struct rtgui_dc* dc, struct rtgui_rect* rect)
 	rtgui_dc_draw_vline(dc, rect->x1, rect->y1, rect->y2);
 	rtgui_dc_draw_vline(dc, rect->x2 - 1, rect->y1, rect->y2);
 }
+RTM_EXPORT(rtgui_dc_draw_rect);
 
 void rtgui_dc_fill_rect_forecolor(struct rtgui_dc* dc, struct rtgui_rect* rect)
 {
@@ -169,6 +174,7 @@ void rtgui_dc_fill_rect_forecolor(struct rtgui_dc* dc, struct rtgui_rect* rect)
 		i++;
     }while(!(rect->y1+i == rect->y2));
 }
+RTM_EXPORT(rtgui_dc_fill_rect_forecolor);
 
 void rtgui_dc_draw_round_rect(struct rtgui_dc* dc, struct rtgui_rect* rect, int r)
 {
@@ -198,6 +204,7 @@ void rtgui_dc_draw_round_rect(struct rtgui_dc* dc, struct rtgui_rect* rect, int
     	rtgui_dc_draw_vline(dc, rect->x2, rect->y1 + r, rect->y2 - r);
     }
 }
+RTM_EXPORT(rtgui_dc_draw_round_rect);
 
 void rtgui_dc_fill_round_rect(struct rtgui_dc* dc, struct rtgui_rect* rect, int r)
 {
@@ -231,6 +238,7 @@ void rtgui_dc_fill_round_rect(struct rtgui_dc* dc, struct rtgui_rect* rect, int
 		rtgui_dc_fill_circle(dc, rect->x1 + r, rect->y2 - r, r); 
 	}
 }
+RTM_EXPORT(rtgui_dc_fill_round_rect);
 
 void rtgui_dc_draw_shaded_rect(struct rtgui_dc* dc, rtgui_rect_t* rect,
 							   rtgui_color_t c1, rtgui_color_t c2)
@@ -245,6 +253,7 @@ void rtgui_dc_draw_shaded_rect(struct rtgui_dc* dc, rtgui_rect_t* rect,
     rtgui_dc_draw_vline(dc, rect->x2 - 1, rect->y1, rect->y2);
     rtgui_dc_draw_hline(dc, rect->x1, rect->x2, rect->y2 - 1);
 }
+RTM_EXPORT(rtgui_dc_draw_shaded_rect);
 
 void rtgui_dc_draw_focus_rect(struct rtgui_dc* dc, rtgui_rect_t* rect)
 {
@@ -266,6 +275,7 @@ void rtgui_dc_draw_focus_rect(struct rtgui_dc* dc, rtgui_rect_t* rect)
 			rtgui_dc_draw_point(dc, rect->x2-1, y);
 	}
 }
+RTM_EXPORT(rtgui_dc_draw_focus_rect);
 
 void rtgui_dc_draw_text (struct rtgui_dc* dc, const char* text, struct rtgui_rect* rect)
 {
@@ -289,6 +299,7 @@ void rtgui_dc_draw_text (struct rtgui_dc* dc, const char* text, struct rtgui_rec
 	len = strlen((const char*)text);
 	rtgui_font_draw(font, dc, text, len, &text_rect);
 }
+RTM_EXPORT(rtgui_dc_draw_text);
 
 void rtgui_dc_draw_text_stroke (struct rtgui_dc* dc, const char* text, struct rtgui_rect* rect,
 	rtgui_color_t color_stroke, rtgui_color_t color_core)
@@ -314,6 +325,7 @@ void rtgui_dc_draw_text_stroke (struct rtgui_dc* dc, const char* text, struct rt
 	rtgui_dc_draw_text(dc, text, rect);
 	RTGUI_DC_FC(dc) = fc;
 }
+RTM_EXPORT(rtgui_dc_draw_text_stroke);
 
 /*
  * draw a monochrome color bitmap data
@@ -332,16 +344,19 @@ void rtgui_dc_draw_mono_bmp(struct rtgui_dc* dc, int x, int y, int w, int h, con
 				if ( ((data[i*w + j] >> (7-k)) & 0x01) != 0)
 					rtgui_dc_draw_point(dc, x + 8*j + k, y + i);
 }
+RTM_EXPORT(rtgui_dc_draw_mono_bmp);
 
 void rtgui_dc_draw_byte(struct rtgui_dc*dc, int x, int y, int h, const rt_uint8_t* data)
 {
 	rtgui_dc_draw_mono_bmp(dc, x, y, 8, h, data);
 }
+RTM_EXPORT(rtgui_dc_draw_byte);
 
 void rtgui_dc_draw_word(struct rtgui_dc*dc, int x, int y, int h, const rt_uint8_t* data)
 {
 	rtgui_dc_draw_mono_bmp(dc, x, y, 16, h, data);
 }
+RTM_EXPORT(rtgui_dc_draw_word);
 
 void rtgui_dc_draw_border(struct rtgui_dc* dc, rtgui_rect_t* rect, int flag)
 {
@@ -395,6 +410,7 @@ void rtgui_dc_draw_border(struct rtgui_dc* dc, rtgui_rect_t* rect, int flag)
 	/* restore color */
 	RTGUI_DC_FC(dc) = color;
 }
+RTM_EXPORT(rtgui_dc_draw_border);
 
 void rtgui_dc_draw_polygon(struct rtgui_dc* dc, const int *vx, const int *vy, int count)
 {
@@ -427,6 +443,7 @@ void rtgui_dc_draw_polygon(struct rtgui_dc* dc, const int *vx, const int *vy, in
 	}
 	rtgui_dc_draw_line(dc, *x1, *y1, *vx, *vy);
 }
+RTM_EXPORT(rtgui_dc_draw_polygon);
 
 void rtgui_dc_draw_regular_polygon(struct rtgui_dc* dc, int x, int y, int r, int count, rt_uint16_t angle)
 {
@@ -474,6 +491,7 @@ void rtgui_dc_draw_regular_polygon(struct rtgui_dc* dc, int x, int y, int r, int
 	rtgui_free(y_head);
 
 }
+RTM_EXPORT(rtgui_dc_draw_regular_polygon);
 
 void rtgui_dc_fill_polygon(struct rtgui_dc* dc, const int* vx, const int* vy, int count)
 {
@@ -556,6 +574,7 @@ void rtgui_dc_fill_polygon(struct rtgui_dc* dc, const int* vx, const int* vy, in
 	/* release memory */
 	rtgui_free(poly_ints);
 }
+RTM_EXPORT(rtgui_dc_fill_polygon);
 
 void rtgui_dc_draw_circle(struct rtgui_dc* dc, int x, int y, int r)
 {
@@ -632,6 +651,7 @@ void rtgui_dc_draw_circle(struct rtgui_dc* dc, int x, int y, int r)
 	    cx++;
 	}while (cx <= cy);
 }
+RTM_EXPORT(rtgui_dc_draw_circle);
 
 void rtgui_dc_fill_circle(struct rtgui_dc* dc, rt_int16_t x, rt_int16_t y, rt_int16_t r)
 {
@@ -707,6 +727,7 @@ void rtgui_dc_fill_circle(struct rtgui_dc* dc, rt_int16_t x, rt_int16_t y, rt_in
 	cx++;
     } while (cx <= cy);
 }
+RTM_EXPORT(rtgui_dc_fill_circle);
 
 void rtgui_dc_draw_arc(struct rtgui_dc *dc, rt_int16_t x, rt_int16_t y, rt_int16_t r, rt_int16_t start, rt_int16_t end)
 {
@@ -926,6 +947,7 @@ void rtgui_dc_draw_arc(struct rtgui_dc *dc, rt_int16_t x, rt_int16_t y, rt_int16
 		cx++;
 	} while (cx <= cy);
 }
+RTM_EXPORT(rtgui_dc_draw_arc);
 
 void rtgui_dc_draw_annulus(struct rtgui_dc *dc, rt_int16_t x, rt_int16_t y, rt_int16_t r1, rt_int16_t r2, rt_int16_t start, rt_int16_t end)
 {
@@ -977,6 +999,7 @@ void rtgui_dc_draw_annulus(struct rtgui_dc *dc, rt_int16_t x, rt_int16_t y, rt_i
 
     rtgui_dc_draw_line(dc, start_x, start_y, end_x, end_y);    
 }
+RTM_EXPORT(rtgui_dc_draw_annulus);
 
 void rtgui_dc_draw_sector(struct rtgui_dc *dc, rt_int16_t x, rt_int16_t y, rt_int16_t r, rt_int16_t start, rt_int16_t end)
 {
@@ -1010,6 +1033,7 @@ void rtgui_dc_draw_sector(struct rtgui_dc *dc, rt_int16_t x, rt_int16_t y, rt_in
     rtgui_dc_draw_line(dc, x, y, start_x, start_y);
     rtgui_dc_draw_line(dc, x, y, end_x, end_y); 
 }
+RTM_EXPORT(rtgui_dc_draw_sector);
 
 void rtgui_dc_fill_sector(struct rtgui_dc *dc, rt_int16_t x, rt_int16_t y, rt_int16_t r, rt_int16_t start, rt_int16_t end)
 {
@@ -1044,6 +1068,7 @@ void rtgui_dc_fill_sector(struct rtgui_dc *dc, rt_int16_t x, rt_int16_t y, rt_in
 	    rtgui_dc_draw_line(dc, x, y, start_x, start_y); 
 	}while(!((start_x == end_x) && (start_y == end_y)));
 }
+RTM_EXPORT(rtgui_dc_fill_sector);
 
 void rtgui_dc_draw_ellipse(struct rtgui_dc* dc, rt_int16_t x, rt_int16_t y, rt_int16_t rx, rt_int16_t ry)
 {
@@ -1192,6 +1217,7 @@ void rtgui_dc_draw_ellipse(struct rtgui_dc* dc, rt_int16_t x, rt_int16_t y, rt_i
 	    } while (i > h);
 	}
 }
+RTM_EXPORT(rtgui_dc_draw_ellipse);
 
 void rtgui_dc_fill_ellipse(struct rtgui_dc *dc, rt_int16_t x, rt_int16_t y, rt_int16_t rx, rt_int16_t ry)
 {
@@ -1300,5 +1326,5 @@ void rtgui_dc_fill_ellipse(struct rtgui_dc *dc, rt_int16_t x, rt_int16_t y, rt_i
 	} while (i > h);
     }
 }
-
+RTM_EXPORT(rtgui_dc_fill_ellipse);
 
diff --git a/components/rtgui/common/dc_client.c b/components/rtgui/common/dc_client.c
index abff12b3a0..0046bc75ad 100644
--- a/components/rtgui/common/dc_client.c
+++ b/components/rtgui/common/dc_client.c
@@ -62,12 +62,14 @@ struct rtgui_dc* rtgui_dc_begin_drawing(rtgui_widget_t* owner)
 
 	return dc;
 }
+RTM_EXPORT(rtgui_dc_begin_drawing);
 
 void rtgui_dc_end_drawing(struct rtgui_dc* dc)
 {
 	dc->engine->fini(dc);
 	rtgui_screen_unlock();
 }
+RTM_EXPORT(rtgui_dc_end_drawing);
 
 const struct rtgui_dc_engine dc_client_engine =
 {
diff --git a/components/rtgui/common/filerw.c b/components/rtgui/common/filerw.c
index dd7ab18f20..5a0390c7c5 100644
--- a/components/rtgui/common/filerw.c
+++ b/components/rtgui/common/filerw.c
@@ -16,7 +16,6 @@
 #include <rtgui/rtgui_system.h>
 
 #ifdef RTGUI_USING_DFS_FILERW
-#include <dfs_posix.h>
 
 /* standard file read/write */
 struct rtgui_filerw_stdio
@@ -95,93 +94,7 @@ static int stdio_close(struct rtgui_filerw *context)
 
 	return -1;
 }
-#elif defined(RTGUI_USING_STDIO_FILERW)
-#include <stdio.h>
 
-/* standard file read/write */
-struct rtgui_filerw_stdio
-{
-	/* inherit from rtgui_filerw */
-	struct rtgui_filerw parent;
-
-	FILE* fp;
-};
-
-static int stdio_seek(struct rtgui_filerw *context, rt_off_t offset, int whence)
-{
-	struct rtgui_filerw_stdio* stdio_filerw = (struct rtgui_filerw_stdio *)context;
-	int stdio_whence[3] = {SEEK_SET, SEEK_CUR, SEEK_END};
-
-	if (whence < RTGUI_FILE_SEEK_SET || whence > RTGUI_FILE_SEEK_END)
-	{
-		return -1;
-	}
-
-	if (fseek(stdio_filerw->fp, offset, stdio_whence[whence]) == 0)
-	{
-		return ftell(stdio_filerw->fp);
-	}
-
-	return -1;
-}
-
-static int stdio_read(struct rtgui_filerw *context, void *ptr, rt_size_t size, rt_size_t maxnum)
-{
-	size_t nread;
-	struct rtgui_filerw_stdio* stdio_filerw = (struct rtgui_filerw_stdio *)context;
-
-	nread = fread(ptr, size, maxnum, stdio_filerw->fp);
-	if (nread == 0 && ferror(stdio_filerw->fp))
-	{
-		return -1;
-	}
-
-	return nread;
-}
-
-static int stdio_write(struct rtgui_filerw *context, const void *ptr, rt_size_t size, rt_size_t num)
-{
-	size_t nwrote;
-	struct rtgui_filerw_stdio* stdio_filerw = (struct rtgui_filerw_stdio *)context;
-
-	nwrote = fwrite(ptr, size, num, stdio_filerw->fp);
-
-	if ( nwrote == 0 && ferror(stdio_filerw->fp) )
-	{
-		return -1;
-	}
-
-	return nwrote;
-}
-
-static int stdio_tell(struct rtgui_filerw* context)
-{
-	struct rtgui_filerw_stdio* stdio_filerw = (struct rtgui_filerw_stdio *)context;
-
-	return ftell(stdio_filerw->fp);
-}
-
-static int stdio_eof(struct rtgui_filerw* context)
-{
-	struct rtgui_filerw_stdio* stdio_filerw = (struct rtgui_filerw_stdio *)context;
-
-	return feof(stdio_filerw->fp);
-}
-
-static int stdio_close(struct rtgui_filerw *context)
-{
-	struct rtgui_filerw_stdio* stdio_filerw = (struct rtgui_filerw_stdio *)context;
-
-	if (stdio_filerw)
-	{
-		fclose(stdio_filerw->fp);
-		rtgui_free(stdio_filerw);
-
-		return 0;
-	}
-
-	return -1;
-}
 #endif
 
 /* memory file read/write */
@@ -302,7 +215,11 @@ static int parse_mode(const char *mode)
     switch (*mode)
 	{
     case 0: return f;
-    case 'b': break;
+#ifdef _WIN32
+    case 'b': f|=O_BINARY;break;
+#else
+	case 'b': break;
+#endif
     case 'r': f=O_RDONLY; break;
     case 'w': f=O_WRONLY|O_CREAT|O_TRUNC; break;
     case 'a': f=O_WRONLY|O_CREAT|O_APPEND; break;
@@ -321,7 +238,11 @@ struct rtgui_filerw* rtgui_filerw_create_file(const char* filename, const char*
 	RT_ASSERT(filename != RT_NULL);
 
 	rw = RT_NULL;
+#ifdef _WIN32
+	fd = _open(filename, parse_mode(mode), 0);
+#else
 	fd = open(filename, parse_mode(mode), 0);
+#endif
 
 	if ( fd >= 0 )
 	{
@@ -342,35 +263,7 @@ struct rtgui_filerw* rtgui_filerw_create_file(const char* filename, const char*
 
 	return &(rw->parent);
 }
-#elif defined(RTGUI_USING_STDIO_FILERW)
-struct rtgui_filerw* rtgui_filerw_create_file(const char* filename, const char* mode)
-{
-	FILE *fp;
-	struct rtgui_filerw_stdio *rw;
 
-	RT_ASSERT(filename != RT_NULL);
-
-	rw = RT_NULL;
-	fp = fopen(filename, mode);
-
-	if ( fp != NULL )
-	{
-		rw = (struct rtgui_filerw_stdio*) rtgui_malloc(sizeof(struct rtgui_filerw_stdio));
-		if (rw != RT_NULL)
-		{
-			rw->parent.seek  = stdio_seek;
-			rw->parent.read  = stdio_read;
-			rw->parent.write = stdio_write;
-			rw->parent.tell  = stdio_tell;
-			rw->parent.close = stdio_close;
-			rw->parent.eof	 = stdio_eof;
-
-			rw->fp = fp;
-		}
-	}
-
-	return &(rw->parent);
-}
 #endif
 
 struct rtgui_filerw* rtgui_filerw_create_mem(const rt_uint8_t* mem, rt_size_t size)
@@ -447,3 +340,12 @@ int rtgui_filerw_close(struct rtgui_filerw* context)
 
 	return 0;
 }
+
+int rtgui_filerw_unlink(const char *filename)
+{
+#ifdef _WIN32
+	return _unlink(filename);
+#else
+	return unlink(filename);
+#endif
+}
diff --git a/components/rtgui/common/font_hz_file.c b/components/rtgui/common/font_hz_file.c
index f5945442a8..f08c925a04 100644
--- a/components/rtgui/common/font_hz_file.c
+++ b/components/rtgui/common/font_hz_file.c
@@ -7,7 +7,19 @@
 #include <rtgui/rtgui_system.h>
 
 #ifdef RTGUI_USING_HZ_FILE
+#ifdef _WIN32
+#include <fcntl.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <io.h>
+#define open	_open
+#define close	_close
+#define read	_read
+#define write	_write
+#define unlink	_unlink
+#else
 #include <dfs_posix.h>
+#endif
 
 #define HZ_CACHE_MAX    64
 
diff --git a/components/rtgui/common/image.c b/components/rtgui/common/image.c
index 424c684729..843d598360 100644
--- a/components/rtgui/common/image.c
+++ b/components/rtgui/common/image.c
@@ -81,7 +81,7 @@ static struct rtgui_image_engine* rtgui_image_get_engine(const char* type)
 	return RT_NULL;
 }
 
-#if defined(RTGUI_USING_DFS_FILERW) || defined(RTGUI_USING_STDIO_FILERW)
+#if defined(RTGUI_USING_DFS_FILERW)
 struct rtgui_image_engine* rtgui_image_get_engine_by_filename(const char* fn)
 {
 	struct rtgui_list_node *node;
@@ -105,6 +105,7 @@ struct rtgui_image_engine* rtgui_image_get_engine_by_filename(const char* fn)
 
 	return RT_NULL;
 }
+RTM_EXPORT(rtgui_image_get_engine_by_filename);
 
 struct rtgui_image* rtgui_image_create_from_file(const char* type, const char* filename, rt_bool_t load)
 {
@@ -153,6 +154,7 @@ struct rtgui_image* rtgui_image_create_from_file(const char* type, const char* f
 
 	return image;
 }
+RTM_EXPORT(rtgui_image_create_from_file);
 
 struct rtgui_image* rtgui_image_create(const char* filename, rt_bool_t load)
 {
@@ -201,6 +203,7 @@ struct rtgui_image* rtgui_image_create(const char* filename, rt_bool_t load)
 
 	return image;
 }
+RTM_EXPORT(rtgui_image_create);
 #endif
 
 struct rtgui_image* rtgui_image_create_from_mem(const char* type, const rt_uint8_t* data, rt_size_t length, rt_bool_t load)
@@ -250,6 +253,7 @@ struct rtgui_image* rtgui_image_create_from_mem(const char* type, const rt_uint8
 
 	return image;
 }
+RTM_EXPORT(rtgui_image_create_from_mem);
 
 void rtgui_image_destroy(struct rtgui_image* image)
 {
@@ -260,6 +264,7 @@ void rtgui_image_destroy(struct rtgui_image* image)
 		rtgui_free(image->palette);
 	rtgui_free(image);
 }
+RTM_EXPORT(rtgui_image_destroy);
 
 /* register an image engine */
 void rtgui_image_register_engine(struct rtgui_image_engine* engine)
@@ -268,6 +273,7 @@ void rtgui_image_register_engine(struct rtgui_image_engine* engine)
 
 	rtgui_list_append(&_rtgui_system_image_list, &(engine->list));
 }
+RTM_EXPORT(rtgui_image_register_engine);
 
 void rtgui_image_blit(struct rtgui_image* image, struct rtgui_dc* dc, struct rtgui_rect* rect)
 {
@@ -282,6 +288,7 @@ void rtgui_image_blit(struct rtgui_image* image, struct rtgui_dc* dc, struct rtg
 		image->engine->image_blit(image, dc, rect);
 	}
 }
+RTM_EXPORT(rtgui_image_blit);
 
 struct rtgui_image_palette* rtgui_image_palette_create(rt_uint32_t ncolors)
 {
@@ -296,6 +303,7 @@ struct rtgui_image_palette* rtgui_image_palette_create(rt_uint32_t ncolors)
 
 	return palette;
 }
+RTM_EXPORT(rtgui_image_palette_create);
 
 void rtgui_image_get_rect(struct rtgui_image* image, struct rtgui_rect* rect)
 {
@@ -305,4 +313,5 @@ void rtgui_image_get_rect(struct rtgui_image* image, struct rtgui_rect* rect)
 	rect->x1 = 0; rect->y1 = 0;
 	rect->x2 = image->w; rect->y2 = image->h;
 }
+RTM_EXPORT(rtgui_image_get_rect);
 
diff --git a/components/rtgui/common/image_bmp.c b/components/rtgui/common/image_bmp.c
index 71f7adbec8..78c60d796b 100644
--- a/components/rtgui/common/image_bmp.c
+++ b/components/rtgui/common/image_bmp.c
@@ -832,6 +832,178 @@ static void rtgui_image_bmp_blit(struct rtgui_image *image, struct rtgui_dc *dc,
     while (0);
 }
 
+/*
+ * config bitmap header.
+ */
+void rtgui_image_bmp_header_cfg(struct rtgui_image_bmp_header *bhr, rt_int32_t w, rt_int32_t h, rt_uint16_t bits_per_pixel)
+{
+	int image_size = w * h * bits_per_pixel/8;
+	int header_size = sizeof(struct rtgui_image_bmp_header);
+
+	bhr->bfType = 0x4d42; /* BM */
+	bhr->bfSize = header_size + image_size; /* data size */
+	bhr->bfReserved1 = 0;
+	bhr->bfReserved2 = 0;
+	bhr->bfOffBits = header_size;
+
+	bhr->biSize = 40; /* sizeof BITMAPINFOHEADER */
+	bhr->biWidth = w;
+	bhr->biHeight = h;
+	bhr->biPlanes = 1;
+	bhr->biBitCount = bits_per_pixel;
+	bhr->biCompression = BI_BITFIELDS;
+	bhr->biSizeImage = image_size;
+	bhr->biXPelsPerMeter = 0;
+	bhr->biYPelsPerMeter = 0;
+	bhr->biClrUsed = 0;
+	bhr->biClrImportant = 0;
+	if(bhr->biBitCount == 16 && bhr->biCompression == BI_BITFIELDS)
+	{
+		bhr->bfSize += 12;
+		bhr->bfOffBits += 12;
+	}
+}
+
+#define WRITE_CLUSTER_SIZE	2048
+void bmp_align_write(struct rtgui_filerw *file, char *dest, char *src, rt_int32_t len, rt_int32_t *count)
+{
+	rt_int32_t len_bak = len;
+
+	while(len)
+	{
+		if(*count >= WRITE_CLUSTER_SIZE)
+		{
+			rtgui_filerw_write(file, dest, WRITE_CLUSTER_SIZE, 1);
+			*count = 0;
+		}
+		*(dest + *count) = *(src + (len_bak-len));
+		len --;
+		(*count) ++;
+	}
+}
+
+/*
+ * Grab screen and save as a BMP file
+ * MACRO RGB_CONVERT_TO_BGR: If the pixel of colors is BGR mode, defined it.
+ */
+void screenshot(const char *filename)
+{
+	struct rtgui_filerw *file;
+	int w, h, i, pitch;
+	rt_uint16_t *src;
+	rt_uint32_t mask;
+	struct rtgui_image_bmp_header bhr;
+	struct rtgui_graphic_driver *grp = hw_driver;
+#ifdef RGB_CONVERT_TO_BGR
+	int j;
+	rt_uint16_t *line_buf;
+	rt_uint16_t color, tmp;
+#endif
+	char *pixel_buf;
+	rt_int32_t write_count=0;
+
+	file = rtgui_filerw_create_file(filename, "wb");
+	if(file == RT_NULL)
+	{
+		rt_kprintf("create file failed\n");
+		return;
+	}
+
+	w = grp->width;
+	h = grp->height;
+
+	pitch = w * sizeof(rt_uint16_t);
+#ifdef RGB_CONVERT_TO_BGR
+	line_buf = rt_malloc(pitch);
+	if(line_buf == RT_NULL)
+	{
+		rt_kprintf("no memory!\n");
+		return;
+	}
+#endif
+	pixel_buf = rt_malloc(WRITE_CLUSTER_SIZE);
+	if(pixel_buf == RT_NULL)
+	{
+		rt_kprintf("no memory!\n");
+#ifdef RGB_CONVERT_TO_BGR
+		rt_free(line_buf);
+#endif
+		return;
+	}
+
+	rtgui_image_bmp_header_cfg(&bhr, w, h, grp->bits_per_pixel);
+
+	bmp_align_write(file, pixel_buf, (char*)&bhr, 
+		sizeof(struct rtgui_image_bmp_header), &write_count);
+
+	if(bhr.biCompression == BI_BITFIELDS)
+	{
+		mask = 0xF800; /* Red Mask */
+		bmp_align_write(file, pixel_buf, (char*)&mask, 4, &write_count);
+		mask = 0x07E0; /* Green Mask */
+		bmp_align_write(file, pixel_buf, (char*)&mask, 4, &write_count);
+		mask = 0x001F; /* Blue Mask */
+		bmp_align_write(file, pixel_buf, (char*)&mask, 4, &write_count);
+	}
+	rtgui_screen_lock(RT_WAITING_FOREVER);
+	if(grp->framebuffer != RT_NULL)
+	{
+		src = (rt_uint16_t*)grp->framebuffer;
+		src += w * h;
+		for(i=0; i<h; i++)
+		{
+			src -= w;
+#ifdef RGB_CONVERT_TO_BGR
+			for(j=0; j<w; j++)
+			{
+				tmp = *(src + j);
+				color  = (tmp & 0x001F)<<11;
+				color += (tmp & 0x07E0);
+				color += (tmp & 0xF800)>>11;
+
+				*(line_buf + i) = color;
+			}
+			bmp_align_write(file, pixel_buf, (char*)line_buf, pitch, &write_count);
+#else
+			bmp_align_write(file, pixel_buf, (char*)src, pitch, &write_count);
+#endif
+		}
+	}
+	else
+	{
+		rtgui_color_t pixel_color;
+		rt_uint16_t write_color;
+		int x;
+		for(i=h-1; i>=0; i--)
+		{
+			x = 0;
+			if(i%10==0)rt_kprintf(">",i);
+			while(x < w)
+			{
+				grp->ops->get_pixel(&pixel_color, x, i);
+				write_color = rtgui_color_to_565p(pixel_color);
+				bmp_align_write(file, pixel_buf, (char*)&write_color, 
+					sizeof(rt_uint16_t), &write_count);
+				x++;
+			}
+		}
+	}
+	/* write The tail of the last */
+	if(write_count < WRITE_CLUSTER_SIZE)
+		rtgui_filerw_write(file, pixel_buf, write_count, 1);
+	rtgui_screen_unlock();
+#ifdef RGB_CONVERT_TO_BGR
+	rt_free(line_buf);
+#endif
+	rt_free(pixel_buf);
+	rt_kprintf("bmp create succeed.\n");
+	rtgui_filerw_close(file);
+}
+#ifdef RT_USING_FINSH
+#include <finsh.h>
+FINSH_FUNCTION_EXPORT(screenshot, usage: screenshot(filename));
+#endif
+
 void rtgui_image_bmp_init()
 {
     /* register bmp on image system */
diff --git a/components/rtgui/common/rtgui_app.c b/components/rtgui/common/rtgui_app.c
index da63107172..68876926dc 100644
--- a/components/rtgui/common/rtgui_app.c
+++ b/components/rtgui/common/rtgui_app.c
@@ -112,6 +112,7 @@ __mq_err:
 	tid->user_data = 0;
 	return RT_NULL;
 }
+RTM_EXPORT(rtgui_app_create);
 
 #define _rtgui_application_check(app)			\
 	do {										\
@@ -152,6 +153,7 @@ void rtgui_app_destroy(struct rtgui_app *app)
 	rt_mq_delete(app->mq);
 	rtgui_object_destroy(RTGUI_OBJECT(app));
 }
+RTM_EXPORT(rtgui_app_destroy);
 
 struct rtgui_app* rtgui_app_self(void)
 {
@@ -164,6 +166,7 @@ struct rtgui_app* rtgui_app_self(void)
 
 	return app;
 }
+RTM_EXPORT(rtgui_app_self);
 
 void rtgui_app_set_onidle(rtgui_idle_func_t onidle)
 {
@@ -173,6 +176,7 @@ void rtgui_app_set_onidle(rtgui_idle_func_t onidle)
 	if (app != RT_NULL)
 		app->on_idle = onidle;
 }
+RTM_EXPORT(rtgui_app_set_onidle);
 
 rtgui_idle_func_t rtgui_app_get_onidle(void)
 {
@@ -184,6 +188,7 @@ rtgui_idle_func_t rtgui_app_get_onidle(void)
 	else
 		return RT_NULL;
 }
+RTM_EXPORT(rtgui_app_get_onidle);
 
 rt_inline rt_bool_t _rtgui_application_dest_handle(
 		struct rtgui_app *app,
@@ -339,12 +344,14 @@ rt_base_t rtgui_app_run(struct rtgui_app *app)
 
 	return app->exit_code;
 }
+RTM_EXPORT(rtgui_app_run);
 
 void rtgui_app_exit(struct rtgui_app* app, rt_uint16_t code)
 {
 	--app->ref_count;
 	app->exit_code = code;
 }
+RTM_EXPORT(rtgui_app_exit);
 
 void rtgui_app_activate(struct rtgui_app *app)
 {
@@ -355,6 +362,7 @@ void rtgui_app_activate(struct rtgui_app *app)
 
 	rtgui_send(app->tid, RTGUI_EVENT(&event), sizeof(struct rtgui_event_application));
 }
+RTM_EXPORT(rtgui_app_activate);
 
 void rtgui_app_close(struct rtgui_app *app)
 {
@@ -365,6 +373,7 @@ void rtgui_app_close(struct rtgui_app *app)
 
 	rtgui_send(app->tid, RTGUI_EVENT(&event), sizeof(struct rtgui_event_application));
 }
+RTM_EXPORT(rtgui_app_close);
 
 /**
  * set this application as window manager
@@ -389,6 +398,7 @@ rt_err_t rtgui_app_set_as_wm(void)
 
 	return RT_ERROR;
 }
+RTM_EXPORT(rtgui_app_set_as_wm);
 
 void rtgui_app_set_main_win(struct rtgui_win* win)
 {
@@ -400,3 +410,5 @@ void rtgui_app_set_main_win(struct rtgui_win* win)
 		app->main_object = RTGUI_OBJECT(win);
 	}
 }
+RTM_EXPORT(rtgui_app_set_main_win);
+
diff --git a/components/rtgui/common/rtgui_object.c b/components/rtgui/common/rtgui_object.c
index 95a7c4e17e..81c3acc701 100644
--- a/components/rtgui/common/rtgui_object.c
+++ b/components/rtgui/common/rtgui_object.c
@@ -34,6 +34,7 @@ DEFINE_CLASS_TYPE(object, "object",
 	_rtgui_object_constructor,
 	_rtgui_object_destructor,
 	sizeof(struct rtgui_object));
+RTM_EXPORT(_rtgui_object);
 
 void rtgui_type_object_construct(const rtgui_type_t *type, rtgui_object_t *object)
 {
@@ -121,6 +122,7 @@ rtgui_object_t *rtgui_object_create(rtgui_type_t *object_type)
 
 	return new_object;
 }
+RTM_EXPORT(rtgui_object_create);
 
 /**
  * @brief Destroys the object: it first sets the weak-pointers to RT_NULL, emits the "destroyed" signal, and then
@@ -146,6 +148,7 @@ void rtgui_object_destroy(rtgui_object_t *object)
 	/* release object */
 	rtgui_free(object);
 }
+RTM_EXPORT(rtgui_object_destroy);
 
 /**
  * @brief Checks if @a object can be cast to @a type.
@@ -166,6 +169,8 @@ rtgui_object_t *rtgui_object_check_cast(rtgui_object_t *obj, rtgui_type_t *obj_t
 
 	return obj;
 }
+RTM_EXPORT(rtgui_object_check_cast);
+
 
 /**
  * @brief Gets the type of the object
@@ -178,6 +183,7 @@ const rtgui_type_t *rtgui_object_object_type_get(rtgui_object_t *object)
 
 	return object->type;
 }
+RTM_EXPORT(rtgui_object_object_type_get);
 
 void rtgui_object_set_event_handler(struct rtgui_object *object, rtgui_event_handler_ptr handler)
 {
@@ -185,9 +191,11 @@ void rtgui_object_set_event_handler(struct rtgui_object *object, rtgui_event_han
 
 	object->event_handler = handler;
 }
+RTM_EXPORT(rtgui_object_set_event_handler);
 
 rt_bool_t rtgui_object_event_handler(struct rtgui_object *object, struct rtgui_event* event)
 {
 	return RT_FALSE;
 }
+RTM_EXPORT(rtgui_object_event_handler);
 
diff --git a/components/rtgui/common/rtgui_system.c b/components/rtgui/common/rtgui_system.c
index 4669ef3010..ed2ad57705 100644
--- a/components/rtgui/common/rtgui_system.c
+++ b/components/rtgui/common/rtgui_system.c
@@ -87,6 +87,7 @@ rtgui_timer_t* rtgui_timer_create(rt_int32_t time, rt_int32_t flag, rtgui_timeou
 
 	return timer;
 }
+RTM_EXPORT(rtgui_timer_create);
 
 void rtgui_timer_destory(rtgui_timer_t* timer)
 {
@@ -100,6 +101,7 @@ void rtgui_timer_destory(rtgui_timer_t* timer)
 
 	rtgui_free(timer);
 }
+RTM_EXPORT(rtgui_timer_destory);
 
 void rtgui_timer_start(rtgui_timer_t* timer)
 {
@@ -108,6 +110,7 @@ void rtgui_timer_start(rtgui_timer_t* timer)
 	/* start rt-thread timer */
 	rt_timer_start(&(timer->timer));
 }
+RTM_EXPORT(rtgui_timer_start);
 
 void rtgui_timer_stop (rtgui_timer_t* timer)
 {
@@ -116,6 +119,7 @@ void rtgui_timer_stop (rtgui_timer_t* timer)
 	/* stop rt-thread timer */
 	rt_timer_stop(&(timer->timer));
 }
+RTM_EXPORT(rtgui_timer_stop);
 
 /************************************************************************/
 /* RTGUI Memory Management                                              */
@@ -267,6 +271,7 @@ void* rtgui_malloc(rt_size_t size)
 
 	return ptr;
 }
+RTM_EXPORT(rtgui_malloc);
 
 void* rtgui_realloc(void* ptr, rt_size_t size)
 {
@@ -285,6 +290,7 @@ void* rtgui_realloc(void* ptr, rt_size_t size)
 
 	return new_ptr;
 }
+RTM_EXPORT(rtgui_realloc);
 
 void rtgui_free(void* ptr)
 {
@@ -295,6 +301,7 @@ void rtgui_free(void* ptr)
 
 	rt_free(ptr);
 }
+RTM_EXPORT(rtgui_free);
 
 #if defined(RTGUI_MEM_TRACE) && defined(RT_USING_FINSH)
 #include <finsh.h>
@@ -560,6 +567,7 @@ rt_err_t rtgui_send(rt_thread_t tid, rtgui_event_t* event, rt_size_t event_size)
 
 	return result;
 }
+RTM_EXPORT(rtgui_send);
 
 rt_err_t rtgui_send_urgent(rt_thread_t tid, rtgui_event_t* event, rt_size_t event_size)
 {
@@ -583,6 +591,7 @@ rt_err_t rtgui_send_urgent(rt_thread_t tid, rtgui_event_t* event, rt_size_t even
 
 	return result;
 }
+RTM_EXPORT(rtgui_send_urgent);
 
 rt_err_t rtgui_send_sync(rt_thread_t tid, rtgui_event_t* event, rt_size_t event_size)
 {
@@ -631,6 +640,7 @@ __return:
 	rt_mb_detach(&ack_mb);
 	return r;
 }
+RTM_EXPORT(rtgui_send_sync);
 
 rt_err_t rtgui_ack(rtgui_event_t* event, rt_int32_t status)
 {
@@ -641,6 +651,7 @@ rt_err_t rtgui_ack(rtgui_event_t* event, rt_int32_t status)
 
 	return RT_EOK;
 }
+RTM_EXPORT(rtgui_ack);
 
 rt_err_t rtgui_recv(rtgui_event_t* event, rt_size_t event_size)
 {
@@ -658,6 +669,7 @@ rt_err_t rtgui_recv(rtgui_event_t* event, rt_size_t event_size)
 
 	return r;
 }
+RTM_EXPORT(rtgui_recv);
 
 rt_err_t rtgui_recv_nosuspend(rtgui_event_t* event, rt_size_t event_size)
 {
@@ -675,6 +687,7 @@ rt_err_t rtgui_recv_nosuspend(rtgui_event_t* event, rt_size_t event_size)
 
 	return r;
 }
+RTM_EXPORT(rtgui_recv_nosuspend);
 
 rt_err_t rtgui_recv_filter(rt_uint32_t type, rtgui_event_t* event, rt_size_t event_size)
 {
@@ -704,33 +717,41 @@ rt_err_t rtgui_recv_filter(rt_uint32_t type, rtgui_event_t* event, rt_size_t eve
 
 	return -RT_ERROR;
 }
+RTM_EXPORT(rtgui_recv_filter);
 
 rt_thread_t rtgui_get_server(void)
 {
 	return rt_thread_find("rtgui");
 }
+RTM_EXPORT(rtgui_get_server);
 
 void rtgui_set_mainwin_rect(struct rtgui_rect *rect)
 {
 	_mainwin_rect = *rect;
 }
+RTM_EXPORT(rtgui_set_mainwin_rect);
 
 void rtgui_get_mainwin_rect(struct rtgui_rect *rect)
 {
 	*rect = _mainwin_rect;
 }
+RTM_EXPORT(rtgui_get_mainwin_rect);
 
 void rtgui_get_screen_rect(struct rtgui_rect *rect)
 {
 	rtgui_graphic_driver_get_rect(rtgui_graphic_driver_get_default(), rect);
 }
+RTM_EXPORT(rtgui_get_screen_rect);
 
 void rtgui_screen_lock(rt_int32_t timeout)
 {
 	rt_mutex_take(&_screen_lock, timeout);
 }
+RTM_EXPORT(rtgui_screen_lock);
 
 void rtgui_screen_unlock(void)
 {
 	rt_mutex_release(&_screen_lock);
 }
+RTM_EXPORT(rtgui_screen_unlock);
+