mirror of
https://github.com/RT-Thread/rt-thread.git
synced 2026-09-28 16:14:20 +08:00
[GUI Engine] Add RTGUI as a GUI Engine
This commit is contained in:
Bernard Xiong
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,178 @@
|
||||
/*
|
||||
* File : color.h
|
||||
* 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
|
||||
* 2012-01-24 onelife add mono color support
|
||||
*/
|
||||
#ifndef __RTGUI_COLOR_H__
|
||||
#define __RTGUI_COLOR_H__
|
||||
|
||||
#include <rtgui/rtgui.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/*
|
||||
* The color used in the GUI:
|
||||
*
|
||||
* bit bit
|
||||
* RGB565 15 R,G,B 0
|
||||
* BGR565 15 B,G,R 0
|
||||
* RGB888 23 R,G,B 0
|
||||
* ARGB888 31 A,R,G,B 0
|
||||
* RGBA888 31 R,G,B,A 0
|
||||
* ABGR888 31 A,B,G,R 0
|
||||
*
|
||||
* The rtgui_color is defined as ARGB888.
|
||||
* bit31 A,R,G,B bit0
|
||||
*/
|
||||
#define RTGUI_ARGB(a, r, g, b) \
|
||||
((rtgui_color_t)(((rt_uint8_t)(b)|\
|
||||
(((unsigned long)(rt_uint8_t)(g))<<8))|\
|
||||
(((unsigned long)(rt_uint8_t)(r))<<16)|\
|
||||
(((unsigned long)(rt_uint8_t)(a))<<24)))
|
||||
#define RTGUI_RGB(r, g, b) RTGUI_ARGB(255, (r), (g), (b))
|
||||
|
||||
#define RTGUI_RGB_B(c) ((c) & 0xff)
|
||||
#define RTGUI_RGB_G(c) (((c) >> 8) & 0xff)
|
||||
#define RTGUI_RGB_R(c) (((c) >> 16) & 0xff)
|
||||
#define RTGUI_RGB_A(c) (((c) >> 24) & 0xff)
|
||||
|
||||
extern const rtgui_color_t default_foreground;
|
||||
extern const rtgui_color_t default_background;
|
||||
|
||||
/* it's better use these color definitions */
|
||||
#define RED RTGUI_RGB(0xff, 0x00, 0x00)
|
||||
#define GREEN RTGUI_RGB(0x00, 0xff, 0x00)
|
||||
#define BLUE RTGUI_RGB(0x00, 0x00, 0xff)
|
||||
#define BLACK RTGUI_RGB(0x00, 0x00, 0x00)
|
||||
#define WHITE RTGUI_RGB(0xff, 0xff, 0xff)
|
||||
#define HIGH_LIGHT RTGUI_RGB(0xfc, 0xfc, 0xfc)
|
||||
#define DARK_GREY RTGUI_RGB(0x7f, 0x7f, 0x7f)
|
||||
#define LIGHT_GREY RTGUI_RGB(0xc0, 0xc0, 0xc0)
|
||||
#define TRANSPARENT RTGUI_ARGB(0, 0, 0, 0)
|
||||
|
||||
extern const rtgui_color_t red;
|
||||
extern const rtgui_color_t green;
|
||||
extern const rtgui_color_t blue;
|
||||
extern const rtgui_color_t black;
|
||||
extern const rtgui_color_t white;
|
||||
extern const rtgui_color_t high_light;
|
||||
extern const rtgui_color_t dark_grey;
|
||||
extern const rtgui_color_t light_grey;
|
||||
|
||||
/*
|
||||
* RTGUI default color format: ARGB
|
||||
* AAAA AAAA RRRR RRRR GGGG GGGG BBBB BBBB
|
||||
* 31 0
|
||||
*/
|
||||
|
||||
/* convert rtgui color to mono */
|
||||
rt_inline rt_uint8_t rtgui_color_to_mono(rtgui_color_t c)
|
||||
{
|
||||
rt_uint8_t pixel;
|
||||
|
||||
pixel = (RTGUI_RGB_R(c) | RTGUI_RGB_G(c) | RTGUI_RGB_B(c)) ? 0x01 : 0x00;
|
||||
return pixel;
|
||||
}
|
||||
|
||||
rt_inline rtgui_color_t rtgui_color_from_mono(rt_uint8_t pixel)
|
||||
{
|
||||
rtgui_color_t color;
|
||||
|
||||
if (pixel)
|
||||
{
|
||||
color = white;
|
||||
}
|
||||
else
|
||||
{
|
||||
color = black;
|
||||
}
|
||||
return color;
|
||||
}
|
||||
|
||||
/* convert rtgui color to RRRRRGGGGGGBBBBB */
|
||||
rt_inline rt_uint16_t rtgui_color_to_565(rtgui_color_t c)
|
||||
{
|
||||
rt_uint16_t pixel;
|
||||
|
||||
pixel = (rt_uint16_t)(((RTGUI_RGB_R(c) >> 3) << 11) | ((RTGUI_RGB_G(c) >> 2) << 5) | (RTGUI_RGB_B(c) >> 3));
|
||||
|
||||
return pixel;
|
||||
}
|
||||
|
||||
rt_inline rtgui_color_t rtgui_color_from_565(rt_uint16_t pixel)
|
||||
{
|
||||
rt_uint16_t r, g, b;
|
||||
rtgui_color_t color;
|
||||
|
||||
r = (pixel >> 11) & 0x1f;
|
||||
g = (pixel >> 5) & 0x3f;
|
||||
b = pixel & 0x1f;
|
||||
|
||||
color = b * 255 / 31 + ((g * 255 / 63) << 8) + ((r * 255 / 31) << 16);
|
||||
|
||||
return color;
|
||||
}
|
||||
|
||||
/* convert rtgui color to BBBBBGGGGGGRRRRR */
|
||||
rt_inline rt_uint16_t rtgui_color_to_565p(rtgui_color_t c)
|
||||
{
|
||||
rt_uint16_t pixel;
|
||||
|
||||
pixel = (rt_uint16_t)(((RTGUI_RGB_B(c) >> 3) << 11) | ((RTGUI_RGB_G(c) >> 2) << 5) | (RTGUI_RGB_R(c) >> 3));
|
||||
return pixel;
|
||||
}
|
||||
|
||||
rt_inline rtgui_color_t rtgui_color_from_565p(rt_uint16_t pixel)
|
||||
{
|
||||
rt_uint8_t r, g, b;
|
||||
rtgui_color_t color;
|
||||
|
||||
r = pixel & 0x1f;
|
||||
g = (pixel >> 5) & 0x3f;
|
||||
b = (pixel >> 11) & 0x1f;
|
||||
|
||||
color = b * 255 / 31 + ((g * 255 / 63) << 8) + ((r * 255 / 31) << 16);
|
||||
|
||||
return color;
|
||||
}
|
||||
|
||||
/* convert rtgui color to RGB */
|
||||
rt_inline rt_uint32_t rtgui_color_to_888(rtgui_color_t c)
|
||||
{
|
||||
rt_uint32_t pixel;
|
||||
|
||||
pixel = RTGUI_RGB_R(c) << 16 | RTGUI_RGB_G(c) << 8 | RTGUI_RGB_B(c);
|
||||
return pixel;
|
||||
}
|
||||
|
||||
rt_inline rtgui_color_t rtgui_color_from_888(rt_uint32_t pixel)
|
||||
{
|
||||
rtgui_color_t color;
|
||||
|
||||
color = RTGUI_RGB(((pixel >> 16) & 0xff), ((pixel >> 8) & 0xff), pixel & 0xff);
|
||||
|
||||
return color;
|
||||
}
|
||||
|
||||
/* get the bits of specified pixle format */
|
||||
rt_uint8_t rtgui_color_get_bits(rt_uint8_t pixel_format) RTGUI_PURE;
|
||||
/* get the bytes of specified pixle format */
|
||||
rt_uint8_t rtgui_color_get_bpp(rt_uint8_t pixel_format) RTGUI_PURE;
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,27 @@
|
||||
/*
|
||||
* File : dc_buffer.h
|
||||
* This file is part of RT-Thread RTOS
|
||||
* COPYRIGHT (C) 2006 - 2010, 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
|
||||
* 2010-04-10 Bernard first version
|
||||
* 2010-06-14 Bernard embedded hardware dc to each widget
|
||||
* 2010-08-09 Bernard rename hardware dc to client dc
|
||||
*/
|
||||
|
||||
#ifndef __RTGUI_DC_CLIENT_H__
|
||||
#define __RTGUI_DC_CLIENT_H__
|
||||
|
||||
#include <rtgui/dc.h>
|
||||
|
||||
/* create a hardware dc */
|
||||
struct rtgui_dc *rtgui_dc_client_create(rtgui_widget_t *owner);
|
||||
void rtgui_dc_client_init(rtgui_widget_t *owner);
|
||||
|
||||
#endif
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,24 @@
|
||||
/*
|
||||
* File : dc_buffer.h
|
||||
* This file is part of RT-Thread RTOS
|
||||
* COPYRIGHT (C) 2006 - 2010, 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
|
||||
* 2010-04-10 Bernard first version
|
||||
* 2010-06-14 Bernard embedded hardware dc to each widget
|
||||
*/
|
||||
#ifndef __RTGUI_DC_HW_H__
|
||||
#define __RTGUI_DC_HW_H__
|
||||
|
||||
#include <rtgui/dc.h>
|
||||
|
||||
/* create a hardware dc */
|
||||
struct rtgui_dc *rtgui_dc_hw_create(rtgui_widget_t *owner);
|
||||
|
||||
#endif
|
||||
|
||||
@@ -0,0 +1,40 @@
|
||||
#ifndef __RTGUI_DC_TRANS_H__
|
||||
#define __RTGUI_DC_TRANS_H__
|
||||
|
||||
#include <rtgui/dc.h>
|
||||
#include <rtgui/matrix.h>
|
||||
|
||||
struct rtgui_dc_trans;
|
||||
|
||||
/** Create a dc translator on the dc @owner
|
||||
*
|
||||
* @return RT_NULL is there is no memory.
|
||||
*/
|
||||
struct rtgui_dc_trans* rtgui_dc_trans_create(struct rtgui_dc *owner);
|
||||
|
||||
/** Rotate the dc clockwise.
|
||||
*
|
||||
* @param degree the degree to rotate.
|
||||
*/
|
||||
void rtgui_dc_trans_rotate(struct rtgui_dc_trans *dct, double degree);
|
||||
|
||||
void rtgui_dc_trans_set_aa(struct rtgui_dc_trans *dct, int use_aa);
|
||||
|
||||
void rtgui_dc_trans_scale(struct rtgui_dc_trans *dct, double sx, double sy);
|
||||
|
||||
/** Move the dc
|
||||
*
|
||||
* The unit of @dx and @dy is pixel.
|
||||
*/
|
||||
void rtgui_dc_trans_move(struct rtgui_dc_trans *dct, int dx, int dy);
|
||||
|
||||
void rtgui_dc_trans_get_new_wh(struct rtgui_dc_trans *dct, int *new_w, int *new_h);
|
||||
|
||||
void rtgui_dc_trans_blit(struct rtgui_dc_trans *dct,
|
||||
struct rtgui_point *dc_point,
|
||||
struct rtgui_dc *dest,
|
||||
struct rtgui_rect *rect);
|
||||
|
||||
void rtgui_dc_trans_destroy(struct rtgui_dc_trans *dct);
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,107 @@
|
||||
/*
|
||||
* 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>
|
||||
|
||||
/* graphic driver operations */
|
||||
struct rtgui_graphic_driver_ops
|
||||
{
|
||||
/* set and get pixel in (x, y) */
|
||||
void (*set_pixel)(rtgui_color_t *c, int x, int y);
|
||||
void (*get_pixel)(rtgui_color_t *c, int x, int y);
|
||||
|
||||
void (*draw_hline)(rtgui_color_t *c, int x1, int x2, int y);
|
||||
void (*draw_vline)(rtgui_color_t *c, int x , int y1, int y2);
|
||||
|
||||
/* draw raw hline */
|
||||
void (*draw_raw_hline)(rt_uint8_t *pixels, int x1, int x2, int y);
|
||||
};
|
||||
|
||||
/* graphic extension operations */
|
||||
struct rtgui_graphic_ext_ops
|
||||
{
|
||||
/* some 2D operations */
|
||||
void (*draw_line)(rtgui_color_t *c, int x1, int y1, int x2, int y2);
|
||||
|
||||
void (*draw_rect)(rtgui_color_t *c, int x1, int y1, int x2, int y2);
|
||||
void (*fill_rect)(rtgui_color_t *c, int x1, int y1, int x2, int y2);
|
||||
|
||||
void (*draw_circle)(rtgui_color_t *c, int x, int y, int r);
|
||||
void (*fill_circle)(rtgui_color_t *c, int x, int y, int r);
|
||||
|
||||
void (*draw_ellipse)(rtgui_color_t *c, int x, int y, int rx, int ry);
|
||||
void (*fill_ellipse)(rtgui_color_t *c, int x, int y, int rx, int ry);
|
||||
};
|
||||
|
||||
struct rtgui_graphic_driver
|
||||
{
|
||||
/* pixel format and byte per pixel */
|
||||
rt_uint8_t pixel_format;
|
||||
rt_uint8_t bits_per_pixel;
|
||||
rt_uint16_t pitch;
|
||||
|
||||
/* screen width and height */
|
||||
rt_uint16_t width;
|
||||
rt_uint16_t height;
|
||||
|
||||
/* framebuffer address and ops */
|
||||
rt_uint8_t *framebuffer;
|
||||
struct rt_device* device;
|
||||
|
||||
const struct rtgui_graphic_driver_ops *ops;
|
||||
const struct rtgui_graphic_ext_ops *ext_ops;
|
||||
};
|
||||
|
||||
struct rtgui_graphic_driver *rtgui_graphic_driver_get_default(void);
|
||||
|
||||
void rtgui_graphic_driver_get_rect(const struct rtgui_graphic_driver *driver, rtgui_rect_t *rect);
|
||||
void rtgui_graphic_driver_screen_update(const struct rtgui_graphic_driver *driver, rtgui_rect_t *rect);
|
||||
rt_uint8_t *rtgui_graphic_driver_get_framebuffer(const struct rtgui_graphic_driver *driver);
|
||||
|
||||
rt_err_t rtgui_graphic_set_device(rt_device_t device);
|
||||
void rtgui_graphic_driver_set_framebuffer(void *fb);
|
||||
|
||||
rt_inline struct rtgui_graphic_driver *rtgui_graphic_get_device()
|
||||
{
|
||||
return rtgui_graphic_driver_get_default();
|
||||
}
|
||||
|
||||
#ifdef RTGUI_USING_HW_CURSOR
|
||||
/*
|
||||
* hardware cursor
|
||||
*/
|
||||
enum rtgui_cursor_type
|
||||
{
|
||||
RTGUI_CURSOR_ARROW,
|
||||
RTGUI_CURSOR_HAND,
|
||||
};
|
||||
|
||||
void rtgui_cursor_set_device(const char* device_name);
|
||||
void rtgui_cursor_set_position(rt_uint16_t x, rt_uint16_t y);
|
||||
void rtgui_cursor_set_image(enum rtgui_cursor_type type);
|
||||
#endif
|
||||
|
||||
#ifdef RTGUI_USING_VFRAMEBUFFER
|
||||
void rtgui_graphic_driver_vmode_enter(void);
|
||||
void rtgui_graphic_driver_vmode_exit(void);
|
||||
struct rtgui_dc* rtgui_graphic_driver_get_rect_buffer(const struct rtgui_graphic_driver *driver, struct rtgui_rect *rect);
|
||||
#endif
|
||||
|
||||
rt_bool_t rtgui_graphic_driver_is_vmode(void);
|
||||
|
||||
#endif
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,68 @@
|
||||
/*
|
||||
* File : filerw.h
|
||||
* 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
|
||||
*/
|
||||
#ifndef __RTGUI_FILERW_H__
|
||||
#define __RTGUI_FILERW_H__
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#ifdef RTGUI_USING_DFS_FILERW
|
||||
#ifdef _WIN32_NATIVE
|
||||
#pragma warning(disable: 4996)
|
||||
#include <fcntl.h>
|
||||
#include <sys/types.h>
|
||||
#include <sys/stat.h>
|
||||
#include <io.h>
|
||||
#else
|
||||
#include <dfs_posix.h>
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#include <rtgui/rtgui.h>
|
||||
|
||||
#define RTGUI_FILE_SEEK_SET 0
|
||||
#define RTGUI_FILE_SEEK_CUR 1
|
||||
#define RTGUI_FILE_SEEK_END 2
|
||||
|
||||
struct rtgui_filerw
|
||||
{
|
||||
int (*seek)(struct rtgui_filerw *context, rt_off_t offset, int whence);
|
||||
int (*read)(struct rtgui_filerw *context, void *buffer, rt_size_t size, rt_size_t count);
|
||||
int (*write)(struct rtgui_filerw *context, const void *buffer, rt_size_t size, rt_size_t count);
|
||||
int (*tell)(struct rtgui_filerw *context);
|
||||
int (*eof)(struct rtgui_filerw *context);
|
||||
int (*close)(struct rtgui_filerw *context);
|
||||
};
|
||||
typedef struct rtgui_filerw rtgui_filerw_t;
|
||||
|
||||
struct rtgui_filerw *rtgui_filerw_create_file(const char *filename, const char *mode);
|
||||
struct rtgui_filerw *rtgui_filerw_create_mem(const rt_uint8_t *mem, rt_size_t size);
|
||||
|
||||
int rtgui_filerw_seek(struct rtgui_filerw *context, rt_off_t offset, int whence);
|
||||
int rtgui_filerw_read(struct rtgui_filerw *context, void *buffer, rt_size_t size, rt_size_t count);
|
||||
int rtgui_filerw_write(struct rtgui_filerw *context, const void *buffer, rt_size_t size, rt_size_t count);
|
||||
int rtgui_filerw_tell(struct rtgui_filerw *context);
|
||||
int rtgui_filerw_eof(struct rtgui_filerw *context);
|
||||
int rtgui_filerw_close(struct rtgui_filerw *context);
|
||||
int rtgui_filerw_unlink(const char *filename);
|
||||
|
||||
/* get memory data from filerw memory object */
|
||||
const rt_uint8_t *rtgui_filerw_mem_getdata(struct rtgui_filerw *context);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,143 @@
|
||||
/*
|
||||
* File : font.h
|
||||
* 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
|
||||
*/
|
||||
#ifndef __RTGUI_FONT_H__
|
||||
#define __RTGUI_FONT_H__
|
||||
|
||||
#include <rtgui/rtgui.h>
|
||||
#include <rtgui/list.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
struct rtgui_font;
|
||||
struct rtgui_dc;
|
||||
struct rtgui_rect;
|
||||
|
||||
struct rtgui_font_engine
|
||||
{
|
||||
/* font engine function */
|
||||
void (*font_init)(struct rtgui_font *font);
|
||||
void (*font_load)(struct rtgui_font *font);
|
||||
|
||||
void (*font_draw_text)(struct rtgui_font *font, struct rtgui_dc *dc, const char *text,
|
||||
rt_ubase_t len, struct rtgui_rect *rect);
|
||||
void (*font_get_metrics)(struct rtgui_font *font, const char *text, struct rtgui_rect *rect);
|
||||
};
|
||||
|
||||
/*
|
||||
* bitmap font engine
|
||||
*/
|
||||
struct rtgui_font_bitmap
|
||||
{
|
||||
const rt_uint8_t *bmp; /* bitmap font data */
|
||||
const rt_uint8_t *char_width; /* each character width, NULL for fixed font */
|
||||
const rt_uint32_t *offset; /* offset for each character */
|
||||
|
||||
rt_uint16_t width; /* font width */
|
||||
rt_uint16_t height; /* font height */
|
||||
|
||||
rt_uint8_t first_char;
|
||||
rt_uint8_t last_char;
|
||||
};
|
||||
extern const struct rtgui_font_engine bmp_font_engine;
|
||||
|
||||
#include <rtgui/tree.h>
|
||||
SPLAY_HEAD(cache_tree, hz_cache);
|
||||
struct hz_cache
|
||||
{
|
||||
SPLAY_ENTRY(hz_cache) hz_node;
|
||||
|
||||
rt_uint16_t hz_id;
|
||||
};
|
||||
|
||||
struct rtgui_hz_file_font
|
||||
{
|
||||
struct cache_tree cache_root;
|
||||
rt_uint16_t cache_size;
|
||||
|
||||
/* font size */
|
||||
rt_uint16_t font_size;
|
||||
rt_uint16_t font_data_size;
|
||||
|
||||
/* file descriptor */
|
||||
int fd;
|
||||
|
||||
/* font file name */
|
||||
const char *font_fn;
|
||||
};
|
||||
extern const struct rtgui_font_engine rtgui_hz_file_font_engine;
|
||||
|
||||
struct rtgui_font
|
||||
{
|
||||
/* font name */
|
||||
char *family;
|
||||
|
||||
/* font height */
|
||||
rt_uint16_t height;
|
||||
|
||||
/* refer count */
|
||||
rt_uint32_t refer_count;
|
||||
|
||||
/* font engine */
|
||||
const struct rtgui_font_engine *engine;
|
||||
|
||||
/* font private data */
|
||||
void *data;
|
||||
|
||||
/* the font list */
|
||||
rtgui_list_t list;
|
||||
};
|
||||
typedef struct rtgui_font rtgui_font_t;
|
||||
|
||||
void rtgui_font_system_init(void);
|
||||
void rtgui_font_system_add_font(struct rtgui_font *font);
|
||||
void rtgui_font_system_remove_font(struct rtgui_font *font);
|
||||
struct rtgui_font *rtgui_font_default(void);
|
||||
void rtgui_font_set_defaut(struct rtgui_font *font);
|
||||
|
||||
struct rtgui_font *rtgui_font_refer(const char *family, rt_uint16_t height);
|
||||
void rtgui_font_derefer(struct rtgui_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);
|
||||
int rtgui_font_get_string_width(struct rtgui_font *font, const char *text);
|
||||
void rtgui_font_get_metrics(struct rtgui_font *font, const char *text, struct rtgui_rect *rect);
|
||||
|
||||
/* used by stract font */
|
||||
#define FONT_BMP_DATA_BEGIN
|
||||
#define FONT_BMP_DATA_END
|
||||
|
||||
struct rtgui_char_position
|
||||
{
|
||||
/* Keep the size of this struct within 4 bytes so it can be passed by
|
||||
* value. */
|
||||
/* How long this char is. */
|
||||
rt_uint16_t char_width;
|
||||
/* How many bytes remaining from current pointer. At least, it will be 1. */
|
||||
rt_uint16_t remain;
|
||||
};
|
||||
|
||||
/*
|
||||
* @len the length of @str.
|
||||
* @offset the char offset on the string to check with.
|
||||
*/
|
||||
struct rtgui_char_position _string_char_width(char *str, rt_size_t len, rt_size_t offset);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
@@ -0,0 +1,38 @@
|
||||
#ifndef __FONT_FNT_H__
|
||||
#define __FONT_FNT_H__
|
||||
|
||||
#include <rtgui/font.h>
|
||||
#include <rtgui/dc.h>
|
||||
|
||||
/* fnt font header */
|
||||
struct fnt_header
|
||||
{
|
||||
rt_uint8_t version[4];
|
||||
rt_uint16_t max_width;
|
||||
rt_uint16_t height;
|
||||
rt_uint16_t ascent;
|
||||
rt_uint16_t depth;
|
||||
|
||||
rt_uint32_t first_char;
|
||||
rt_uint32_t default_char;
|
||||
rt_uint32_t size;
|
||||
rt_uint32_t nbits;
|
||||
rt_uint32_t noffset;
|
||||
rt_uint32_t nwidth;
|
||||
};
|
||||
typedef rt_uint8_t MWIMAGEBITS;
|
||||
|
||||
struct fnt_font
|
||||
{
|
||||
struct fnt_header header;
|
||||
|
||||
const MWIMAGEBITS *bits; /* nbits */
|
||||
const rt_uint16_t *offset; /* noffset */
|
||||
const rt_uint8_t *width; /* nwidth */
|
||||
};
|
||||
extern const struct rtgui_font_engine fnt_font_engine;
|
||||
|
||||
struct rtgui_font *fnt_font_create(const char* filename);
|
||||
|
||||
#endif
|
||||
|
||||
@@ -0,0 +1,18 @@
|
||||
#ifndef __RTGUI_FONT_TTF_H__
|
||||
#define __RTGUI_FONT_TTF_H__
|
||||
|
||||
#include <rtgui/dc.h>
|
||||
#include <rtgui/font.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
rtgui_font_t *rtgui_freetype_font_create(const char *filename, int bold, int italic, rt_size_t size);
|
||||
void rtgui_freetype_font_destroy(rtgui_font_t *font);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,90 @@
|
||||
/*
|
||||
* File : image.h
|
||||
* 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
|
||||
*/
|
||||
#ifndef __RTGUI_IMAGE_H__
|
||||
#define __RTGUI_IMAGE_H__
|
||||
|
||||
#include <rtgui/dc.h>
|
||||
#include <rtgui/filerw.h>
|
||||
#include <rtgui/region.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
struct rtgui_image;
|
||||
struct rtgui_image_engine
|
||||
{
|
||||
const char *name;
|
||||
struct rtgui_list_node list;
|
||||
|
||||
/* image engine function */
|
||||
rt_bool_t (*image_check)(struct rtgui_filerw *file);
|
||||
|
||||
rt_bool_t (*image_load)(struct rtgui_image *image, struct rtgui_filerw *file, rt_bool_t load);
|
||||
void (*image_unload)(struct rtgui_image *image);
|
||||
|
||||
void (*image_blit)(struct rtgui_image *image, struct rtgui_dc *dc, struct rtgui_rect *rect);
|
||||
};
|
||||
|
||||
struct rtgui_image_palette
|
||||
{
|
||||
rtgui_color_t *colors;
|
||||
rt_uint32_t ncolors;
|
||||
};
|
||||
typedef struct rtgui_image_palette rtgui_image_palette_t;
|
||||
|
||||
struct rtgui_image
|
||||
{
|
||||
/* image metrics */
|
||||
rt_uint16_t w, h;
|
||||
|
||||
/* image engine */
|
||||
const struct rtgui_image_engine *engine;
|
||||
|
||||
/* image palette */
|
||||
rtgui_image_palette_t *palette;
|
||||
|
||||
/* image private data */
|
||||
void *data;
|
||||
};
|
||||
typedef struct rtgui_image rtgui_image_t;
|
||||
|
||||
/* init rtgui image system */
|
||||
void rtgui_system_image_init(void);
|
||||
|
||||
#if defined(RTGUI_USING_DFS_FILERW)
|
||||
struct rtgui_image_engine *rtgui_image_get_engine_by_filename(const char *fn);
|
||||
struct rtgui_image *rtgui_image_create_from_file(const char *type, const char *filename, rt_bool_t load);
|
||||
struct rtgui_image *rtgui_image_create(const char *filename, rt_bool_t load);
|
||||
#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);
|
||||
void rtgui_image_destroy(struct rtgui_image *image);
|
||||
|
||||
/* get image's rect */
|
||||
void rtgui_image_get_rect(struct rtgui_image *image, struct rtgui_rect *rect);
|
||||
|
||||
/* register an image engine */
|
||||
void rtgui_image_register_engine(struct rtgui_image_engine *engine);
|
||||
|
||||
/* blit an image on DC */
|
||||
void rtgui_image_blit(struct rtgui_image *image, struct rtgui_dc *dc, struct rtgui_rect *rect);
|
||||
struct rtgui_image_palette *rtgui_image_palette_create(rt_uint32_t ncolors);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
@@ -0,0 +1,46 @@
|
||||
/*
|
||||
* File : image_bmp.h
|
||||
* 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
|
||||
* 2010-08-10 Bernard first version
|
||||
*/
|
||||
#ifndef __RTGUI_IMAGE_BMP_H__
|
||||
#define __RTGUI_IMAGE_BMP_H__
|
||||
|
||||
#pragma pack(push)
|
||||
#pragma pack(2)
|
||||
|
||||
struct rtgui_image_bmp_header
|
||||
{
|
||||
/* The Win32 BMP file header (14 bytes) */
|
||||
rt_uint16_t bfType;
|
||||
rt_uint32_t bfSize;
|
||||
rt_uint16_t bfReserved1;
|
||||
rt_uint16_t bfReserved2;
|
||||
rt_uint32_t bfOffBits;
|
||||
|
||||
/* The Win32 BITMAPINFOHEADER struct (40 bytes) */
|
||||
rt_uint32_t biSize;
|
||||
rt_int32_t biWidth;
|
||||
rt_int32_t biHeight;
|
||||
rt_uint16_t biPlanes;
|
||||
rt_uint16_t biBitCount;
|
||||
rt_uint32_t biCompression;
|
||||
rt_uint32_t biSizeImage;
|
||||
rt_int32_t biXPelsPerMeter;
|
||||
rt_int32_t biYPelsPerMeter;
|
||||
rt_uint32_t biClrUsed;
|
||||
rt_uint32_t biClrImportant;
|
||||
};
|
||||
#pragma pack(pop)
|
||||
|
||||
void rtgui_image_bmp_init(void);
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,37 @@
|
||||
/*
|
||||
* File : image_xpm.h
|
||||
* 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
|
||||
*/
|
||||
#ifndef __RTGUI_IMAGE_HDC_H__
|
||||
#define __RTGUI_IMAGE_HDC_H__
|
||||
|
||||
#include <rtgui/image.h>
|
||||
|
||||
struct rtgui_image_hdcmm
|
||||
{
|
||||
struct rtgui_image parent;
|
||||
|
||||
/* hdc image information */
|
||||
rt_uint16_t byte_per_pixel;
|
||||
rt_uint16_t pitch;
|
||||
|
||||
rt_uint8_t *pixels;
|
||||
};
|
||||
|
||||
void rtgui_image_hdc_init(void);
|
||||
extern const struct rtgui_image_engine rtgui_image_hdcmm_engine;
|
||||
|
||||
#define HDC_HEADER_SIZE (5 * 4)
|
||||
#define RTGUI_IMAGE_HDC_DEF(bpp, w, h, pixels) \
|
||||
{{w, h, &rtgui_image_hdcmm_engine, RT_NULL}, bpp, (bpp * w), ((rt_uint8_t*)pixels + HDC_HEADER_SIZE)}
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,8 @@
|
||||
#ifndef __RTGUI_IMAGE_JPEG_H__
|
||||
#define __RTGUI_IMAGE_JPEG_H__
|
||||
|
||||
#include <rtgui/image.h>
|
||||
|
||||
void rtgui_image_jpeg_init(void);
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,21 @@
|
||||
/*
|
||||
* File : image_png.h
|
||||
* 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
|
||||
*/
|
||||
#ifndef __RTGUI_IMAGE_PNG_H__
|
||||
#define __RTGUI_IMAGE_PNG_H__
|
||||
|
||||
#include <rtgui/image.h>
|
||||
|
||||
void rtgui_image_png_init(void);
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,21 @@
|
||||
/*
|
||||
* File : image_xpm.h
|
||||
* 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
|
||||
*/
|
||||
#ifndef __RTGUI_IMAGE_XPM_H__
|
||||
#define __RTGUI_IMAGE_XPM_H__
|
||||
|
||||
#include <rtgui/image.h>
|
||||
|
||||
void rtgui_image_xpm_init(void);
|
||||
|
||||
#endif
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,66 @@
|
||||
/*
|
||||
* File : list.h
|
||||
* 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
|
||||
*/
|
||||
#ifndef __RTGUI_LIST_H__
|
||||
#define __RTGUI_LIST_H__
|
||||
|
||||
#include <rtgui/rtgui.h>
|
||||
|
||||
struct rtgui_list_node
|
||||
{
|
||||
struct rtgui_list_node *next;
|
||||
};
|
||||
typedef struct rtgui_list_node rtgui_list_t;
|
||||
|
||||
rt_inline void rtgui_list_init(rtgui_list_t *l)
|
||||
{
|
||||
l->next = (struct rtgui_list_node *)0;
|
||||
}
|
||||
|
||||
rt_inline void rtgui_list_append(rtgui_list_t *l, rtgui_list_t *n)
|
||||
{
|
||||
struct rtgui_list_node *node;
|
||||
|
||||
node = l;
|
||||
while (node->next) node = node->next;
|
||||
|
||||
/* append the node to the tail */
|
||||
node->next = n;
|
||||
n->next = (struct rtgui_list_node *) 0;
|
||||
}
|
||||
|
||||
rt_inline void rtgui_list_insert(rtgui_list_t *l, rtgui_list_t *n)
|
||||
{
|
||||
n->next = l->next;
|
||||
l->next = n;
|
||||
}
|
||||
|
||||
rt_inline rtgui_list_t *rtgui_list_remove(rtgui_list_t *l, rtgui_list_t *n)
|
||||
{
|
||||
/* remove slist head */
|
||||
struct rtgui_list_node *node = l;
|
||||
while (node->next && node->next != n) node = node->next;
|
||||
|
||||
/* remove node */
|
||||
if (node->next != (rtgui_list_t *)0) node->next = node->next->next;
|
||||
|
||||
return l;
|
||||
}
|
||||
|
||||
#define rtgui_list_entry(node, type, member) \
|
||||
((type *)((char*)(node)-(unsigned long)(&((type *)0)->member)))
|
||||
|
||||
#define rtgui_list_foreach(node, list) \
|
||||
for ((node) = (list)->next; (node) != RT_NULL; (node) = (node)->next)
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,162 @@
|
||||
#ifndef __MATRIX_H__
|
||||
#define __MATRIX_H__
|
||||
|
||||
/* Port from ejoy2d: https://github.com/cloudwu/ejoy2d/blob/master/LICENSE
|
||||
* Original License:
|
||||
*
|
||||
* The MIT License (MIT)
|
||||
*
|
||||
* Copyright (c) 2013 Ejoy.com Inc.
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||
* this software and associated documentation files (the "Software"), to deal in
|
||||
* the Software without restriction, including without limitation the rights to
|
||||
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
|
||||
* the Software, and to permit persons to whom the Software is furnished to do so,
|
||||
* subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in all
|
||||
* copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
|
||||
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
|
||||
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
|
||||
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
*/
|
||||
|
||||
/* Port to RTGUI and modified by Grissiom */
|
||||
|
||||
#ifdef _MSC_VER
|
||||
typedef __int32 int32_t;
|
||||
typedef unsigned __int32 uint32_t;
|
||||
typedef __int64 int64_t;
|
||||
typedef unsigned __int64 uint64_t;
|
||||
#else
|
||||
#include <stdint.h>
|
||||
#endif
|
||||
|
||||
#define RTGUI_MATRIX_FRAC_BITS 11
|
||||
#define RTGUI_MATRIX_FRAC (1 << RTGUI_MATRIX_FRAC_BITS)
|
||||
|
||||
struct rtgui_matrix
|
||||
{
|
||||
/* The matrix format is :
|
||||
*
|
||||
* | m[0] m[1] 0 |
|
||||
* | m[2] m[3] 0 |
|
||||
* | m[4] m[5] 1 |
|
||||
*
|
||||
* The format of the coordinate of a point is:
|
||||
*
|
||||
* | x y 1 |
|
||||
*
|
||||
* So, if you want to transform a point p with a matrix m, do:
|
||||
*
|
||||
* p * m
|
||||
*
|
||||
* Note: m[0-3] is in fix presentation that has 10 bits decimal
|
||||
* fraction(m/RTGUI_MATRIX_FRAC). While the unit of m[4-5] is pixel.
|
||||
*
|
||||
*/
|
||||
int m[6];
|
||||
};
|
||||
|
||||
rt_inline int32_t _rtgui_matrix_round_div32(int32_t n, int32_t d)
|
||||
{
|
||||
if (n == 0)
|
||||
return 0;
|
||||
|
||||
if (d < 0)
|
||||
{
|
||||
d = -d;
|
||||
n = -n;
|
||||
}
|
||||
if (n > 0)
|
||||
return (n + d / 2) / d;
|
||||
else
|
||||
return (n - d / 2) / d;
|
||||
}
|
||||
|
||||
rt_inline int32_t _rtgui_matrix_round_div6432(int64_t n, int32_t d)
|
||||
{
|
||||
if (n == 0)
|
||||
return 0;
|
||||
|
||||
if (d < 0)
|
||||
{
|
||||
d = -d;
|
||||
n = -n;
|
||||
}
|
||||
if (n > 0)
|
||||
return (n + d / 2) / d;
|
||||
else
|
||||
return (n - d / 2) / d;
|
||||
}
|
||||
|
||||
/* mm = mm1 * mm2 */
|
||||
rt_inline void rtgui_matrix_mul(struct rtgui_matrix *mm,
|
||||
const struct rtgui_matrix *mm1,
|
||||
const struct rtgui_matrix *mm2)
|
||||
{
|
||||
int *m = mm->m;
|
||||
const int *m1 = mm1->m;
|
||||
const int *m2 = mm2->m;
|
||||
|
||||
m[0] = _rtgui_matrix_round_div32(m1[0] * m2[0] + m1[1] * m2[2], RTGUI_MATRIX_FRAC);
|
||||
m[1] = _rtgui_matrix_round_div32(m1[0] * m2[1] + m1[1] * m2[3], RTGUI_MATRIX_FRAC);
|
||||
m[2] = _rtgui_matrix_round_div32(m1[2] * m2[0] + m1[3] * m2[2], RTGUI_MATRIX_FRAC);
|
||||
m[3] = _rtgui_matrix_round_div32(m1[2] * m2[1] + m1[3] * m2[3], RTGUI_MATRIX_FRAC);
|
||||
m[4] = _rtgui_matrix_round_div32(m1[4] * m2[0] + m1[5] * m2[2], RTGUI_MATRIX_FRAC) + m2[4];
|
||||
m[5] = _rtgui_matrix_round_div32(m1[4] * m2[1] + m1[5] * m2[3], RTGUI_MATRIX_FRAC) + m2[5];
|
||||
}
|
||||
|
||||
/* Matrix multiply point[(p) = (x, y) * m], ignore the movement components. */
|
||||
rt_inline void rtgui_matrix_mul_point_nomove(struct rtgui_point *p,
|
||||
int x, int y,
|
||||
struct rtgui_matrix *m)
|
||||
{
|
||||
int *mm = m->m;
|
||||
|
||||
p->x = _rtgui_matrix_round_div32(x * mm[0] + y * mm[2], RTGUI_MATRIX_FRAC);
|
||||
p->y = _rtgui_matrix_round_div32(x * mm[1] + y * mm[3], RTGUI_MATRIX_FRAC);
|
||||
}
|
||||
|
||||
/* Matrix multiply point[(p) = (x, y) * m]. */
|
||||
rt_inline void rtgui_matrix_mul_point(struct rtgui_point *p,
|
||||
int x, int y,
|
||||
struct rtgui_matrix *m)
|
||||
{
|
||||
int *mm = m->m;
|
||||
|
||||
p->x = _rtgui_matrix_round_div32(x * mm[0] + y * mm[2], RTGUI_MATRIX_FRAC) + mm[4];
|
||||
p->y = _rtgui_matrix_round_div32(x * mm[1] + y * mm[3], RTGUI_MATRIX_FRAC) + mm[5];
|
||||
}
|
||||
|
||||
/** Set @mm to an identity matrix. */
|
||||
rt_inline void rtgu_matrix_identity(struct rtgui_matrix *mm)
|
||||
{
|
||||
int *mat = mm->m;
|
||||
mat[0] = RTGUI_MATRIX_FRAC;
|
||||
mat[1] = 0;
|
||||
mat[2] = 0;
|
||||
mat[3] = RTGUI_MATRIX_FRAC;
|
||||
mat[4] = 0;
|
||||
mat[5] = 0;
|
||||
}
|
||||
|
||||
/** Save the inversed matrix of @mm to @mo.
|
||||
*
|
||||
* @return If the matrix is not inversale, return 1. Otherwise, return 0. */
|
||||
int rtgui_matrix_inverse(const struct rtgui_matrix *mm, struct rtgui_matrix *mo);
|
||||
|
||||
/** @degree range from 0 ~ 512. */
|
||||
void rtgui_matrix_rotate(struct rtgui_matrix *m, int degree);
|
||||
/** The unit is fixed point number. RTGUI_MATRIX_FRAC means 1.0. */
|
||||
void rtgui_matrix_scale(struct rtgui_matrix *m, int sx, int sy);
|
||||
/** The unit is pixel. Not the fixed point number. */
|
||||
void rtgui_matrix_move(struct rtgui_matrix *m, int dx, int dy);
|
||||
|
||||
#endif /* end of include guard: __MATRIX_H__ */
|
||||
|
||||
@@ -0,0 +1,118 @@
|
||||
/*
|
||||
* File : region.h
|
||||
* 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
|
||||
*/
|
||||
#ifndef __RTGUI_REGION_H__
|
||||
#define __RTGUI_REGION_H__
|
||||
|
||||
#include <rtgui/rtgui.h>
|
||||
|
||||
#if defined(__cplusplus) || defined(c_plusplus)
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
typedef struct rtgui_region_data rtgui_region_data_t;
|
||||
struct rtgui_dc;
|
||||
|
||||
struct rtgui_region_data
|
||||
{
|
||||
rt_uint32_t size;
|
||||
rt_uint32_t numRects;
|
||||
/* XXX: And why, exactly, do we have this bogus struct definition? */
|
||||
/* rtgui_rect_t rects[size]; in memory but not explicitly declared */
|
||||
};
|
||||
|
||||
typedef struct rtgui_region
|
||||
{
|
||||
rtgui_rect_t extents;
|
||||
rtgui_region_data_t *data;
|
||||
} rtgui_region_t;
|
||||
|
||||
typedef enum
|
||||
{
|
||||
RTGUI_REGION_STATUS_FAILURE,
|
||||
RTGUI_REGION_STATUS_SUCCESS
|
||||
} rtgui_region_status_t;
|
||||
|
||||
/* creation/destruction */
|
||||
|
||||
void rtgui_region_init(rtgui_region_t *region);
|
||||
void rtgui_region_init_rect(rtgui_region_t *region,
|
||||
int x, int y, unsigned int width, unsigned int height);
|
||||
void rtgui_region_init_with_extents(rtgui_region_t *region, const rtgui_rect_t *extents);
|
||||
void rtgui_region_fini(rtgui_region_t *region);
|
||||
|
||||
void rtgui_region_translate(rtgui_region_t *region, int x, int y);
|
||||
|
||||
rtgui_region_status_t rtgui_region_copy(rtgui_region_t *dest, rtgui_region_t *source);
|
||||
|
||||
rtgui_region_status_t rtgui_region_intersect(rtgui_region_t *newReg, rtgui_region_t *reg1, rtgui_region_t *reg2);
|
||||
rtgui_region_status_t rtgui_region_intersect_rect(rtgui_region_t *newReg, rtgui_region_t *reg1, rtgui_rect_t *rect);
|
||||
rtgui_region_status_t rtgui_region_union(rtgui_region_t *newReg, rtgui_region_t *reg1, rtgui_region_t *reg2);
|
||||
rtgui_region_status_t rtgui_region_union_rect(rtgui_region_t *dest, rtgui_region_t *source, rtgui_rect_t *rect);
|
||||
rtgui_region_status_t rtgui_region_subtract(rtgui_region_t *regD, rtgui_region_t *regM, rtgui_region_t *regS);
|
||||
rtgui_region_status_t rtgui_region_subtract_rect(rtgui_region_t *regD, rtgui_region_t *regM, rtgui_rect_t *rect);
|
||||
rtgui_region_status_t rtgui_region_inverse(rtgui_region_t *newReg, rtgui_region_t *reg1, rtgui_rect_t *invRect);
|
||||
|
||||
int rtgui_region_num_rects(rtgui_region_t *region);
|
||||
|
||||
rtgui_rect_t *rtgui_region_rects(rtgui_region_t *region);
|
||||
|
||||
#define RTGUI_REGION_OUT 0
|
||||
#define RTGUI_REGION_IN 1
|
||||
#define RTGUI_REGION_PART 2
|
||||
|
||||
int rtgui_region_contains_point(rtgui_region_t *region, int x, int y, rtgui_rect_t *box);
|
||||
int rtgui_region_contains_rectangle(rtgui_region_t *rtgui_region_t, rtgui_rect_t *prect);
|
||||
|
||||
int rtgui_region_not_empty(rtgui_region_t *region);
|
||||
rtgui_rect_t *rtgui_region_extents(rtgui_region_t *region);
|
||||
|
||||
rtgui_region_status_t rtgui_region_append(rtgui_region_t *dest, rtgui_region_t *region);
|
||||
rtgui_region_status_t rtgui_region_validate(rtgui_region_t *badreg, int *pOverlap);
|
||||
|
||||
void rtgui_region_reset(rtgui_region_t *region, rtgui_rect_t *rect);
|
||||
void rtgui_region_empty(rtgui_region_t *region);
|
||||
void rtgui_region_dump(rtgui_region_t *region);
|
||||
void rtgui_region_draw_clip(rtgui_region_t *region, struct rtgui_dc *dc);
|
||||
int rtgui_region_is_flat(rtgui_region_t *region);
|
||||
|
||||
/* rect functions */
|
||||
extern rtgui_rect_t rtgui_empty_rect;
|
||||
|
||||
void rtgui_rect_moveto(rtgui_rect_t *rect, int x, int y);
|
||||
void rtgui_rect_moveto_align(const rtgui_rect_t *rect, rtgui_rect_t *to, int align);
|
||||
void rtgui_rect_inflate(rtgui_rect_t *rect, int d);
|
||||
void rtgui_rect_intersect(rtgui_rect_t *src, rtgui_rect_t *dest);
|
||||
int rtgui_rect_contains_point(const rtgui_rect_t *rect, int x, int y);
|
||||
int rtgui_rect_is_intersect(const rtgui_rect_t *rect1, const rtgui_rect_t *rect2);
|
||||
int rtgui_rect_is_equal(const rtgui_rect_t *rect1, const rtgui_rect_t *rect2);
|
||||
rtgui_rect_t *rtgui_rect_set(rtgui_rect_t *rect, int x, int y, int w, int h);
|
||||
rt_bool_t rtgui_rect_is_empty(const rtgui_rect_t *rect);
|
||||
|
||||
rt_inline void rtgui_rect_init(rtgui_rect_t* rect, int x, int y, int width, int height)
|
||||
{
|
||||
rect->x1 = x; rect->y1 = y;
|
||||
rect->x2 = x + width; rect->y2 = y + height;
|
||||
}
|
||||
|
||||
#define RTGUI_RECT(rect, x, y, w, h) \
|
||||
do { \
|
||||
rect.x1 = x; rect.y1 = y; \
|
||||
rect.x2 = (x) + (w); rect.y2 = (y) + (h); \
|
||||
} while (0)
|
||||
|
||||
#if defined(__cplusplus) || defined(c_plusplus)
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* _PIXMAN_H_ */
|
||||
@@ -0,0 +1,194 @@
|
||||
/*
|
||||
* File : rtgui.h
|
||||
* This file is part of RT-Thread GUI
|
||||
* COPYRIGHT (C) 2009 - 2013, RT-Thread Development Team
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; either version 2 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License along
|
||||
* with this program; if not, write to the Free Software Foundation, Inc.,
|
||||
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
* 2009-10-04 Bernard first version
|
||||
*/
|
||||
#ifndef __RT_GUI_H__
|
||||
#define __RT_GUI_H__
|
||||
|
||||
#include <rtthread.h>
|
||||
#include <rtgui/rtgui_config.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#define RTGUI_VERSION 0L /**< major version number */
|
||||
#define RTGUI_SUBVERSION 8L /**< minor version number */
|
||||
#define RTGUI_REVISION 1L /**< revise version number */
|
||||
#define RTGUI_CODENAME "Newton" /**< code name */
|
||||
|
||||
#define RT_INT16_MAX 32767
|
||||
#define RT_INT16_MIN (-RT_INT16_MAX-1)
|
||||
#define RTGUI_NOT_FOUND (-1)
|
||||
|
||||
#define _UI_MIN(x, y) (((x)<(y))?(x):(y))
|
||||
#define _UI_MAX(x, y) (((x)>(y))?(x):(y))
|
||||
#define _UI_BITBYTES(bits) ((bits + 7)/8)
|
||||
#define _UI_ABS(x) ((x)>=0? (x):-(x))
|
||||
|
||||
/* MDK, GCC and MSVC all support __restrict keyword. */
|
||||
#define RTGUI_RESTRICT __restrict
|
||||
#ifdef _MSC_VER
|
||||
#define RTGUI_PURE
|
||||
#else
|
||||
/* GCC and MDK share the same attributes.
|
||||
* TODO: IAR attributes. */
|
||||
#define RTGUI_PURE __attribute__((pure))
|
||||
#endif
|
||||
|
||||
struct rtgui_event;
|
||||
|
||||
struct rtgui_object;
|
||||
struct rtgui_widget;
|
||||
struct rtgui_win;
|
||||
struct rtgui_font;
|
||||
|
||||
typedef struct rtgui_win rtgui_win_t;
|
||||
typedef rt_bool_t (*rtgui_event_handler_ptr)(struct rtgui_object *object, struct rtgui_event *event);
|
||||
typedef void (*rtgui_onbutton_func_t)(struct rtgui_object *object, struct rtgui_event *event);
|
||||
|
||||
/**
|
||||
* Coordinate point
|
||||
*/
|
||||
struct rtgui_point
|
||||
{
|
||||
rt_int16_t x, y;
|
||||
};
|
||||
typedef struct rtgui_point rtgui_point_t;
|
||||
extern rtgui_point_t rtgui_empty_point;
|
||||
|
||||
/**
|
||||
* Rectangle structure
|
||||
*/
|
||||
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)
|
||||
|
||||
typedef unsigned long rtgui_color_t;
|
||||
|
||||
/**
|
||||
* Graphic context
|
||||
*/
|
||||
struct rtgui_gc
|
||||
{
|
||||
/* foreground and background color */
|
||||
rtgui_color_t foreground, background;
|
||||
|
||||
/* text style */
|
||||
rt_uint16_t textstyle;
|
||||
/* text align */
|
||||
rt_uint16_t textalign;
|
||||
|
||||
/* font */
|
||||
struct rtgui_font *font;
|
||||
};
|
||||
typedef struct rtgui_gc rtgui_gc_t;
|
||||
|
||||
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
|
||||
};
|
||||
|
||||
/**
|
||||
* Border style
|
||||
*/
|
||||
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,
|
||||
RTGUI_BORDER_UP,
|
||||
RTGUI_BORDER_DOWN
|
||||
};
|
||||
#define RTGUI_BORDER_DEFAULT_WIDTH 2
|
||||
#define RTGUI_WIDGET_DEFAULT_MARGIN 3
|
||||
|
||||
/**
|
||||
* Blend mode
|
||||
*/
|
||||
enum RTGUI_BLENDMODE
|
||||
{
|
||||
RTGUI_BLENDMODE_NONE = 0x00,
|
||||
RTGUI_BLENDMODE_BLEND,
|
||||
RTGUI_BLENDMODE_ADD,
|
||||
RTGUI_BLENDMODE_MOD,
|
||||
};
|
||||
|
||||
/**
|
||||
* Orientation
|
||||
*/
|
||||
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_CENTER = RTGUI_ALIGN_CENTER_HORIZONTAL | RTGUI_ALIGN_CENTER_VERTICAL,
|
||||
RTGUI_ALIGN_EXPAND = 0x10,
|
||||
RTGUI_ALIGN_STRETCH = 0x20,
|
||||
};
|
||||
|
||||
enum RTGUI_TEXTSTYLE
|
||||
{
|
||||
RTGUI_TEXTSTYLE_NORMAL = 0x00,
|
||||
RTGUI_TEXTSTYLE_DRAW_BACKGROUND = 0x01,
|
||||
RTGUI_TEXTSTYLE_SHADOW = 0x02,
|
||||
RTGUI_TEXTSTYLE_OUTLINE = 0x04,
|
||||
};
|
||||
|
||||
enum RTGUI_MODAL_CODE
|
||||
{
|
||||
RTGUI_MODAL_OK,
|
||||
RTGUI_MODAL_CANCEL
|
||||
};
|
||||
typedef enum RTGUI_MODAL_CODE rtgui_modal_code_t;
|
||||
|
||||
#include <rtgui/rtgui_object.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
@@ -0,0 +1,113 @@
|
||||
/*
|
||||
* File : rtgui_app.h
|
||||
* This file is part of RTGUI in RT-Thread RTOS
|
||||
* COPYRIGHT (C) 2006 - 2012, 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
|
||||
* 2012-01-13 Grissiom first version
|
||||
*/
|
||||
|
||||
#ifndef __RTGUI_APP_H__
|
||||
#define __RTGUI_APP_H__
|
||||
|
||||
#include <rtthread.h>
|
||||
#include <rtgui/rtgui.h>
|
||||
#include <rtgui/event.h>
|
||||
#include <rtgui/rtgui_system.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
DECLARE_CLASS_TYPE(application);
|
||||
|
||||
/** Gets the type of a application */
|
||||
#define RTGUI_APP_TYPE (RTGUI_TYPE(application))
|
||||
/** Casts the object to an rtgui_workbench */
|
||||
#define RTGUI_APP(obj) (RTGUI_OBJECT_CAST((obj), RTGUI_APP_TYPE, struct rtgui_app))
|
||||
/** Checks if the object is an rtgui_workbench */
|
||||
#define RTGUI_IS_APP(obj) (RTGUI_OBJECT_CHECK_TYPE((obj), RTGUI_APP_TYPE))
|
||||
|
||||
enum rtgui_app_flag
|
||||
{
|
||||
RTGUI_APP_FLAG_EXITED = 0x04,
|
||||
RTGUI_APP_FLAG_SHOWN = 0x08,
|
||||
RTGUI_APP_FLAG_KEEP = 0x80,
|
||||
};
|
||||
|
||||
typedef void (*rtgui_idle_func_t)(struct rtgui_object *obj, struct rtgui_event *event);
|
||||
|
||||
struct rtgui_app
|
||||
{
|
||||
struct rtgui_object parent;
|
||||
|
||||
/* application name */
|
||||
unsigned char *name;
|
||||
struct rtgui_image *icon;
|
||||
|
||||
enum rtgui_app_flag state_flag;
|
||||
|
||||
rt_uint16_t ref_count;
|
||||
rt_uint16_t exit_code;
|
||||
|
||||
/* the thread id */
|
||||
rt_thread_t tid;
|
||||
/* the message queue of thread */
|
||||
rt_mq_t mq;
|
||||
/* event buffer */
|
||||
rt_uint8_t event_buffer[sizeof(union rtgui_event_generic)];
|
||||
|
||||
/* if not RT_NULL, the main_object is the one will be activated when the
|
||||
* app recieves activate event. By default, it is the first window shown in
|
||||
* the app. */
|
||||
struct rtgui_object *main_object;
|
||||
|
||||
/* on idle event handler */
|
||||
rtgui_idle_func_t on_idle;
|
||||
|
||||
unsigned int window_cnt;
|
||||
|
||||
void *user_data;
|
||||
};
|
||||
|
||||
/**
|
||||
* create an application named @myname on current thread.
|
||||
*
|
||||
* @param name the name of the application
|
||||
*
|
||||
* @return a pointer to struct rtgui_app on success. RT_NULL on failure.
|
||||
*/
|
||||
struct rtgui_app *rtgui_app_create(const char *name);
|
||||
void rtgui_app_destroy(struct rtgui_app *app);
|
||||
rt_bool_t rtgui_app_event_handler(struct rtgui_object *obj, rtgui_event_t *event);
|
||||
|
||||
rt_base_t rtgui_app_run(struct rtgui_app *app);
|
||||
void rtgui_app_exit(struct rtgui_app *app, rt_uint16_t code);
|
||||
void rtgui_app_activate(struct rtgui_app *app);
|
||||
void rtgui_app_close(struct rtgui_app *app);
|
||||
void rtgui_app_sleep(struct rtgui_app *app, int millisecond);
|
||||
|
||||
void rtgui_app_set_onidle(struct rtgui_app *app, rtgui_idle_func_t onidle);
|
||||
rtgui_idle_func_t rtgui_app_get_onidle(struct rtgui_app *app);
|
||||
|
||||
/**
|
||||
* return the rtgui_app struct on current thread
|
||||
*/
|
||||
struct rtgui_app *rtgui_app_self(void);
|
||||
|
||||
rt_err_t rtgui_app_set_as_wm(struct rtgui_app *app);
|
||||
|
||||
void rtgui_app_set_main_win(struct rtgui_app *app, struct rtgui_win *win);
|
||||
struct rtgui_win* rtgui_app_get_main_win(struct rtgui_app *app);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* end of include guard: __RTGUI_APP_H__ */
|
||||
|
||||
@@ -0,0 +1,71 @@
|
||||
/*
|
||||
* File : rtgui_config.h
|
||||
* 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-02-08 Bernard move some RTGUI options to bsp
|
||||
*/
|
||||
|
||||
#ifndef __RTGUI_CONFIG_H__
|
||||
#define __RTGUI_CONFIG_H__
|
||||
|
||||
/* RTGUI options */
|
||||
|
||||
#ifndef RT_USING_DFS
|
||||
#undef RTGUI_USING_DFS_FILERW
|
||||
#undef RTGUI_USING_HZ_FILE
|
||||
#endif
|
||||
|
||||
#ifdef RT_USING_DFS
|
||||
/* if file system is used, the DFS_FILERW will be defined */
|
||||
#ifndef RTGUI_USING_DFS_FILERW
|
||||
#define RTGUI_USING_DFS_FILERW
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#if RTGUI_DEFAULT_FONT_SIZE == 0
|
||||
#define RTGUI_DEFAULT_FONT_SIZE 12
|
||||
#endif
|
||||
|
||||
#define RTGUI_SVR_THREAD_PRIORITY 15
|
||||
#define RTGUI_SVR_THREAD_TIMESLICE 5
|
||||
#ifndef RTGUI_SVR_THREAD_STACK_SIZE
|
||||
#ifdef RTGUI_USING_SMALL_SIZE
|
||||
#define RTGUI_SVR_THREAD_STACK_SIZE 1024
|
||||
#else
|
||||
#define RTGUI_SVR_THREAD_STACK_SIZE 2048
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#define RTGUI_APP_THREAD_PRIORITY 25
|
||||
#define RTGUI_APP_THREAD_TIMESLICE 5
|
||||
#ifdef RTGUI_USING_SMALL_SIZE
|
||||
#define RTGUI_APP_THREAD_STACK_SIZE 1024
|
||||
#else
|
||||
#define RTGUI_APP_THREAD_STACK_SIZE 2048
|
||||
#endif
|
||||
|
||||
// #define RTGUI_USING_CAST_CHECK
|
||||
|
||||
// #define RTGUI_USING_DESKTOP_WINDOW
|
||||
// #undef RTGUI_USING_SMALL_SIZE
|
||||
|
||||
//#define RTGUI_USING_CALIBRATION
|
||||
|
||||
#define RTGUI_USING_VFRAMEBUFFER
|
||||
|
||||
#ifdef DEBUG_MEMLEAK
|
||||
#define rtgui_malloc rt_malloc
|
||||
#define rtgui_realloc rt_realloc
|
||||
#define rtgui_free rt_free
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
@@ -0,0 +1,167 @@
|
||||
/*
|
||||
* 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>
|
||||
#include <rtgui/rtgui.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/* rtgui object type */
|
||||
#define RTGUI_CONTAINER_OF(obj, type, member) \
|
||||
((type *)((char *)(obj) - (unsigned long)(&((type *)0)->member)))
|
||||
|
||||
/** 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-definition */
|
||||
struct rtgui_object;
|
||||
struct rtgui_app;
|
||||
|
||||
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;
|
||||
|
||||
/* parent type link */
|
||||
const struct rtgui_type *parent;
|
||||
|
||||
/* constructor and destructor */
|
||||
rtgui_constructor_t constructor;
|
||||
rtgui_destructor_t destructor;
|
||||
|
||||
/* size of type */
|
||||
int size;
|
||||
};
|
||||
typedef struct rtgui_type rtgui_type_t;
|
||||
#define RTGUI_TYPE(type) (_rtgui_##type##_get_type())
|
||||
#define RTGUI_PARENT_TYPE(type) (const struct rtgui_type*)(&_rtgui_##type)
|
||||
|
||||
#define DECLARE_CLASS_TYPE(type) \
|
||||
const rtgui_type_t *_rtgui_##type##_get_type(void); \
|
||||
extern const struct rtgui_type _rtgui_##type
|
||||
|
||||
#define DEFINE_CLASS_TYPE(type, name, parent, constructor, destructor, size) \
|
||||
const struct rtgui_type _rtgui_##type = { \
|
||||
name, \
|
||||
parent, \
|
||||
RTGUI_CONSTRUCTOR(constructor), \
|
||||
RTGUI_DESTRUCTOR(destructor), \
|
||||
size }; \
|
||||
const rtgui_type_t *_rtgui_##type##_get_type(void) { return &_rtgui_##type; } \
|
||||
RTM_EXPORT(_rtgui_##type##_get_type)
|
||||
|
||||
void rtgui_type_object_construct(const rtgui_type_t *type, rtgui_object_t *object);
|
||||
void rtgui_type_destructors_call(const rtgui_type_t *type, rtgui_object_t *object);
|
||||
rt_bool_t rtgui_type_inherits_from(const rtgui_type_t *type, const rtgui_type_t *parent);
|
||||
const rtgui_type_t *rtgui_type_parent_type_get(const rtgui_type_t *type);
|
||||
const char *rtgui_type_name_get(const rtgui_type_t *type);
|
||||
const rtgui_type_t *rtgui_object_object_type_get(rtgui_object_t *object);
|
||||
|
||||
#ifdef RTGUI_USING_CAST_CHECK
|
||||
#define RTGUI_OBJECT_CAST(obj, obj_type, c_type) \
|
||||
((c_type *)rtgui_object_check_cast((rtgui_object_t *)(obj), (obj_type), __FUNCTION__, __LINE__))
|
||||
#else
|
||||
#define RTGUI_OBJECT_CAST(obj, obj_type, c_type) ((c_type *)(obj))
|
||||
#endif
|
||||
|
||||
#define RTGUI_OBJECT_CHECK_TYPE(_obj, _type) \
|
||||
(rtgui_type_inherits_from(((rtgui_object_t *)(_obj))->type, (_type)))
|
||||
|
||||
DECLARE_CLASS_TYPE(object);
|
||||
/** Gets the type of an object */
|
||||
#define RTGUI_OBJECT_TYPE RTGUI_TYPE(object)
|
||||
/** Casts the object to an rtgui_object_t */
|
||||
#define RTGUI_OBJECT(obj) (RTGUI_OBJECT_CAST((obj), RTGUI_OBJECT_TYPE, struct rtgui_object))
|
||||
/** Checks if the object is an rtgui_Object */
|
||||
#define RTGUI_IS_OBJECT(obj) (RTGUI_OBJECT_CHECK_TYPE((obj), RTGUI_OBJECT_TYPE))
|
||||
|
||||
enum rtgui_object_flag
|
||||
{
|
||||
RTGUI_OBJECT_FLAG_NONE = 0x0000,
|
||||
RTGUI_OBJECT_FLAG_STATIC = 0x0001,
|
||||
RTGUI_OBJECT_FLAG_DISABLED = 0x0002,
|
||||
/* When an object is created, it's flag is set to valid. When an object is
|
||||
* deleted, the valid bits will be cleared. */
|
||||
RTGUI_OBJECT_FLAG_VALID = 0xAB00,
|
||||
};
|
||||
|
||||
/* rtgui base object */
|
||||
struct rtgui_object
|
||||
{
|
||||
/* object type */
|
||||
const rtgui_type_t *type;
|
||||
|
||||
/* the event handler */
|
||||
rtgui_event_handler_ptr event_handler;
|
||||
|
||||
enum rtgui_object_flag flag;
|
||||
|
||||
rt_uint32_t id;
|
||||
};
|
||||
|
||||
rtgui_object_t *rtgui_object_create(const rtgui_type_t *object_type);
|
||||
void rtgui_object_destroy(rtgui_object_t *object);
|
||||
|
||||
/* set the event handler of object */
|
||||
void rtgui_object_set_event_handler(struct rtgui_object *object, rtgui_event_handler_ptr handler);
|
||||
/* object default event handler */
|
||||
rt_bool_t rtgui_object_event_handler(struct rtgui_object *object, struct rtgui_event *event);
|
||||
/* helper micro. widget event handlers could use this. */
|
||||
#define RTGUI_WIDGET_EVENT_HANDLER_PREPARE \
|
||||
struct rtgui_widget *widget; \
|
||||
RT_ASSERT(object != RT_NULL); \
|
||||
RT_ASSERT(event != RT_NULL); \
|
||||
widget = RTGUI_WIDGET(object); \
|
||||
/* supress compiler warning */ \
|
||||
widget = widget;
|
||||
|
||||
/** handle @param event on @param object's own event handler
|
||||
*
|
||||
* If the @param object does not have an event handler, which means the object
|
||||
* does not interested in any event, it will return RT_FALSE. Otherwise, the
|
||||
* return code of that handler is returned.
|
||||
*/
|
||||
rt_inline rt_bool_t rtgui_object_handle(struct rtgui_object *object, struct rtgui_event *event)
|
||||
{
|
||||
if (object->event_handler)
|
||||
return object->event_handler(object, event);
|
||||
return RT_FALSE;
|
||||
}
|
||||
|
||||
rtgui_object_t *rtgui_object_check_cast(rtgui_object_t *object, const rtgui_type_t *type, const char *func, int line);
|
||||
const rtgui_type_t *rtgui_object_object_type_get(rtgui_object_t *object);
|
||||
|
||||
void rtgui_object_set_id(struct rtgui_object *obj, rt_uint32_t id);
|
||||
rt_uint32_t rtgui_object_get_id(struct rtgui_object *obj);
|
||||
struct rtgui_object* rtgui_get_object(struct rtgui_app *app, rt_uint32_t id);
|
||||
struct rtgui_object* rtgui_get_self_object(rt_uint32_t id);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
@@ -0,0 +1,79 @@
|
||||
/*
|
||||
* 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 <rtservice.h>
|
||||
#include <rtgui/list.h>
|
||||
|
||||
/* RTGUI server definitions */
|
||||
|
||||
/* top window definitions in server */
|
||||
enum rtgui_topwin_flag
|
||||
{
|
||||
WINTITLE_INIT = 0x00,
|
||||
WINTITLE_ACTIVATE = 0x01,
|
||||
WINTITLE_NOFOCUS = 0x02,
|
||||
/* window is hidden by default */
|
||||
WINTITLE_SHOWN = 0x04,
|
||||
/* window is modaled by other window */
|
||||
WINTITLE_MODALED = 0x08,
|
||||
/* window is modaling other window */
|
||||
WINTITLE_MODALING = 0x100,
|
||||
WINTITLE_ONTOP = 0x200,
|
||||
WINTITLE_ONBTM = 0x400,
|
||||
};
|
||||
|
||||
struct rtgui_topwin
|
||||
{
|
||||
/* the window flag */
|
||||
enum rtgui_topwin_flag flag;
|
||||
/* event mask */
|
||||
rt_uint32_t mask;
|
||||
|
||||
struct rtgui_wintitle *title;
|
||||
|
||||
/* the window id */
|
||||
struct rtgui_win *wid;
|
||||
|
||||
/* which app I belong */
|
||||
struct rtgui_app *app;
|
||||
|
||||
/* the extent information */
|
||||
rtgui_rect_t extent;
|
||||
|
||||
struct rtgui_topwin *parent;
|
||||
|
||||
/* we need to iterate the topwin list with usual order(get target window)
|
||||
* or reversely(painting). So it's better to use a double linked list */
|
||||
rt_list_t list;
|
||||
rt_list_t child_list;
|
||||
|
||||
/* the monitor rect list */
|
||||
rtgui_list_t monitor_list;
|
||||
};
|
||||
|
||||
/* top win manager init */
|
||||
void rtgui_topwin_init(void);
|
||||
void rtgui_server_init(void);
|
||||
|
||||
void rtgui_server_install_show_win_hook(void (*hk)(void));
|
||||
void rtgui_server_install_act_win_hook(void (*hk)(void));
|
||||
|
||||
/* post an event to server */
|
||||
void rtgui_server_post_event(struct rtgui_event *event, rt_size_t size);
|
||||
rt_err_t rtgui_server_post_event_sync(struct rtgui_event *event, rt_size_t size);
|
||||
|
||||
#endif
|
||||
|
||||
@@ -0,0 +1,98 @@
|
||||
/*
|
||||
* 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>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
struct rtgui_dc;
|
||||
struct rtgui_event;
|
||||
struct rtgui_widget;
|
||||
|
||||
struct rtgui_timer;
|
||||
typedef void (*rtgui_timeout_func)(struct rtgui_timer *timer, void *parameter);
|
||||
|
||||
enum rtgui_timer_state
|
||||
{
|
||||
RTGUI_TIMER_ST_INIT,
|
||||
RTGUI_TIMER_ST_RUNNING,
|
||||
RTGUI_TIMER_ST_DESTROY_PENDING,
|
||||
};
|
||||
|
||||
struct rtgui_timer
|
||||
{
|
||||
/* the rtgui application it runs on */
|
||||
struct rtgui_app* app;
|
||||
/* rt timer */
|
||||
struct rt_timer timer;
|
||||
/* How many events are pending on the queue. */
|
||||
int pending_cnt;
|
||||
enum rtgui_timer_state state;
|
||||
|
||||
/* 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_set_timeout(rtgui_timer_t *timer, rt_int32_t time);
|
||||
void rtgui_timer_start(rtgui_timer_t *timer);
|
||||
void rtgui_timer_stop(rtgui_timer_t *timer);
|
||||
|
||||
/* rtgui system initialization function */
|
||||
int rtgui_system_server_init(void);
|
||||
|
||||
void *rtgui_malloc(rt_size_t size);
|
||||
void rtgui_free(void *ptr);
|
||||
void *rtgui_realloc(void *ptr, rt_size_t size);
|
||||
|
||||
#ifdef _WIN32_NATIVE
|
||||
#define rtgui_enter_critical()
|
||||
#define rtgui_exit_critical()
|
||||
#else
|
||||
#define rtgui_enter_critical rt_enter_critical
|
||||
#define rtgui_exit_critical rt_exit_critical
|
||||
#endif
|
||||
|
||||
struct rtgui_app* rtgui_get_server(void);
|
||||
void rtgui_set_mainwin_rect(struct rtgui_rect *rect);
|
||||
void rtgui_get_mainwin_rect(struct rtgui_rect *rect);
|
||||
void rtgui_get_screen_rect(struct rtgui_rect *rect);
|
||||
|
||||
void rtgui_screen_lock(rt_int32_t timeout);
|
||||
void rtgui_screen_unlock(void);
|
||||
int rtgui_screen_lock_freeze(void);
|
||||
void rtgui_screen_lock_thaw(int value);
|
||||
|
||||
struct rtgui_event;
|
||||
rt_err_t rtgui_send(struct rtgui_app* app, struct rtgui_event *event, rt_size_t event_size);
|
||||
rt_err_t rtgui_send_urgent(struct rtgui_app* app, struct rtgui_event *event, rt_size_t event_size);
|
||||
rt_err_t rtgui_send_sync(struct rtgui_app* app, struct rtgui_event *event, rt_size_t event_size);
|
||||
rt_err_t rtgui_ack(struct rtgui_event *event, rt_int32_t status);
|
||||
rt_err_t rtgui_recv(struct rtgui_event *event, rt_size_t event_size, rt_int32_t timeout);
|
||||
rt_err_t rtgui_recv_filter(rt_uint32_t type, struct rtgui_event *event, rt_size_t event_size);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,55 @@
|
||||
/*
|
||||
* File : box.h
|
||||
* 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
|
||||
*/
|
||||
#ifndef __RTGUI_BOX_H__
|
||||
#define __RTGUI_BOX_H__
|
||||
|
||||
#include <rtgui/rtgui.h>
|
||||
#include <rtgui/widgets/widget.h>
|
||||
#include <rtgui/widgets/container.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
DECLARE_CLASS_TYPE(box);
|
||||
|
||||
/** Gets the type of a box */
|
||||
#define RTGUI_BOX_TYPE (RTGUI_TYPE(box))
|
||||
/** Casts the object to an rtgui_box */
|
||||
#define RTGUI_BOX(obj) (RTGUI_OBJECT_CAST((obj), RTGUI_BOX_TYPE, rtgui_box_t))
|
||||
/** Checks if the object is an rtgui_box */
|
||||
#define RTGUI_IS_BOX(obj) (RTGUI_OBJECT_CHECK_TYPE((obj), RTGUI_BOX_TYPE))
|
||||
|
||||
struct rtgui_box
|
||||
{
|
||||
struct rtgui_object parent;
|
||||
|
||||
rt_uint16_t orient;
|
||||
rt_uint16_t border_size;
|
||||
|
||||
struct rtgui_container *container;
|
||||
};
|
||||
typedef struct rtgui_box rtgui_box_t;
|
||||
|
||||
struct rtgui_box *rtgui_box_create(int orientation, int border_size);
|
||||
void rtgui_box_destroy(struct rtgui_box *box);
|
||||
|
||||
void rtgui_box_layout(rtgui_box_t *box);
|
||||
void rtgui_box_layout_rect(rtgui_box_t *box, struct rtgui_rect *rect);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,70 @@
|
||||
/*
|
||||
* File : container.h
|
||||
* 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
|
||||
*/
|
||||
#ifndef __RTGUI_CONTAINER_H__
|
||||
#define __RTGUI_CONTAINER_H__
|
||||
|
||||
#include <rtgui/widgets/widget.h>
|
||||
#include <rtgui/widgets/box.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
DECLARE_CLASS_TYPE(container);
|
||||
/** Gets the type of a container */
|
||||
#define RTGUI_CONTAINER_TYPE (RTGUI_TYPE(container))
|
||||
/** Casts the object to an rtgui_container */
|
||||
#define RTGUI_CONTAINER(obj) (RTGUI_OBJECT_CAST((obj), RTGUI_CONTAINER_TYPE, rtgui_container_t))
|
||||
/** Checks if the object is an rtgui_container */
|
||||
#define RTGUI_IS_CONTAINER(obj) (RTGUI_OBJECT_CHECK_TYPE((obj), RTGUI_CONTAINER_TYPE))
|
||||
|
||||
/*
|
||||
* the container widget
|
||||
*/
|
||||
struct rtgui_container
|
||||
{
|
||||
struct rtgui_widget parent;
|
||||
|
||||
/* layout box */
|
||||
struct rtgui_box *layout_box;
|
||||
|
||||
rtgui_list_t children;
|
||||
};
|
||||
typedef struct rtgui_container rtgui_container_t;
|
||||
|
||||
rtgui_container_t *rtgui_container_create(void);
|
||||
void rtgui_container_destroy(rtgui_container_t *container);
|
||||
|
||||
rt_bool_t rtgui_container_event_handler(struct rtgui_object *widget, struct rtgui_event *event);
|
||||
|
||||
/* set layout box */
|
||||
void rtgui_container_set_box(struct rtgui_container *container, struct rtgui_box *box);
|
||||
void rtgui_container_layout(struct rtgui_container *container);
|
||||
|
||||
void rtgui_container_add_child(rtgui_container_t *container, rtgui_widget_t *child);
|
||||
void rtgui_container_remove_child(rtgui_container_t *container, rtgui_widget_t *child);
|
||||
void rtgui_container_destroy_children(rtgui_container_t *container);
|
||||
rtgui_widget_t *rtgui_container_get_first_child(rtgui_container_t *container);
|
||||
|
||||
rt_bool_t rtgui_container_event_handler(struct rtgui_object *widget, rtgui_event_t *event);
|
||||
|
||||
rt_bool_t rtgui_container_dispatch_event(rtgui_container_t *container, rtgui_event_t *event);
|
||||
rt_bool_t rtgui_container_dispatch_mouse_event(rtgui_container_t *container, struct rtgui_event_mouse *event);
|
||||
|
||||
struct rtgui_object* rtgui_container_get_object(struct rtgui_container *container, rt_uint32_t id);
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,38 @@
|
||||
/*
|
||||
* File : title.h
|
||||
* 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
|
||||
*/
|
||||
#ifndef __RTGUI_TITLE__
|
||||
#define __RTGUI_TITLE__
|
||||
|
||||
#include <rtgui/widgets/widget.h>
|
||||
|
||||
DECLARE_CLASS_TYPE(wintitle);
|
||||
/** Gets the type of a title */
|
||||
#define RTGUI_WINTITLE_TYPE (RTGUI_TYPE(wintitle))
|
||||
/** Casts the object to an rtgui_wintitle */
|
||||
#define RTGUI_WINTITLE(obj) (RTGUI_OBJECT_CAST((obj), RTGUI_WINTITLE_TYPE, rtgui_wintitle_t))
|
||||
/** Checks if the object is an rtgui_wintitle */
|
||||
#define RTGUI_IS_WINTITLE(obj) (RTGUI_OBJECT_CHECK_TYPE((obj), RTGUI_WINTITLE_TYPE))
|
||||
|
||||
struct rtgui_wintitle
|
||||
{
|
||||
struct rtgui_widget parent;
|
||||
};
|
||||
typedef struct rtgui_wintitle rtgui_wintitle_t;
|
||||
|
||||
rtgui_wintitle_t *rtgui_wintitle_create(struct rtgui_win *window);
|
||||
void rtgui_wintitle_destroy(rtgui_wintitle_t *wintitle);
|
||||
|
||||
rt_bool_t rtgui_wintile_event_handler(struct rtgui_object *object, rtgui_event_t *event);
|
||||
|
||||
#endif
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,191 @@
|
||||
/*
|
||||
* 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
|
||||
* 2010-05-03 Bernard add win close function
|
||||
*/
|
||||
#ifndef __RTGUI_WINDOW_H__
|
||||
#define __RTGUI_WINDOW_H__
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#include <rtgui/rtgui.h>
|
||||
#include <rtgui/list.h>
|
||||
#include <rtgui/dc.h>
|
||||
#include <rtgui/widgets/widget.h>
|
||||
#include <rtgui/widgets/box.h>
|
||||
|
||||
DECLARE_CLASS_TYPE(win);
|
||||
/** Gets the type of a win */
|
||||
#define RTGUI_WIN_TYPE (RTGUI_TYPE(win))
|
||||
/** 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_NO_FOCUS 0x0001 /* non-focused window */
|
||||
#define RTGUI_WIN_STYLE_NO_TITLE 0x0002 /* no title window */
|
||||
#define RTGUI_WIN_STYLE_NO_BORDER 0x0004 /* no border window */
|
||||
#define RTGUI_WIN_STYLE_CLOSEBOX 0x0008 /* window has the close button */
|
||||
#define RTGUI_WIN_STYLE_MINIBOX 0x0010 /* window has the mini button */
|
||||
|
||||
#define RTGUI_WIN_STYLE_DESTROY_ON_CLOSE 0x0020 /* window is destroyed when closed */
|
||||
#define RTGUI_WIN_STYLE_ONTOP 0x0040 /* window is in the top layer */
|
||||
#define RTGUI_WIN_STYLE_ONBTM 0x0080 /* window is in the bottom layer */
|
||||
#define RTGUI_WIN_STYLE_MAINWIN 0x0106 /* window is a main window */
|
||||
|
||||
#define RTGUI_WIN_STYLE_DEFAULT (RTGUI_WIN_STYLE_CLOSEBOX | RTGUI_WIN_STYLE_MINIBOX)
|
||||
|
||||
#define WINTITLE_HEIGHT 20
|
||||
#define WINTITLE_CB_WIDTH 16
|
||||
#define WINTITLE_CB_HEIGHT 16
|
||||
#define WINTITLE_BORDER_SIZE 2
|
||||
|
||||
enum rtgui_win_flag
|
||||
{
|
||||
RTGUI_WIN_FLAG_INIT = 0x00, /* init state */
|
||||
RTGUI_WIN_FLAG_MODAL = 0x01, /* modal mode window */
|
||||
RTGUI_WIN_FLAG_CLOSED = 0x02, /* window is closed */
|
||||
RTGUI_WIN_FLAG_ACTIVATE = 0x04, /* window is activated */
|
||||
RTGUI_WIN_FLAG_UNDER_MODAL = 0x08, /* window is under modal
|
||||
show(modaled by other) */
|
||||
RTGUI_WIN_FLAG_CONNECTED = 0x10, /* connected to server */
|
||||
/* window is event_key dispatcher(dispatch it to the focused widget in
|
||||
* current window) _and_ a key handler(it should be able to handle keys
|
||||
* such as ESC). Both of dispatching and handling are in the same
|
||||
* function(rtgui_win_event_handler). So we have to distinguish between the
|
||||
* two modes.
|
||||
*
|
||||
* If this flag is set, we are in key-handling mode.
|
||||
*/
|
||||
RTGUI_WIN_FLAG_HANDLE_KEY = 0x20,
|
||||
|
||||
RTGUI_WIN_FLAG_CB_PRESSED = 0x40,
|
||||
};
|
||||
|
||||
struct rtgui_win
|
||||
{
|
||||
/* inherit from container */
|
||||
rtgui_container_t parent;
|
||||
|
||||
/* drawing count */
|
||||
rt_base_t drawing;
|
||||
|
||||
/* parent window. RT_NULL if the window is a top level window */
|
||||
struct rtgui_win *parent_window;
|
||||
|
||||
struct rtgui_region outer_clip;
|
||||
struct rtgui_rect outer_extent;
|
||||
|
||||
/* the widget that will grab the focus in current window */
|
||||
struct rtgui_widget *focused_widget;
|
||||
|
||||
/* which app I belong */
|
||||
struct rtgui_app *app;
|
||||
|
||||
/* window style */
|
||||
rt_uint16_t style;
|
||||
|
||||
/* window state flag */
|
||||
enum rtgui_win_flag flag;
|
||||
|
||||
rtgui_modal_code_t modal_code;
|
||||
|
||||
/* last mouse event handled widget */
|
||||
rtgui_widget_t *last_mevent_widget;
|
||||
|
||||
/* window title */
|
||||
char *title;
|
||||
struct rtgui_wintitle *_title_wgt;
|
||||
|
||||
/* call back */
|
||||
rt_bool_t (*on_activate)(struct rtgui_object *widget, struct rtgui_event *event);
|
||||
rt_bool_t (*on_deactivate)(struct rtgui_object *widget, struct rtgui_event *event);
|
||||
rt_bool_t (*on_close)(struct rtgui_object *widget, struct rtgui_event *event);
|
||||
/* the key is sent to the focused widget by default. If the focused widget
|
||||
* and all of it's parents didn't handle the key event, it will be handled
|
||||
* by @func on_key
|
||||
*
|
||||
* If you want to handle key event on your own, it's better to overload
|
||||
* this function other than handle EVENT_KBD in event_handler.
|
||||
*/
|
||||
rt_bool_t (*on_key)(struct rtgui_object *widget, struct rtgui_event *event);
|
||||
|
||||
/* reserved user data */
|
||||
void *user_data;
|
||||
|
||||
/* Private data. */
|
||||
rt_base_t (*_do_show)(struct rtgui_win *win);
|
||||
};
|
||||
|
||||
rtgui_win_t *rtgui_win_create(struct rtgui_win *parent_window, const char *title,
|
||||
rtgui_rect_t *rect, rt_uint16_t style);
|
||||
rtgui_win_t *rtgui_mainwin_create(struct rtgui_win *parent_window, const char *title, rt_uint16_t style);
|
||||
|
||||
void rtgui_win_destroy(rtgui_win_t *win);
|
||||
|
||||
int rtgui_win_init(struct rtgui_win *win, struct rtgui_win *parent_window,
|
||||
const char *title,
|
||||
rtgui_rect_t *rect,
|
||||
rt_uint16_t style);
|
||||
int rtgui_win_fini(struct rtgui_win* win);
|
||||
|
||||
/** Close window.
|
||||
*
|
||||
* @param win the window you want to close
|
||||
*
|
||||
* @return RT_TRUE if the window is closed. RT_FALSE if not. If the onclose
|
||||
* callback returns RT_FALSE, the window won't be closed.
|
||||
*
|
||||
* \sa rtgui_win_set_onclose .
|
||||
*/
|
||||
rt_bool_t rtgui_win_close(struct rtgui_win *win);
|
||||
|
||||
rt_base_t rtgui_win_show(struct rtgui_win *win, rt_bool_t is_modal);
|
||||
rt_base_t rtgui_win_do_show(struct rtgui_win *win);
|
||||
rt_base_t rtgui_win_enter_modal(struct rtgui_win *win);
|
||||
|
||||
void rtgui_win_hide(rtgui_win_t *win);
|
||||
void rtgui_win_end_modal(rtgui_win_t *win, rtgui_modal_code_t modal_code);
|
||||
rt_err_t rtgui_win_activate(struct rtgui_win *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_update_clip(struct rtgui_win *win);
|
||||
|
||||
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);
|
||||
void rtgui_win_set_onkey(rtgui_win_t *win, rtgui_event_handler_ptr handler);
|
||||
|
||||
rt_bool_t rtgui_win_event_handler(struct rtgui_object *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);
|
||||
|
||||
struct rtgui_dc *rtgui_win_get_drawing(rtgui_win_t * win);
|
||||
|
||||
struct rtgui_win* rtgui_win_get_topmost_shown(void);
|
||||
struct rtgui_win* rtgui_win_get_next_shown(void);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
Reference in New Issue
Block a user