sync RTGUI with github(https://github.com/RT-Thread/RTGUI) 9ae08379da5b698d6facc40bd0415de2e254ae9c

As always, full log is in GitHub.

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

components/rtgui/SConscript

@@ -32,6 +32,7 @@ common/hz12font.c
 common/hz16font.c
 common/framebuffer_driver.c
 common/pixel_driver.c
+common/rtgui_mv_model.c
 """)
 
 server_src = Split("""
@@ -68,10 +69,17 @@ widgets/window.c
 widgets/panel.c
 widgets/groupbox.c
 widgets/edit.c
+widgets/mv_view.c
 widgets/plot.c
 widgets/plot_curve.c
 """)
 
+if GetDepend('RTGUI_USING_FONT_COMPACT'):
+    import stract_cjk
+    common_src.append('common/font_cmp_hz16.c')
+    common_src.append('common/font_cmp_hz12.c')
+    RegisterPreBuildingAction(stract_cjk.gen_cmp_font_file)
+
 # The set of source files associated with this SConscript file.
 src = common_src + server_src + widgets_src
 

components/rtgui/common/color.c

@@ -13,18 +13,18 @@
  */
 #include <rtgui/color.h>
 
-const rtgui_color_t red 	= RTGUI_RGB(0xff, 0x00, 0x00);
-const rtgui_color_t green 	= RTGUI_RGB(0x00, 0xff, 0x00);
-const rtgui_color_t blue 	= RTGUI_RGB(0x00, 0x00, 0xff);
-const rtgui_color_t black 	= RTGUI_RGB(0x00, 0x00, 0x00);
-const rtgui_color_t white 	= RTGUI_RGB(0xff, 0xff, 0xff);
+const rtgui_color_t red     = RTGUI_RGB(0xff, 0x00, 0x00);
+const rtgui_color_t green   = RTGUI_RGB(0x00, 0xff, 0x00);
+const rtgui_color_t blue    = RTGUI_RGB(0x00, 0x00, 0xff);
+const rtgui_color_t black   = RTGUI_RGB(0x00, 0x00, 0x00);
+const rtgui_color_t white   = RTGUI_RGB(0xff, 0xff, 0xff);
 
-const rtgui_color_t high_light 	= RTGUI_RGB(0xff, 0xff, 0xff);
-const rtgui_color_t dark_grey 	= RTGUI_RGB(0x7f, 0x7f, 0x7f);
-const rtgui_color_t light_grey 	= RTGUI_RGB(0xc0, 0xc0, 0xc0);
+const rtgui_color_t high_light  = RTGUI_RGB(0xff, 0xff, 0xff);
+const rtgui_color_t dark_grey   = RTGUI_RGB(0x7f, 0x7f, 0x7f);
+const rtgui_color_t light_grey  = RTGUI_RGB(0xc0, 0xc0, 0xc0);
 
-#define RTGUI_RGB_R(c)	((c) & 0xff)
-#define RTGUI_RGB_G(c)	(((c) >> 8)  & 0xff)
-#define RTGUI_RGB_B(c)	(((c) >> 16) & 0xff)
-#define RTGUI_RGB_A(c)	(((c) >> 24) & 0xff)
+#define RTGUI_RGB_R(c)  ((c) & 0xff)
+#define RTGUI_RGB_G(c)  (((c) >> 8)  & 0xff)
+#define RTGUI_RGB_B(c)  (((c) >> 16) & 0xff)
+#define RTGUI_RGB_A(c)  (((c) >> 24) & 0xff)
 

components/rtgui/common/dc_buffer.c

@@ -18,328 +18,328 @@
 #include <rtgui/color.h>
 #include <rtgui/rtgui_system.h>
 
-#define hw_driver				(rtgui_graphic_driver_get_default())
+#define hw_driver               (rtgui_graphic_driver_get_default())
 
-#define RTGUI_BLENDMODE_NONE	0x00
-#define RTGUI_BLENDMODE_BLEND	0x01
-#define RTGUI_BLENDMODE_ADD		0x02
-#define RTGUI_BLENDMODE_MOD		0x03
+#define RTGUI_BLENDMODE_NONE    0x00
+#define RTGUI_BLENDMODE_BLEND   0x01
+#define RTGUI_BLENDMODE_ADD     0x02
+#define RTGUI_BLENDMODE_MOD     0x03
 
 struct rtgui_dc_buffer
 {
-	struct rtgui_dc parent;
+    struct rtgui_dc parent;
 
-	/* graphic context */
-	rtgui_gc_t gc;
+    /* graphic context */
+    rtgui_gc_t gc;
 
-	/* pixel format */
-	rt_uint8_t pixel_format;
-	rt_uint8_t blend_mode;
+    /* pixel format */
+    rt_uint8_t pixel_format;
+    rt_uint8_t blend_mode;
 
-	/* width and height */
-	rt_uint16_t width, height;
-	rt_uint16_t pitch;
+    /* width and height */
+    rt_uint16_t width, height;
+    rt_uint16_t pitch;
 
-	/* blit info */
-	rtgui_region_t clip;
+    /* blit info */
+    rtgui_region_t clip;
 
-	/* pixel data */
-	rt_uint8_t* pixel;
+    /* pixel data */
+    rt_uint8_t *pixel;
 };
 
-static rt_bool_t rtgui_dc_buffer_fini(struct rtgui_dc* dc);
-static void rtgui_dc_buffer_draw_point(struct rtgui_dc* dc, int x, int y);
-static void rtgui_dc_buffer_draw_color_point(struct rtgui_dc* dc, int x, int y, rtgui_color_t color);
-static void rtgui_dc_buffer_draw_vline(struct rtgui_dc* dc, int x, int y1, int y2);
-static void rtgui_dc_buffer_draw_hline(struct rtgui_dc* dc, int x1, int x2, int y);
-static void rtgui_dc_buffer_fill_rect (struct rtgui_dc* dc, struct rtgui_rect* rect);
-static void rtgui_dc_buffer_blit_line(struct rtgui_dc* self, int x1, int x2, int y, rt_uint8_t* line_data);
-static void rtgui_dc_buffer_blit(struct rtgui_dc* self, struct rtgui_point* dc_point,
-	struct rtgui_dc* dest, rtgui_rect_t* rect);
+static rt_bool_t rtgui_dc_buffer_fini(struct rtgui_dc *dc);
+static void rtgui_dc_buffer_draw_point(struct rtgui_dc *dc, int x, int y);
+static void rtgui_dc_buffer_draw_color_point(struct rtgui_dc *dc, int x, int y, rtgui_color_t color);
+static void rtgui_dc_buffer_draw_vline(struct rtgui_dc *dc, int x, int y1, int y2);
+static void rtgui_dc_buffer_draw_hline(struct rtgui_dc *dc, int x1, int x2, int y);
+static void rtgui_dc_buffer_fill_rect(struct rtgui_dc *dc, struct rtgui_rect *rect);
+static void rtgui_dc_buffer_blit_line(struct rtgui_dc *self, int x1, int x2, int y, rt_uint8_t *line_data);
+static void rtgui_dc_buffer_blit(struct rtgui_dc *self, struct rtgui_point *dc_point,
+                                 struct rtgui_dc *dest, rtgui_rect_t *rect);
 
-static void rtgui_dc_buffer_set_gc (struct rtgui_dc* dc, rtgui_gc_t *gc);
-static rtgui_gc_t* rtgui_dc_buffer_get_gc(struct rtgui_dc* dc);
+static void rtgui_dc_buffer_set_gc(struct rtgui_dc *dc, rtgui_gc_t *gc);
+static rtgui_gc_t *rtgui_dc_buffer_get_gc(struct rtgui_dc *dc);
 
-static rt_bool_t rtgui_dc_buffer_get_visible(struct rtgui_dc* dc);
-static void rtgui_dc_buffer_get_rect(struct rtgui_dc* dc, rtgui_rect_t* rect);
+static rt_bool_t rtgui_dc_buffer_get_visible(struct rtgui_dc *dc);
+static void rtgui_dc_buffer_get_rect(struct rtgui_dc *dc, rtgui_rect_t *rect);
 
-const static struct rtgui_dc_engine dc_buffer_engine = 
+const static struct rtgui_dc_engine dc_buffer_engine =
 {
-	rtgui_dc_buffer_draw_point,
-	rtgui_dc_buffer_draw_color_point,
-	rtgui_dc_buffer_draw_vline,
-	rtgui_dc_buffer_draw_hline,
-	rtgui_dc_buffer_fill_rect,
-	rtgui_dc_buffer_blit_line,
-	rtgui_dc_buffer_blit,
+    rtgui_dc_buffer_draw_point,
+    rtgui_dc_buffer_draw_color_point,
+    rtgui_dc_buffer_draw_vline,
+    rtgui_dc_buffer_draw_hline,
+    rtgui_dc_buffer_fill_rect,
+    rtgui_dc_buffer_blit_line,
+    rtgui_dc_buffer_blit,
 
-	rtgui_dc_buffer_set_gc,
-	rtgui_dc_buffer_get_gc,
+    rtgui_dc_buffer_set_gc,
+    rtgui_dc_buffer_get_gc,
 
-	rtgui_dc_buffer_get_visible,
-	rtgui_dc_buffer_get_rect,
+    rtgui_dc_buffer_get_visible,
+    rtgui_dc_buffer_get_rect,
 
-	rtgui_dc_buffer_fini,
+    rtgui_dc_buffer_fini,
 };
 
-struct rtgui_dc* rtgui_dc_buffer_create(int w, int h)
+struct rtgui_dc *rtgui_dc_buffer_create(int w, int h)
 {
-	struct rtgui_dc_buffer* dc;
+    struct rtgui_dc_buffer *dc;
 
-	dc = (struct rtgui_dc_buffer*)rtgui_malloc(sizeof(struct rtgui_dc_buffer));
-	dc->parent.type   = RTGUI_DC_BUFFER;
-	dc->parent.engine = &dc_buffer_engine;
-	dc->gc.foreground = default_foreground;
-	dc->gc.background = default_background;
-	dc->gc.font = rtgui_font_default();
-	dc->gc.textalign = RTGUI_ALIGN_LEFT | RTGUI_ALIGN_TOP;
+    dc = (struct rtgui_dc_buffer *)rtgui_malloc(sizeof(struct rtgui_dc_buffer));
+    dc->parent.type   = RTGUI_DC_BUFFER;
+    dc->parent.engine = &dc_buffer_engine;
+    dc->gc.foreground = default_foreground;
+    dc->gc.background = default_background;
+    dc->gc.font = rtgui_font_default();
+    dc->gc.textalign = RTGUI_ALIGN_LEFT | RTGUI_ALIGN_TOP;
 
-	dc->width	= w;
-	dc->height	= h;
-	dc->pitch	= w * sizeof(rtgui_color_t);
+    dc->width   = w;
+    dc->height  = h;
+    dc->pitch   = w *sizeof(rtgui_color_t);
 
-	rtgui_region_init(&(dc->clip));
+    rtgui_region_init(&(dc->clip));
 
-	dc->pixel = rtgui_malloc(h * dc->pitch);
-	rt_memset(dc->pixel, 0, h * dc->pitch);
+    dc->pixel = rtgui_malloc(h * dc->pitch);
+    rt_memset(dc->pixel, 0, h * dc->pitch);
 
-	return &(dc->parent);
+    return &(dc->parent);
 }
 
-rt_uint8_t* rtgui_dc_buffer_get_pixel(struct rtgui_dc* dc)
+rt_uint8_t *rtgui_dc_buffer_get_pixel(struct rtgui_dc *dc)
 {
-	struct rtgui_dc_buffer* dc_buffer;
+    struct rtgui_dc_buffer *dc_buffer;
 
-	dc_buffer = (struct rtgui_dc_buffer*)dc;
+    dc_buffer = (struct rtgui_dc_buffer *)dc;
 
-	return dc_buffer->pixel;
+    return dc_buffer->pixel;
 }
 
-static rt_bool_t rtgui_dc_buffer_fini(struct rtgui_dc* dc)
+static rt_bool_t rtgui_dc_buffer_fini(struct rtgui_dc *dc)
 {
-	struct rtgui_dc_buffer* buffer = (struct rtgui_dc_buffer*)dc;
+    struct rtgui_dc_buffer *buffer = (struct rtgui_dc_buffer *)dc;
 
-	if (dc->type != RTGUI_DC_BUFFER) return RT_FALSE;
+    if (dc->type != RTGUI_DC_BUFFER) return RT_FALSE;
 
-	rtgui_free(buffer->pixel);
-	buffer->pixel = RT_NULL;
+    rtgui_free(buffer->pixel);
+    buffer->pixel = RT_NULL;
 
-	return RT_TRUE;
+    return RT_TRUE;
 }
 
-static void rtgui_dc_buffer_draw_point(struct rtgui_dc* self, int x, int y)
+static void rtgui_dc_buffer_draw_point(struct rtgui_dc *self, int x, int y)
 {
-	rtgui_color_t* ptr;
-	struct rtgui_dc_buffer* dc;
+    rtgui_color_t *ptr;
+    struct rtgui_dc_buffer *dc;
 
-	dc = (struct rtgui_dc_buffer*)self;
+    dc = (struct rtgui_dc_buffer *)self;
 
-	/* does not draw point out of dc */
-	if ((x > dc->width) || (y > dc->height)) return ;
-	
-	/* note: there is no parameter check in this function */
-	ptr = (rtgui_color_t*)(dc->pixel + y * dc->pitch + x * sizeof(rtgui_color_t));
+    /* does not draw point out of dc */
+    if ((x > dc->width) || (y > dc->height)) return ;
 
-	*ptr = dc->gc.foreground;
+    /* note: there is no parameter check in this function */
+    ptr = (rtgui_color_t *)(dc->pixel + y * dc->pitch + x * sizeof(rtgui_color_t));
+
+    *ptr = dc->gc.foreground;
 }
 
-static void rtgui_dc_buffer_draw_color_point(struct rtgui_dc* self, int x, int y, rtgui_color_t color)
+static void rtgui_dc_buffer_draw_color_point(struct rtgui_dc *self, int x, int y, rtgui_color_t color)
 {
-	rtgui_color_t* ptr;
-	struct rtgui_dc_buffer* dc;
+    rtgui_color_t *ptr;
+    struct rtgui_dc_buffer *dc;
 
-	dc = (struct rtgui_dc_buffer*)self;
+    dc = (struct rtgui_dc_buffer *)self;
 
-	/* note: there is no parameter check in this function */
-	ptr = (rtgui_color_t*)(dc->pixel + y * dc->pitch + x * sizeof(rtgui_color_t));
+    /* note: there is no parameter check in this function */
+    ptr = (rtgui_color_t *)(dc->pixel + y * dc->pitch + x * sizeof(rtgui_color_t));
 
-	*ptr = color;
+    *ptr = color;
 }
 
-static void rtgui_dc_buffer_draw_vline(struct rtgui_dc* self, int x, int y1, int y2)
+static void rtgui_dc_buffer_draw_vline(struct rtgui_dc *self, int x, int y1, int y2)
 {
-	rtgui_color_t* ptr;
-	register rt_base_t index;
-	struct rtgui_dc_buffer* dc;
-
-	dc = (struct rtgui_dc_buffer*)self;
-
-	if (x  >= dc->width) return;
-	if (y1 > dc->height) y1 = dc->height;
-	if (y2 > dc->height) y2 = dc->height;
-
-	ptr = (rtgui_color_t*)(dc->pixel + y1 * dc->pitch + x * sizeof(rtgui_color_t));
-	for (index = y1; index < y2; index ++)
-	{
-		/* draw this point */
-		*ptr = dc->gc.foreground;
-		ptr += dc->width;
-	}
+    rtgui_color_t *ptr;
+    register rt_base_t index;
+    struct rtgui_dc_buffer *dc;
+
+    dc = (struct rtgui_dc_buffer *)self;
+
+    if (x  >= dc->width) return;
+    if (y1 > dc->height) y1 = dc->height;
+    if (y2 > dc->height) y2 = dc->height;
+
+    ptr = (rtgui_color_t *)(dc->pixel + y1 * dc->pitch + x * sizeof(rtgui_color_t));
+    for (index = y1; index < y2; index ++)
+    {
+        /* draw this point */
+        *ptr = dc->gc.foreground;
+        ptr += dc->width;
+    }
 }
 
-static void rtgui_dc_buffer_draw_hline(struct rtgui_dc* self, int x1, int x2, int y)
+static void rtgui_dc_buffer_draw_hline(struct rtgui_dc *self, int x1, int x2, int y)
 {
-	rtgui_color_t* ptr;
-	register rt_base_t index;
-	struct rtgui_dc_buffer* dc;
-
-	dc = (struct rtgui_dc_buffer*)self;
-	if (y >= dc->height) return;
-	if (x1 > dc->width) x1 = dc->width;
-	if (x2 > dc->width) x2 = dc->width;
-
-	ptr = (rtgui_color_t*)(dc->pixel + y * dc->pitch + x1 * sizeof(rtgui_color_t));
-	for (index = x1; index < x2; index ++)
-	{
-		/* draw this point */
-		*ptr++ = dc->gc.foreground;
-	}
+    rtgui_color_t *ptr;
+    register rt_base_t index;
+    struct rtgui_dc_buffer *dc;
+
+    dc = (struct rtgui_dc_buffer *)self;
+    if (y >= dc->height) return;
+    if (x1 > dc->width) x1 = dc->width;
+    if (x2 > dc->width) x2 = dc->width;
+
+    ptr = (rtgui_color_t *)(dc->pixel + y * dc->pitch + x1 * sizeof(rtgui_color_t));
+    for (index = x1; index < x2; index ++)
+    {
+        /* draw this point */
+        *ptr++ = dc->gc.foreground;
+    }
 }
 
-static void rtgui_dc_buffer_fill_rect (struct rtgui_dc* self, struct rtgui_rect* rect)
+static void rtgui_dc_buffer_fill_rect(struct rtgui_dc *self, struct rtgui_rect *rect)
 {
-	rtgui_color_t foreground;
-	rtgui_rect_t r;
-	struct rtgui_dc_buffer* dc;
-
-	r = *rect;
-	dc = (struct rtgui_dc_buffer*)self;
-	if (r.x1 > dc->width) r.x1 = dc->width;
-	if (r.x2 > dc->width) r.x2 = dc->width;
-	if (r.y1 > dc->height) r.y1 = dc->height;
-	if (r.y2 > dc->height) r.y2 = dc->height;
-	
-	/* save foreground color */
-	foreground = RTGUI_DC_FC(self);
-
-	/* set background color as foreground color */
-	RTGUI_DC_FC(self) = RTGUI_DC_BC(self);
-
-	/* fill first line */
-	rtgui_dc_buffer_draw_hline(&(dc->parent), r.x1, r.x2, r.y1);
-
-	/* memory copy other lines */
-	if (r.y2 > r.y1)
-	{
-		register rt_base_t index;
-		for (index = r.y1 + 1; index < r.y2; index ++)
-		{
-			rt_memcpy(dc->pixel + index * dc->pitch,
-				dc->pixel + r.y1 * dc->pitch,
-				(r.x2 - r.x1) * sizeof(rtgui_color_t));
-		}
-	}
-
-	/* restore foreground color */
-	RTGUI_DC_FC(self) = foreground;
+    rtgui_color_t foreground;
+    rtgui_rect_t r;
+    struct rtgui_dc_buffer *dc;
+
+    r = *rect;
+    dc = (struct rtgui_dc_buffer *)self;
+    if (r.x1 > dc->width) r.x1 = dc->width;
+    if (r.x2 > dc->width) r.x2 = dc->width;
+    if (r.y1 > dc->height) r.y1 = dc->height;
+    if (r.y2 > dc->height) r.y2 = dc->height;
+
+    /* save foreground color */
+    foreground = RTGUI_DC_FC(self);
+
+    /* set background color as foreground color */
+    RTGUI_DC_FC(self) = RTGUI_DC_BC(self);
+
+    /* fill first line */
+    rtgui_dc_buffer_draw_hline(&(dc->parent), r.x1, r.x2, r.y1);
+
+    /* memory copy other lines */
+    if (r.y2 > r.y1)
+    {
+        register rt_base_t index;
+        for (index = r.y1 + 1; index < r.y2; index ++)
+        {
+            rt_memcpy(dc->pixel + index * dc->pitch,
+                      dc->pixel + r.y1 * dc->pitch,
+                      (r.x2 - r.x1) * sizeof(rtgui_color_t));
+        }
+    }
+
+    /* restore foreground color */
+    RTGUI_DC_FC(self) = foreground;
 }
 
 /* blit a dc to a hardware dc */
-static void rtgui_dc_buffer_blit(struct rtgui_dc* self, struct rtgui_point* dc_point, struct rtgui_dc* dest, rtgui_rect_t* rect)
+static void rtgui_dc_buffer_blit(struct rtgui_dc *self, struct rtgui_point *dc_point, struct rtgui_dc *dest, rtgui_rect_t *rect)
 {
-	struct rtgui_dc_buffer* dc = (struct rtgui_dc_buffer*)self;
-
-	if (dc_point == RT_NULL) dc_point = &rtgui_empty_point;
-	if (rtgui_dc_get_visible(dest) == RT_FALSE) return;
-
-	if ((dest->type == RTGUI_DC_HW) || (dest->type == RTGUI_DC_CLIENT))
-	{
-		rt_uint8_t *line_ptr, *pixels;
-		rt_uint16_t rect_width, rect_height, index, pitch;
-		rtgui_blit_line_func blit_line;
-
-		/* calculate correct width and height */
-		if (rtgui_rect_width(*rect) > (dc->width - dc_point->x))
-			rect_width = dc->width - dc_point->x;
-		else
-			rect_width = rtgui_rect_width(*rect);
-
-		if (rtgui_rect_height(*rect) > (dc->height - dc_point->y))
-			rect_height = dc->height - dc_point->y;
-		else
-			rect_height = rtgui_rect_height(*rect);
-
-		/* prepare pixel line */
-		pixels = dc->pixel + dc_point->y * dc->pitch + dc_point->x * sizeof(rtgui_color_t);
-
-		if (hw_driver->bits_per_pixel == sizeof(rtgui_color_t) * 8)
-		{
-			/* it's the same byte per pixel, draw it directly */
-			for (index = rect->y1; index < rect->y1 + rect_height; index++)
-			{
-				dest->engine->blit_line(dest, rect->x1, rect->x1 + rect_width, index, pixels);
-				pixels += dc->width * sizeof(rtgui_color_t);
-			}
-		}
-		else
-		{
-			/* get blit line function */
-			blit_line = rtgui_blit_line_get(hw_driver->bits_per_pixel/8, 4);
-			/* calculate pitch */
-			pitch = rect_width * sizeof(rtgui_color_t);
-			/* create line buffer */
-			line_ptr = (rt_uint8_t*) rtgui_malloc(rect_width * hw_driver->bits_per_pixel/8);
-
-			/* draw each line */
-			for (index = rect->y1; index < rect->y1 + rect_height; index ++)
-			{
-				/* blit on line buffer */
-				blit_line(line_ptr, (rt_uint8_t*)pixels, pitch);
-				pixels += dc->width * sizeof(rtgui_color_t);
-
-				/* draw on hardware dc */
-				dest->engine->blit_line(dest, rect->x1, rect->x1 + rect_width, index, line_ptr);
-			}
-
-			/* release line buffer */
-			rtgui_free(line_ptr);
-		}
-	}
+    struct rtgui_dc_buffer *dc = (struct rtgui_dc_buffer *)self;
+
+    if (dc_point == RT_NULL) dc_point = &rtgui_empty_point;
+    if (rtgui_dc_get_visible(dest) == RT_FALSE) return;
+
+    if ((dest->type == RTGUI_DC_HW) || (dest->type == RTGUI_DC_CLIENT))
+    {
+        rt_uint8_t *line_ptr, *pixels;
+        rt_uint16_t rect_width, rect_height, index, pitch;
+        rtgui_blit_line_func blit_line;
+
+        /* calculate correct width and height */
+        if (rtgui_rect_width(*rect) > (dc->width - dc_point->x))
+            rect_width = dc->width - dc_point->x;
+        else
+            rect_width = rtgui_rect_width(*rect);
+
+        if (rtgui_rect_height(*rect) > (dc->height - dc_point->y))
+            rect_height = dc->height - dc_point->y;
+        else
+            rect_height = rtgui_rect_height(*rect);
+
+        /* prepare pixel line */
+        pixels = dc->pixel + dc_point->y * dc->pitch + dc_point->x * sizeof(rtgui_color_t);
+
+        if (hw_driver->bits_per_pixel == sizeof(rtgui_color_t) * 8)
+        {
+            /* it's the same byte per pixel, draw it directly */
+            for (index = rect->y1; index < rect->y1 + rect_height; index++)
+            {
+                dest->engine->blit_line(dest, rect->x1, rect->x1 + rect_width, index, pixels);
+                pixels += dc->width * sizeof(rtgui_color_t);
+            }
+        }
+        else
+        {
+            /* get blit line function */
+            blit_line = rtgui_blit_line_get(hw_driver->bits_per_pixel / 8, 4);
+            /* calculate pitch */
+            pitch = rect_width * sizeof(rtgui_color_t);
+            /* create line buffer */
+            line_ptr = (rt_uint8_t *) rtgui_malloc(rect_width * hw_driver->bits_per_pixel / 8);
+
+            /* draw each line */
+            for (index = rect->y1; index < rect->y1 + rect_height; index ++)
+            {
+                /* blit on line buffer */
+                blit_line(line_ptr, (rt_uint8_t *)pixels, pitch);
+                pixels += dc->width * sizeof(rtgui_color_t);
+
+                /* draw on hardware dc */
+                dest->engine->blit_line(dest, rect->x1, rect->x1 + rect_width, index, line_ptr);
+            }
+
+            /* release line buffer */
+            rtgui_free(line_ptr);
+        }
+    }
 }
 
-static void rtgui_dc_buffer_blit_line(struct rtgui_dc* self, int x1, int x2, int y, rt_uint8_t* line_data)
+static void rtgui_dc_buffer_blit_line(struct rtgui_dc *self, int x1, int x2, int y, rt_uint8_t *line_data)
 {
-	rtgui_color_t* color_ptr;
-	struct rtgui_dc_buffer* dc = (struct rtgui_dc_buffer*)self;
+    rtgui_color_t *color_ptr;
+    struct rtgui_dc_buffer *dc = (struct rtgui_dc_buffer *)self;
 
-	RT_ASSERT(dc != RT_NULL);
-	RT_ASSERT(line_data != RT_NULL);
+    RT_ASSERT(dc != RT_NULL);
+    RT_ASSERT(line_data != RT_NULL);
 
-	/* out of range */
-	if ((x1 > dc->width) || (y > dc->height)) return;
-	/* check range */
-	if (x2 > dc->width) x2 = dc->width;
+    /* out of range */
+    if ((x1 > dc->width) || (y > dc->height)) return;
+    /* check range */
+    if (x2 > dc->width) x2 = dc->width;
 
-	color_ptr = (rtgui_color_t*)(dc->pixel + y * dc->pitch + x1 * sizeof(rtgui_color_t));
-	rt_memcpy(color_ptr, line_data, (x2 - x1) * sizeof(rtgui_color_t));
+    color_ptr = (rtgui_color_t *)(dc->pixel + y * dc->pitch + x1 * sizeof(rtgui_color_t));
+    rt_memcpy(color_ptr, line_data, (x2 - x1) * sizeof(rtgui_color_t));
 }
 
-static void rtgui_dc_buffer_set_gc(struct rtgui_dc* self, rtgui_gc_t *gc)
+static void rtgui_dc_buffer_set_gc(struct rtgui_dc *self, rtgui_gc_t *gc)
 {
-	struct rtgui_dc_buffer* dc = (struct rtgui_dc_buffer*)self;
+    struct rtgui_dc_buffer *dc = (struct rtgui_dc_buffer *)self;
 
-	dc->gc = *gc;
+    dc->gc = *gc;
 }
 
-static rtgui_gc_t *rtgui_dc_buffer_get_gc(struct rtgui_dc* self)
+static rtgui_gc_t *rtgui_dc_buffer_get_gc(struct rtgui_dc *self)
 {
-	struct rtgui_dc_buffer* dc = (struct rtgui_dc_buffer*)self;
+    struct rtgui_dc_buffer *dc = (struct rtgui_dc_buffer *)self;
 
-	return &dc->gc;
+    return &dc->gc;
 }
 
-static rt_bool_t rtgui_dc_buffer_get_visible(struct rtgui_dc* dc)
+static rt_bool_t rtgui_dc_buffer_get_visible(struct rtgui_dc *dc)
 {
-	return RT_TRUE;
+    return RT_TRUE;
 }
 
-static void rtgui_dc_buffer_get_rect(struct rtgui_dc* self, rtgui_rect_t* rect)
+static void rtgui_dc_buffer_get_rect(struct rtgui_dc *self, rtgui_rect_t *rect)
 {
-	struct rtgui_dc_buffer* dc = (struct rtgui_dc_buffer*)self;
+    struct rtgui_dc_buffer *dc = (struct rtgui_dc_buffer *)self;
 
-	rect->x1 = rect->y1 = 0;
+    rect->x1 = rect->y1 = 0;
 
-	rect->x2 = dc->width;
-	rect->y2 = dc->height;
+    rect->x2 = dc->width;
+    rect->y2 = dc->height;
 }
 

components/rtgui/common/font.c

@@ -15,7 +15,7 @@
 #include <rtgui/dc.h>
 
 static rtgui_list_t _rtgui_font_list;
-static struct rtgui_font* rtgui_default_font;
+static struct rtgui_font *rtgui_default_font;
 
 extern struct rtgui_font rtgui_font_asc16;
 extern struct rtgui_font rtgui_font_arial16;
@@ -28,131 +28,131 @@ extern struct rtgui_font rtgui_font_hz12;
 
 void rtgui_font_system_init()
 {
-	rtgui_list_init(&(_rtgui_font_list));
+    rtgui_list_init(&(_rtgui_font_list));
 
-	/* set default font to NULL */
-	rtgui_default_font = RT_NULL;
+    /* set default font to NULL */
+    rtgui_default_font = RT_NULL;
 
 #ifdef RTGUI_USING_FONT16
-	rtgui_font_system_add_font(&rtgui_font_asc16);
+    rtgui_font_system_add_font(&rtgui_font_asc16);
 #ifdef RTGUI_USING_FONTHZ
-	rtgui_font_system_add_font(&rtgui_font_hz16);
+    rtgui_font_system_add_font(&rtgui_font_hz16);
 #endif
 #endif
 
 #ifdef RTGUI_USING_FONT12
-	rtgui_font_system_add_font(&rtgui_font_asc12);
+    rtgui_font_system_add_font(&rtgui_font_asc12);
 #ifdef RTGUI_USING_FONTHZ
-	rtgui_font_system_add_font(&rtgui_font_hz12);
+    rtgui_font_system_add_font(&rtgui_font_hz12);
 #endif
 #endif
 
 #ifdef RTGUI_USING_FONT12
-	if (rtgui_default_font == RT_NULL)
-		rtgui_font_set_defaut(&rtgui_font_asc12);
+    if (rtgui_default_font == RT_NULL)
+        rtgui_font_set_defaut(&rtgui_font_asc12);
 #endif
 #ifdef RTGUI_USING_FONT16
-	if (rtgui_default_font == RT_NULL)
-		rtgui_font_set_defaut(&rtgui_font_asc16);
+    if (rtgui_default_font == RT_NULL)
+        rtgui_font_set_defaut(&rtgui_font_asc16);
 #endif
 }
 
-void rtgui_font_system_add_font(struct rtgui_font* font)
+void rtgui_font_system_add_font(struct rtgui_font *font)
 {
-	rtgui_list_init(&(font->list));
-	rtgui_list_append(&_rtgui_font_list, &(font->list));
+    rtgui_list_init(&(font->list));
+    rtgui_list_append(&_rtgui_font_list, &(font->list));
 
-	/* init font */
-	if (font->engine->font_init != RT_NULL)
-		font->engine->font_init(font);
+    /* init font */
+    if (font->engine->font_init != RT_NULL)
+        font->engine->font_init(font);
 
-	/* first refer, load it */
-	if (font->engine->font_load != RT_NULL)
-		font->engine->font_load(font);
+    /* first refer, load it */
+    if (font->engine->font_load != RT_NULL)
+        font->engine->font_load(font);
 }
 
-void rtgui_font_system_remove_font(struct rtgui_font* font)
+void rtgui_font_system_remove_font(struct rtgui_font *font)
 {
-	rtgui_list_remove(&_rtgui_font_list, &(font->list));
+    rtgui_list_remove(&_rtgui_font_list, &(font->list));
 }
 
-struct rtgui_font* rtgui_font_default()
+struct rtgui_font *rtgui_font_default()
 {
-	return rtgui_default_font;
+    return rtgui_default_font;
 }
 
-void rtgui_font_set_defaut(struct rtgui_font* font)
+void rtgui_font_set_defaut(struct rtgui_font *font)
 {
-	rtgui_default_font = font;
+    rtgui_default_font = font;
 }
 
-struct rtgui_font* rtgui_font_refer(const rt_uint8_t* family, rt_uint16_t height)
+struct rtgui_font *rtgui_font_refer(const char *family, rt_uint16_t height)
 {
-	/* search font */
-	struct rtgui_list_node* node;
-	struct rtgui_font* font;
-
-	rtgui_list_foreach(node, &_rtgui_font_list)
-	{
-		font = rtgui_list_entry(node, struct rtgui_font, list);
-		if ((rt_strncmp((const char*)font->family, (const char*)family, RTGUI_NAME_MAX) == 0) &&
-			font->height == height)
-		{
-			font->refer_count ++;
-			return font;
-		}
-	}
-
-	return RT_NULL;
+    /* search font */
+    struct rtgui_list_node *node;
+    struct rtgui_font *font;
+
+    rtgui_list_foreach(node, &_rtgui_font_list)
+    {
+        font = rtgui_list_entry(node, struct rtgui_font, list);
+        if ((rt_strncmp(font->family, family, RTGUI_NAME_MAX) == 0) &&
+                font->height == height)
+        {
+            font->refer_count ++;
+            return font;
+        }
+    }
+
+    return RT_NULL;
 }
 
-void rtgui_font_derefer(struct rtgui_font* font)
+void rtgui_font_derefer(struct rtgui_font *font)
 {
-	RT_ASSERT(font != RT_NULL);
+    RT_ASSERT(font != RT_NULL);
 
-	font->refer_count --;
+    font->refer_count --;
 
-	/* no refer, remove font */
-	if (font->refer_count == 0)
-	{
-		rtgui_font_system_remove_font(font);
-	}
+    /* no refer, remove font */
+    if (font->refer_count == 0)
+    {
+        rtgui_font_system_remove_font(font);
+    }
 }
 
 /* draw a text */
-void rtgui_font_draw(struct rtgui_font* font, struct rtgui_dc* dc, const char* text, rt_ubase_t len, struct rtgui_rect* rect)
+void rtgui_font_draw(struct rtgui_font *font, struct rtgui_dc *dc, const char *text, rt_ubase_t len, struct rtgui_rect *rect)
 {
-	RT_ASSERT(font != RT_NULL);
+    RT_ASSERT(font != RT_NULL);
 
-	if (font->engine != RT_NULL &&
-		font->engine->font_draw_text != RT_NULL)
-	{
-		font->engine->font_draw_text(font, dc, text, len, rect);
-	}
+    if (font->engine != RT_NULL &&
+            font->engine->font_draw_text != RT_NULL)
+    {
+        font->engine->font_draw_text(font, dc, text, len, rect);
+    }
 }
 
-int rtgui_font_get_string_width(struct rtgui_font* font, const char* text)
+int rtgui_font_get_string_width(struct rtgui_font *font, const char *text)
 {
-	rtgui_rect_t rect;
+    rtgui_rect_t rect;
 
-	/* get metrics */
-	rtgui_font_get_metrics(font, text, &rect);
+    /* get metrics */
+    rtgui_font_get_metrics(font, text, &rect);
 
-	return rect.x2 - rect.x1;
+    return rect.x2 - rect.x1;
 }
 
-void rtgui_font_get_metrics(struct rtgui_font* font, const char* text, rtgui_rect_t* rect)
+void rtgui_font_get_metrics(struct rtgui_font *font, const char *text, rtgui_rect_t *rect)
 {
-	RT_ASSERT(font != RT_NULL);
-
-	if (font->engine != RT_NULL &&
-		font->engine->font_get_metrics != RT_NULL)
-	{
-		font->engine->font_get_metrics(font, text, rect);
-	}
-	else
-	{
-		/* no font engine found, set rect to zero */
-		rt_memset(rect, 0, sizeof(rtgui_rect_t));
-	}
+    RT_ASSERT(font != RT_NULL);
+
+    if (font->engine != RT_NULL &&
+            font->engine->font_get_metrics != RT_NULL)
+    {
+        font->engine->font_get_metrics(font, text, rect);
+    }
+    else
+    {
+        /* no font engine found, set rect to zero */
+        rt_memset(rect, 0, sizeof(rtgui_rect_t));
+    }
 }

components/rtgui/common/font_hz_file.c

@@ -7,27 +7,27 @@
 #include <rtgui/rtgui_system.h>
 
 #ifdef RTGUI_USING_HZ_FILE
-#ifdef _WIN32
+#ifdef _WIN32_NATIVE
 #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
+#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
 
-static int _font_cache_compare(struct hz_cache* node1, struct hz_cache* node2);
+static int _font_cache_compare(struct hz_cache *node1, struct hz_cache *node2);
 
-static void rtgui_hz_file_font_load(struct rtgui_font* font);
-static void rtgui_hz_file_font_draw_text(struct rtgui_font* font, struct rtgui_dc* dc, const char* text, rt_ubase_t len, struct rtgui_rect* rect);
-static void rtgui_hz_file_font_get_metrics(struct rtgui_font* font, const char* text, rtgui_rect_t* rect);
+static void rtgui_hz_file_font_load(struct rtgui_font *font);
+static void rtgui_hz_file_font_draw_text(struct rtgui_font *font, struct rtgui_dc *dc, const char *text, rt_ubase_t len, struct rtgui_rect *rect);
+static void rtgui_hz_file_font_get_metrics(struct rtgui_font *font, const char *text, rtgui_rect_t *rect);
 const struct rtgui_font_engine rtgui_hz_file_font_engine =
 {
     RT_NULL,
@@ -37,9 +37,9 @@ const struct rtgui_font_engine rtgui_hz_file_font_engine =
 };
 
 SPLAY_PROTOTYPE(cache_tree, hz_cache, hz_node, _font_cache_compare);
-SPLAY_GENERATE (cache_tree, hz_cache, hz_node, _font_cache_compare);
+SPLAY_GENERATE(cache_tree, hz_cache, hz_node, _font_cache_compare);
 
-static int _font_cache_compare(struct hz_cache* cache_1, struct hz_cache* cache_2)
+static int _font_cache_compare(struct hz_cache *cache_1, struct hz_cache *cache_2)
 {
     if (cache_1->hz_id > cache_2->hz_id) return 1;
     if (cache_1->hz_id < cache_2->hz_id) return -1;
@@ -47,7 +47,7 @@ static int _font_cache_compare(struct hz_cache* cache_1, struct hz_cache* cache_
     return 0;
 }
 
-static rt_uint8_t* _font_cache_get(struct rtgui_hz_file_font* font, rt_uint16_t hz_id)
+static rt_uint8_t *_font_cache_get(struct rtgui_hz_file_font *font, rt_uint16_t hz_id)
 {
     rt_uint32_t seek;
     struct hz_cache *cache, search;
@@ -64,14 +64,14 @@ static rt_uint8_t* _font_cache_get(struct rtgui_hz_file_font* font, rt_uint16_t
         rtgui_exit_critical();
 
         /* found it */
-        return (rt_uint8_t*)(cache + 1);
+        return (rt_uint8_t *)(cache + 1);
     }
 
     /* exit critical */
     rtgui_exit_critical();
 
     /* can not find it, load to cache */
-    cache = (struct hz_cache*) rtgui_malloc(sizeof(struct hz_cache) + font->font_data_size);
+    cache = (struct hz_cache *) rtgui_malloc(sizeof(struct hz_cache) + font->font_data_size);
     if (cache == RT_NULL)
         return RT_NULL; /* no memory yet */
 
@@ -81,8 +81,8 @@ static rt_uint8_t* _font_cache_get(struct rtgui_hz_file_font* font, rt_uint16_t
 
     /* read hz font data */
     if ((lseek(font->fd, seek, SEEK_SET) < 0) ||
-        read(font->fd, (char*)(cache + 1), font->font_data_size) !=
-        font->font_data_size)
+            read(font->fd, (char *)(cache + 1), font->font_data_size) !=
+            font->font_data_size)
     {
         rtgui_free(cache);
         return RT_NULL;
@@ -94,7 +94,7 @@ static rt_uint8_t* _font_cache_get(struct rtgui_hz_file_font* font, rt_uint16_t
     if (font->cache_size >= HZ_CACHE_MAX)
     {
         /* remove a cache */
-        struct hz_cache* left;
+        struct hz_cache *left;
         left = font->cache_root.sph_root;
         while (SPLAY_LEFT(left, hz_node) != RT_NULL) left = SPLAY_LEFT(left, hz_node);
 
@@ -111,20 +111,20 @@ static rt_uint8_t* _font_cache_get(struct rtgui_hz_file_font* font, rt_uint16_t
     /* exit critical */
     rtgui_exit_critical();
 
-    return (rt_uint8_t*)(cache + 1);
+    return (rt_uint8_t *)(cache + 1);
 }
 
-static void rtgui_hz_file_font_load(struct rtgui_font* font)
+static void rtgui_hz_file_font_load(struct rtgui_font *font)
 {
-    struct rtgui_hz_file_font* hz_file_font = (struct rtgui_hz_file_font*)font->data;
+    struct rtgui_hz_file_font *hz_file_font = (struct rtgui_hz_file_font *)font->data;
     RT_ASSERT(hz_file_font != RT_NULL);
 
     hz_file_font->fd = open(hz_file_font->font_fn, O_RDONLY, 0);
 }
 
-static void _rtgui_hz_file_font_draw_text(struct rtgui_hz_file_font* hz_file_font, struct rtgui_dc* dc, const char* text, rt_ubase_t len, struct rtgui_rect* rect)
+static void _rtgui_hz_file_font_draw_text(struct rtgui_hz_file_font *hz_file_font, struct rtgui_dc *dc, const char *text, rt_ubase_t len, struct rtgui_rect *rect)
 {
-    rt_uint8_t* str;
+    rt_uint8_t *str;
     rtgui_color_t bc;
     rt_uint16_t style;
     register rt_base_t h, word_bytes;
@@ -134,34 +134,34 @@ static void _rtgui_hz_file_font_draw_text(struct rtgui_hz_file_font* hz_file_fon
     bc = rtgui_dc_get_gc(dc)->background;
 
     /* drawing height */
-    h = (hz_file_font->font_size + rect->y1 > rect->y2)?
+    h = (hz_file_font->font_size + rect->y1 > rect->y2) ?
         rect->y2 - rect->y1 : hz_file_font->font_size;
     word_bytes = (hz_file_font->font_size + 7) / 8;
 
-    str = (rt_uint8_t*)text;
+    str = (rt_uint8_t *)text;
 
     while (len > 0 && rect->x1 < rect->x2)
     {
-        const rt_uint8_t* font_ptr;
+        const rt_uint8_t *font_ptr;
         register rt_base_t i, j, k;
 
         /* get font pixel data */
-        font_ptr = _font_cache_get(hz_file_font, *str | (*(str+1) << 8));
+        font_ptr = _font_cache_get(hz_file_font, *str | (*(str + 1) << 8));
 
         /* draw word */
-        for (i=0; i < h; i ++)
+        for (i = 0; i < h; i ++)
         {
-            for (j=0; j < word_bytes; j++)
-                for (k=0; k < 8; k++)
+            for (j = 0; j < word_bytes; j++)
+                for (k = 0; k < 8; k++)
                 {
-                    if ( ((font_ptr[i*word_bytes + j] >> (7-k)) & 0x01) != 0 &&
-                        (rect->x1 + 8 * j + k < rect->x2))
+                    if (((font_ptr[i * word_bytes + j] >> (7 - k)) & 0x01) != 0 &&
+                            (rect->x1 + 8 * j + k < rect->x2))
                     {
-                        rtgui_dc_draw_point(dc, rect->x1 + 8*j + k, rect->y1 + i);
+                        rtgui_dc_draw_point(dc, rect->x1 + 8 * j + k, rect->y1 + i);
                     }
                     else if (style & RTGUI_TEXTSTYLE_DRAW_BACKGROUND)
                     {
-                        rtgui_dc_draw_color_point(dc, rect->x1 + 8*j + k, rect->y1 + i, bc);
+                        rtgui_dc_draw_color_point(dc, rect->x1 + 8 * j + k, rect->y1 + i, bc);
                     }
                 }
         }
@@ -173,11 +173,11 @@ static void _rtgui_hz_file_font_draw_text(struct rtgui_hz_file_font* hz_file_fon
     }
 }
 
-static void rtgui_hz_file_font_draw_text(struct rtgui_font* font, struct rtgui_dc* dc, const char* text, rt_ubase_t length, struct rtgui_rect* rect)
+static void rtgui_hz_file_font_draw_text(struct rtgui_font *font, struct rtgui_dc *dc, const char *text, rt_ubase_t length, struct rtgui_rect *rect)
 {
     rt_uint32_t len;
     struct rtgui_font *efont;
-    struct rtgui_hz_file_font* hz_file_font = (struct rtgui_hz_file_font*)font->data;
+    struct rtgui_hz_file_font *hz_file_font = (struct rtgui_hz_file_font *)font->data;
 
     RT_ASSERT(dc != RT_NULL);
     RT_ASSERT(hz_file_font != RT_NULL);
@@ -189,7 +189,7 @@ static void rtgui_hz_file_font_draw_text(struct rtgui_font* font, struct rtgui_d
     while (length > 0)
     {
         len = 0;
-        while (((rt_uint8_t)*(text + len)) < 0x80 && *(text + len) && len < length) len ++;
+        while (((rt_uint8_t) * (text + len)) < 0x80 && *(text + len) && len < length) len ++;
         /* draw text with English font */
         if (len > 0)
         {
@@ -200,7 +200,7 @@ static void rtgui_hz_file_font_draw_text(struct rtgui_font* font, struct rtgui_d
         }
 
         len = 0;
-        while (((rt_uint8_t)*(text + len)) >= 0x80 && len < length) len ++;
+        while (((rt_uint8_t) * (text + len)) >= 0x80 && len < length) len ++;
         if (len > 0)
         {
             _rtgui_hz_file_font_draw_text(hz_file_font, dc, text, len, rect);
@@ -213,14 +213,14 @@ static void rtgui_hz_file_font_draw_text(struct rtgui_font* font, struct rtgui_d
     rtgui_font_derefer(efont);
 }
 
-static void rtgui_hz_file_font_get_metrics(struct rtgui_font* font, const char* text, rtgui_rect_t* rect)
+static void rtgui_hz_file_font_get_metrics(struct rtgui_font *font, const char *text, rtgui_rect_t *rect)
 {
-    struct rtgui_hz_file_font* hz_file_font = (struct rtgui_hz_file_font*)font->data;
+    struct rtgui_hz_file_font *hz_file_font = (struct rtgui_hz_file_font *)font->data;
     RT_ASSERT(hz_file_font != RT_NULL);
 
     /* set metrics rect */
     rect->x1 = rect->y1 = 0;
-    rect->x2 = (rt_int16_t)(hz_file_font->font_size/2 * rt_strlen((const char*)text));
+    rect->x2 = (rt_int16_t)(hz_file_font->font_size / 2 * rt_strlen((const char *)text));
     rect->y2 = hz_file_font->font_size;
 }
 #endif

components/rtgui/include/rtgui/blit.h

@@ -3,7 +3,7 @@
 
 #include <rtgui/rtgui.h>
 
-typedef void (*rtgui_blit_line_func)(rt_uint8_t* dst, rt_uint8_t* src, int line);
+typedef void (*rtgui_blit_line_func)(rt_uint8_t *dst, rt_uint8_t *src, int line);
 rtgui_blit_line_func rtgui_blit_line_get(int dst_bpp, int src_bpp);
 rtgui_blit_line_func rtgui_blit_line_get_inv(int dst_bpp, int src_bpp);