mirror of
https://github.com/RT-Thread/rt-thread.git
synced 2025-01-15 20:59:22 +08:00
db06460208
The full log is at https://github.com/RTGUI/RTGUI/commits/merge_1 and it's difficult to merge the new tree commit by commit. I also converted all the file into unix eol so there are many fake diff. Big changes are noted in rtgui/doc/road_map.txt and rtgui/doc/attention.txt. Keep an eye on them if you want to migrate your old code. Note that the work is still in progress and the bsp is not prepared in trunk so far. git-svn-id: https://rt-thread.googlecode.com/svn/trunk@2092 bbd45198-f89e-11dd-88c7-29a3b14d5316
539 lines
14 KiB
C
539 lines
14 KiB
C
/*
|
|
* File : dc_client.c
|
|
* This file is part of RT-Thread RTOS
|
|
* COPYRIGHT (C) 2006 - 2009, RT-Thread Development Team
|
|
*
|
|
* The license and distribution terms for this file may be
|
|
* found in the file LICENSE in this distribution or at
|
|
* http://www.rt-thread.org/license/LICENSE
|
|
*
|
|
* Change Logs:
|
|
* Date Author Notes
|
|
* 2009-10-16 Bernard first version
|
|
* 2010-08-09 Bernard rename hardware dc to client dc
|
|
* 2010-09-13 Bernard fix rtgui_dc_client_blit_line issue, which found
|
|
* by appele
|
|
* 2010-09-14 Bernard fix vline and hline coordinate issue
|
|
*/
|
|
#include <rtgui/dc.h>
|
|
#include <rtgui/dc_hw.h>
|
|
#include <rtgui/dc_client.h>
|
|
|
|
#include <rtgui/driver.h>
|
|
#include <rtgui/rtgui_system.h>
|
|
#include <rtgui/rtgui_application.h>
|
|
#include <rtgui/rtgui_server.h>
|
|
#include <rtgui/widgets/container.h>
|
|
#include <rtgui/widgets/window.h>
|
|
#include <rtgui/widgets/title.h>
|
|
|
|
static void rtgui_dc_client_draw_point(struct rtgui_dc* dc, int x, int y);
|
|
static void rtgui_dc_client_draw_color_point(struct rtgui_dc* dc, int x, int y, rtgui_color_t color);
|
|
static void rtgui_dc_client_draw_hline(struct rtgui_dc* dc, int x1, int x2, int y);
|
|
static void rtgui_dc_client_draw_vline(struct rtgui_dc* dc, int x, int y1, int y2);
|
|
static void rtgui_dc_client_fill_rect (struct rtgui_dc* dc, rtgui_rect_t* rect);
|
|
static void rtgui_dc_client_blit_line (struct rtgui_dc* self, int x1, int x2, int y, rt_uint8_t* line_data);
|
|
static void rtgui_dc_client_blit (struct rtgui_dc* dc, struct rtgui_point* dc_point, struct rtgui_dc* dest, rtgui_rect_t* rect);
|
|
static void rtgui_dc_client_set_gc (struct rtgui_dc* dc, rtgui_gc_t *gc);
|
|
static rtgui_gc_t *rtgui_dc_client_get_gc (struct rtgui_dc* dc);
|
|
static rt_bool_t rtgui_dc_client_fini(struct rtgui_dc* dc);
|
|
static rt_bool_t rtgui_dc_client_get_visible(struct rtgui_dc* dc);
|
|
static void rtgui_dc_client_get_rect(struct rtgui_dc* dc, rtgui_rect_t* rect);
|
|
|
|
#define hw_driver (rtgui_graphic_driver_get_default())
|
|
#define dc_set_foreground(c) dc->gc.foreground = c
|
|
#define dc_set_background(c) dc->gc.background = c
|
|
#define _int_swap(x, y) do {x ^= y; y ^= x; x ^= y;} while (0)
|
|
|
|
struct rtgui_dc* rtgui_dc_begin_drawing(rtgui_widget_t* owner)
|
|
{
|
|
RT_ASSERT(owner != RT_NULL);
|
|
|
|
if ((rtgui_region_is_flat(&owner->clip) == RT_EOK) &&
|
|
rtgui_rect_is_equal(&(owner->extent), &(owner->clip.extents)) == RT_EOK)
|
|
return rtgui_dc_hw_create(owner);
|
|
else
|
|
return rtgui_dc_client_create(owner);
|
|
}
|
|
|
|
void rtgui_dc_end_drawing(struct rtgui_dc* dc)
|
|
{
|
|
dc->engine->fini(dc);
|
|
}
|
|
|
|
const struct rtgui_dc_engine dc_client_engine =
|
|
{
|
|
rtgui_dc_client_draw_point,
|
|
rtgui_dc_client_draw_color_point,
|
|
rtgui_dc_client_draw_vline,
|
|
rtgui_dc_client_draw_hline,
|
|
rtgui_dc_client_fill_rect,
|
|
rtgui_dc_client_blit_line,
|
|
rtgui_dc_client_blit,
|
|
|
|
rtgui_dc_client_set_gc,
|
|
rtgui_dc_client_get_gc,
|
|
|
|
rtgui_dc_client_get_visible,
|
|
rtgui_dc_client_get_rect,
|
|
|
|
rtgui_dc_client_fini,
|
|
};
|
|
|
|
void rtgui_dc_client_init(rtgui_widget_t* owner)
|
|
{
|
|
struct rtgui_dc* dc;
|
|
|
|
RT_ASSERT(owner != RT_NULL);
|
|
|
|
dc = RTGUI_WIDGET_DC(owner);
|
|
dc->type = RTGUI_DC_CLIENT;
|
|
dc->engine = &dc_client_engine;
|
|
}
|
|
|
|
extern struct rt_mutex cursor_mutex;
|
|
extern void rtgui_mouse_show_cursor(void);
|
|
extern void rtgui_mouse_hide_cursor(void);
|
|
struct rtgui_dc* rtgui_dc_client_create(rtgui_widget_t* owner)
|
|
{
|
|
struct rtgui_dc* dc;
|
|
rtgui_widget_t* widget;
|
|
|
|
/* adjudge owner */
|
|
if (owner == RT_NULL || owner->toplevel == RT_NULL) return RT_NULL;
|
|
if (!RTGUI_IS_TOPLEVEL(owner->toplevel)) return RT_NULL;
|
|
|
|
dc = RTGUI_WIDGET_DC(owner);
|
|
/* set init visible as true */
|
|
RTGUI_WIDGET_DC_SET_VISIBLE(owner);
|
|
|
|
/* check widget visible */
|
|
widget = owner;
|
|
while (widget != RT_NULL)
|
|
{
|
|
if (RTGUI_WIDGET_IS_HIDE(widget))
|
|
{
|
|
RTGUI_WIDGET_DC_SET_UNVISIBLE(owner);
|
|
return RT_NULL;
|
|
}
|
|
|
|
widget = widget->parent;
|
|
}
|
|
|
|
if (RTGUI_IS_WINTITLE(owner->toplevel))
|
|
{
|
|
rtgui_toplevel_t* top = RTGUI_TOPLEVEL(owner->toplevel);
|
|
top->drawing ++;
|
|
|
|
if (top->drawing == 1)
|
|
{
|
|
#ifdef RTGUI_USING_MOUSE_CURSOR
|
|
#ifdef _WIN32
|
|
rt_mutex_take(&cursor_mutex, RT_WAITING_FOREVER);
|
|
rt_kprintf("hide cursor\n");
|
|
rtgui_mouse_hide_cursor();
|
|
#else
|
|
/* hide cursor */
|
|
rtgui_mouse_hide_cursor();
|
|
#endif
|
|
#endif
|
|
}
|
|
}
|
|
else if (RTGUI_IS_APPLICATION(owner->toplevel))
|
|
{
|
|
RT_ASSERT(0);
|
|
}
|
|
else if (RTGUI_IS_WIN(owner->toplevel))
|
|
{
|
|
rtgui_toplevel_t* top = RTGUI_TOPLEVEL(owner->toplevel);
|
|
top->drawing ++;
|
|
|
|
if (top->drawing == 1)
|
|
{
|
|
#ifdef _WIN32
|
|
#ifdef RTGUI_USING_MOUSE_CURSOR
|
|
rt_mutex_take(&cursor_mutex, RT_WAITING_FOREVER);
|
|
rt_kprintf("hide cursor\n");
|
|
rtgui_mouse_hide_cursor();
|
|
#endif
|
|
#else
|
|
/* send draw begin to server */
|
|
struct rtgui_event_update_begin eupdate;
|
|
RTGUI_EVENT_UPDATE_BEGIN_INIT(&(eupdate));
|
|
eupdate.rect = RTGUI_WIDGET(top)->extent;
|
|
|
|
rtgui_server_post_event((struct rtgui_event*)&eupdate, sizeof(eupdate));
|
|
#endif
|
|
}
|
|
}
|
|
|
|
return dc;
|
|
}
|
|
|
|
static rt_bool_t rtgui_dc_client_fini(struct rtgui_dc* dc)
|
|
{
|
|
rtgui_widget_t* owner;
|
|
|
|
if (dc == RT_NULL || dc->type != RTGUI_DC_CLIENT) return RT_FALSE;
|
|
|
|
/* get owner */
|
|
owner = RTGUI_CONTAINER_OF(dc, struct rtgui_widget, dc_type);
|
|
|
|
if (RTGUI_IS_WINTITLE(owner->toplevel))
|
|
{
|
|
/* update title extent */
|
|
rtgui_toplevel_t* top = RTGUI_TOPLEVEL(owner->toplevel);
|
|
|
|
top->drawing --;
|
|
if ((top->drawing == 0) && RTGUI_WIDGET_IS_DC_VISIBLE(owner))
|
|
{
|
|
#ifdef _WIN32
|
|
#ifdef RTGUI_USING_MOUSE_CURSOR
|
|
rt_mutex_release(&cursor_mutex);
|
|
/* show cursor */
|
|
rtgui_mouse_show_cursor();
|
|
rt_kprintf("show cursor\n");
|
|
#endif
|
|
/* update screen */
|
|
rtgui_graphic_driver_screen_update(hw_driver, &(owner->extent));
|
|
#else
|
|
#ifdef RTGUI_USING_MOUSE_CURSOR
|
|
/* show cursor */
|
|
rtgui_mouse_show_cursor();
|
|
#endif
|
|
|
|
/* update screen */
|
|
rtgui_graphic_driver_screen_update(hw_driver, &(owner->extent));
|
|
#endif
|
|
}
|
|
}
|
|
else if (RTGUI_IS_APPLICATION(owner->toplevel) ||
|
|
RTGUI_IS_WIN(owner->toplevel))
|
|
{
|
|
rtgui_toplevel_t* top = RTGUI_TOPLEVEL(owner->toplevel);
|
|
top->drawing --;
|
|
|
|
if ((top->drawing == 0) && RTGUI_WIDGET_IS_DC_VISIBLE(owner))
|
|
{
|
|
#ifdef _WIN32
|
|
#ifdef RTGUI_USING_MOUSE_CURSOR
|
|
rt_mutex_release(&cursor_mutex);
|
|
/* show cursor */
|
|
rtgui_mouse_show_cursor();
|
|
rt_kprintf("show cursor\n");
|
|
#endif
|
|
/* update screen */
|
|
rtgui_graphic_driver_screen_update(hw_driver, &(owner->extent));
|
|
#else
|
|
/* send to server to end drawing */
|
|
struct rtgui_event_update_end eupdate;
|
|
RTGUI_EVENT_UPDATE_END_INIT(&(eupdate));
|
|
eupdate.rect = owner->extent;
|
|
|
|
rtgui_server_post_event((struct rtgui_event*)&eupdate, sizeof(eupdate));
|
|
#endif
|
|
}
|
|
}
|
|
|
|
return RT_TRUE;
|
|
}
|
|
|
|
/*
|
|
* draw a logic point on device
|
|
*/
|
|
static void rtgui_dc_client_draw_point(struct rtgui_dc* self, int x, int y)
|
|
{
|
|
rtgui_rect_t rect;
|
|
rtgui_widget_t *owner;
|
|
|
|
if (self == RT_NULL) return;
|
|
|
|
/* get owner */
|
|
owner = RTGUI_CONTAINER_OF(self, struct rtgui_widget, dc_type);
|
|
if (!RTGUI_WIDGET_IS_DC_VISIBLE(owner)) return;
|
|
|
|
x = x + owner->extent.x1;
|
|
y = y + owner->extent.y1;
|
|
|
|
if (rtgui_region_contains_point(&(owner->clip), x, y, &rect) == RT_EOK)
|
|
{
|
|
/* draw this point */
|
|
hw_driver->ops->set_pixel(&(owner->gc.foreground), x, y);
|
|
}
|
|
}
|
|
|
|
static void rtgui_dc_client_draw_color_point(struct rtgui_dc* self, int x, int y, rtgui_color_t color)
|
|
{
|
|
rtgui_rect_t rect;
|
|
rtgui_widget_t *owner;
|
|
|
|
if (self == RT_NULL) return;
|
|
|
|
/* get owner */
|
|
owner = RTGUI_CONTAINER_OF(self, struct rtgui_widget, dc_type);
|
|
if (!RTGUI_WIDGET_IS_DC_VISIBLE(owner)) return;
|
|
|
|
x = x + owner->extent.x1;
|
|
y = y + owner->extent.y1;
|
|
|
|
if (rtgui_region_contains_point(&(owner->clip), x, y, &rect) == RT_EOK)
|
|
{
|
|
/* draw this point */
|
|
hw_driver->ops->set_pixel(&color, x, y);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* draw a logic vertical line on device
|
|
*/
|
|
static void rtgui_dc_client_draw_vline(struct rtgui_dc* self, int x, int y1, int y2)
|
|
{
|
|
register rt_base_t index;
|
|
rtgui_widget_t *owner;
|
|
|
|
if (self == RT_NULL) return;
|
|
|
|
/* get owner */
|
|
owner = RTGUI_CONTAINER_OF(self, struct rtgui_widget, dc_type);
|
|
if (!RTGUI_WIDGET_IS_DC_VISIBLE(owner)) return;
|
|
|
|
x = x + owner->extent.x1;
|
|
y1 = y1 + owner->extent.y1;
|
|
y2 = y2 + owner->extent.y1;
|
|
if (y1 > y2) _int_swap(y1, y2);
|
|
|
|
if (owner->clip.data == RT_NULL)
|
|
{
|
|
rtgui_rect_t* prect;
|
|
|
|
prect = &(owner->clip.extents);
|
|
|
|
/* calculate vline intersect */
|
|
if (prect->x1 > x || prect->x2 <= x) return;
|
|
if (prect->y2 <= y1 || prect->y1 > y2) return;
|
|
|
|
if (prect->y1 > y1) y1 = prect->y1;
|
|
if (prect->y2 < y2) y2 = prect->y2;
|
|
|
|
/* draw vline */
|
|
hw_driver->ops->draw_vline(&(owner->gc.foreground), x, y1, y2);
|
|
}
|
|
else for (index = 0; index < rtgui_region_num_rects(&(owner->clip)); index ++)
|
|
{
|
|
rtgui_rect_t* prect;
|
|
register rt_base_t draw_y1, draw_y2;
|
|
|
|
prect = ((rtgui_rect_t *)(owner->clip.data + index + 1));
|
|
draw_y1 = y1;
|
|
draw_y2 = y2;
|
|
|
|
/* calculate vline clip */
|
|
if (prect->x1 > x || prect->x2 <= x) continue;
|
|
if (prect->y2 <= y1 || prect->y1 > y2) continue;
|
|
|
|
if (prect->y1 > y1) draw_y1 = prect->y1;
|
|
if (prect->y2 < y2) draw_y2 = prect->y2;
|
|
|
|
/* draw vline */
|
|
hw_driver->ops->draw_vline(&(owner->gc.foreground), x, draw_y1, draw_y2);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* draw a logic horizontal line on device
|
|
*/
|
|
static void rtgui_dc_client_draw_hline(struct rtgui_dc* self, int x1, int x2, int y)
|
|
{
|
|
register rt_base_t index;
|
|
rtgui_widget_t *owner;
|
|
|
|
if (self == RT_NULL) return;
|
|
|
|
/* get owner */
|
|
owner = RTGUI_CONTAINER_OF(self, struct rtgui_widget, dc_type);
|
|
if (!RTGUI_WIDGET_IS_DC_VISIBLE(owner)) return;
|
|
|
|
/* convert logic to device */
|
|
x1 = x1 + owner->extent.x1;
|
|
x2 = x2 + owner->extent.x1;
|
|
if (x1 > x2) _int_swap(x1, x2);
|
|
y = y + owner->extent.y1;
|
|
|
|
if (owner->clip.data == RT_NULL)
|
|
{
|
|
rtgui_rect_t* prect;
|
|
|
|
prect = &(owner->clip.extents);
|
|
|
|
/* calculate vline intersect */
|
|
if (prect->y1 > y || prect->y2 <= y ) return;
|
|
if (prect->x2 <= x1 || prect->x1 > x2) return;
|
|
|
|
if (prect->x1 > x1) x1 = prect->x1;
|
|
if (prect->x2 < x2) x2 = prect->x2;
|
|
|
|
/* draw hline */
|
|
hw_driver->ops->draw_hline(&(owner->gc.foreground), x1, x2, y);
|
|
}
|
|
else for (index = 0; index < rtgui_region_num_rects(&(owner->clip)); index ++)
|
|
{
|
|
rtgui_rect_t* prect;
|
|
register rt_base_t draw_x1, draw_x2;
|
|
|
|
prect = ((rtgui_rect_t *)(owner->clip.data + index + 1));
|
|
draw_x1 = x1;
|
|
draw_x2 = x2;
|
|
|
|
/* calculate hline clip */
|
|
if (prect->y1 > y || prect->y2 <= y ) continue;
|
|
if (prect->x2 <= x1 || prect->x1 > x2) continue;
|
|
|
|
if (prect->x1 > x1) draw_x1 = prect->x1;
|
|
if (prect->x2 < x2) draw_x2 = prect->x2;
|
|
|
|
/* draw hline */
|
|
hw_driver->ops->draw_hline(&(owner->gc.foreground), draw_x1, draw_x2, y);
|
|
}
|
|
}
|
|
|
|
static void rtgui_dc_client_fill_rect (struct rtgui_dc* self, struct rtgui_rect* rect)
|
|
{
|
|
rtgui_color_t foreground;
|
|
register rt_base_t index;
|
|
rtgui_widget_t *owner;
|
|
|
|
if (self == RT_NULL) return;
|
|
|
|
/* get owner */
|
|
owner = RTGUI_CONTAINER_OF(self, struct rtgui_widget, dc_type);
|
|
if (!RTGUI_WIDGET_IS_DC_VISIBLE(owner)) return;
|
|
|
|
/* save foreground color */
|
|
foreground = owner->gc.foreground;
|
|
|
|
/* set background color as foreground color */
|
|
owner->gc.foreground = owner->gc.background;
|
|
|
|
/* fill rect */
|
|
for (index = rect->y1; index < rect->y2; index ++)
|
|
{
|
|
rtgui_dc_client_draw_hline(self, rect->x1, rect->x2, index);
|
|
}
|
|
|
|
/* restore foreground color */
|
|
owner->gc.foreground = foreground;
|
|
}
|
|
|
|
static void rtgui_dc_client_blit_line (struct rtgui_dc* self, int x1, int x2, int y, rt_uint8_t* line_data)
|
|
{
|
|
register rt_base_t index;
|
|
rtgui_widget_t *owner;
|
|
|
|
if (self == RT_NULL) return;
|
|
|
|
/* get owner */
|
|
owner = RTGUI_CONTAINER_OF(self, struct rtgui_widget, dc_type);
|
|
if (!RTGUI_WIDGET_IS_DC_VISIBLE(owner)) return;
|
|
|
|
/* convert logic to device */
|
|
x1 = x1 + owner->extent.x1;
|
|
x2 = x2 + owner->extent.x1;
|
|
if (x1 > x2) _int_swap(x1, x2);
|
|
y = y + owner->extent.y1;
|
|
|
|
if (rtgui_region_is_flat(&(owner->clip)) == RT_EOK)
|
|
{
|
|
rtgui_rect_t* prect;
|
|
int offset = 0;
|
|
prect = &(owner->clip.extents);
|
|
|
|
/* calculate vline intersect */
|
|
if (prect->y1 > y || prect->y2 <= y ) return;
|
|
if (prect->x2 <= x1 || prect->x1 > x2) return;
|
|
|
|
if (prect->x1 > x1) x1 = prect->x1;
|
|
if (prect->x2 < x2) x2 = prect->x2;
|
|
|
|
/* patch note:
|
|
* We need to adjust the offset when update widget clip!
|
|
* Of course at ordinary times for 0. General */
|
|
offset = owner->clip.extents.x1 - owner->extent.x1;
|
|
offset = offset * hw_driver->bits_per_pixel/8;
|
|
/* draw hline */
|
|
hw_driver->ops->draw_raw_hline(line_data+offset, x1, x2, y);
|
|
}
|
|
else for (index = 0; index < rtgui_region_num_rects(&(owner->clip)); index ++)
|
|
{
|
|
rtgui_rect_t* prect;
|
|
register rt_base_t draw_x1, draw_x2;
|
|
|
|
prect = ((rtgui_rect_t *)(owner->clip.data + index + 1));
|
|
draw_x1 = x1;
|
|
draw_x2 = x2;
|
|
|
|
/* calculate hline clip */
|
|
if (prect->y1 > y || prect->y2 <= y ) continue;
|
|
if (prect->x2 <= x1 || prect->x1 > x2) continue;
|
|
|
|
if (prect->x1 > x1) draw_x1 = prect->x1;
|
|
if (prect->x2 < x2) draw_x2 = prect->x2;
|
|
|
|
/* draw hline */
|
|
hw_driver->ops->draw_raw_hline(line_data + (draw_x1 - x1) * hw_driver->bits_per_pixel/8, draw_x1, draw_x2, y);
|
|
}
|
|
}
|
|
|
|
static void rtgui_dc_client_blit(struct rtgui_dc* dc, struct rtgui_point* dc_point, struct rtgui_dc* dest, rtgui_rect_t* rect)
|
|
{
|
|
/* not blit in hardware dc */
|
|
return ;
|
|
}
|
|
|
|
static void rtgui_dc_client_set_gc(struct rtgui_dc* self, rtgui_gc_t *gc)
|
|
{
|
|
rtgui_widget_t *owner;
|
|
|
|
if (self == RT_NULL) return;
|
|
|
|
/* get owner */
|
|
owner = RTGUI_CONTAINER_OF(self, struct rtgui_widget, dc_type);
|
|
owner->gc = *gc;
|
|
}
|
|
|
|
static rtgui_gc_t* rtgui_dc_client_get_gc(struct rtgui_dc* self)
|
|
{
|
|
rtgui_widget_t *owner;
|
|
|
|
RT_ASSERT(self != RT_NULL);
|
|
|
|
/* get owner */
|
|
owner = RTGUI_CONTAINER_OF(self, struct rtgui_widget, dc_type);
|
|
|
|
return &(owner->gc);
|
|
}
|
|
|
|
static rt_bool_t rtgui_dc_client_get_visible(struct rtgui_dc* self)
|
|
{
|
|
rtgui_widget_t *owner;
|
|
|
|
if (self == RT_NULL) return RT_FALSE;
|
|
|
|
/* get owner */
|
|
owner = RTGUI_CONTAINER_OF(self, struct rtgui_widget, dc_type);
|
|
if (!RTGUI_WIDGET_IS_DC_VISIBLE(owner)) return RT_FALSE;
|
|
|
|
return RT_TRUE;
|
|
}
|
|
|
|
static void rtgui_dc_client_get_rect(struct rtgui_dc* self, rtgui_rect_t* rect)
|
|
{
|
|
rtgui_widget_t *owner;
|
|
|
|
if (self == RT_NULL) return;
|
|
|
|
/* get owner */
|
|
owner = RTGUI_CONTAINER_OF(self, struct rtgui_widget, dc_type);
|
|
rtgui_widget_get_rect(owner, rect);
|
|
}
|
|
|