void tetris_refreshmap(struct rtgui_dc *dc) //刷新地图
{
rt_uint8_t i, j;
rt_uint8_t buf[5];
rtgui_rect_t rect = {XOFFSET, YOFFSET, XOFFSET + 240, YOFFSET + 400};
RTGUI_DC_FC(dc) = RTGUI_RGB(0x55, 0x55, 0x55);
rtgui_dc_fill_rect_forecolor(dc, &rect);
rect.x1 -= 10;
rect.x2 += 150;
rect.y1 -= 10;
rect.y2 += 10;
RTGUI_DC_FC(dc) = RTGUI_RGB(0x00, 0x00, 0xff);
rtgui_dc_draw_rect(dc, &rect);
rect.x1 += 290;
rect.x2 -= 30;
rect.y1 += 40;
rect.y2 -= 360;
RTGUI_DC_FC(dc) = RTGUI_RGB(0x00, 0x00, 0x00);
rtgui_dc_draw_text(dc, "下一个", &rect);
rect.y1 += 130;
rect.y2 += 130;
rtgui_dc_draw_text(dc, "总得分", &rect);
rect.y1 += 80;
rect.y2 += 80;
rtgui_dc_draw_text(dc, "LEVEL", &rect);
RTGUI_DC_FC(dc) = RTGUI_RGB(0xff, 0x00, 0x00);
rect.x1 += 20;
rect.x2 += 20;
rect.y1 -= 60;
rect.y2 -= 60;
rt_sprintf(buf, "%d", score);
rtgui_dc_fill_rect(dc, &rect);
rtgui_dc_draw_text(dc, buf, &rect);
rect.y1 += 80;
rect.y2 += 80;
rt_sprintf(buf, "%d", level);
rtgui_dc_fill_rect(dc, &rect);
rtgui_dc_draw_text(dc, buf, &rect);
for (i = 0; i < 25; i++)
{
for (j = 0; j < 15; j++)
{
if (tetris_map[j][i] != 0)
{
tetris_drawbox(dc, j, i, tetris_colors[tetris_map[j][i]]);
}
}
}
}
void _onidle(struct rtgui_object *object, rtgui_event_t *event)
{
rtgui_color_t color;
rtgui_rect_t rect, draw_rect;
struct rtgui_dc *dc;
/* 获得控件所属的DC */
// dc = rtgui_dc_hw_create(RTGUI_WIDGET(container));
dc = rtgui_dc_begin_drawing(RTGUI_WIDGET(container));
if (dc == RT_NULL)
return;
demo_view_get_logic_rect(RTGUI_CONTAINER(container), &rect);
draw_rect.x1 = RAND(rect.x1, rect.x2);
draw_rect.y1 = RAND(rect.y1, rect.y2);
draw_rect.x2 = RAND(draw_rect.x1, rect.x2);
draw_rect.y2 = RAND(draw_rect.y1, rect.y2);
color = RTGUI_RGB(rand() % 255, rand() % 255, rand() % 255);
RTGUI_WIDGET_BACKGROUND(RTGUI_WIDGET(container)) = color;
rtgui_dc_fill_rect(dc, &draw_rect);
/* 绘图完成 */
rtgui_dc_end_drawing(dc);
}
void _onidle(PVOID wdt, rtgui_event_t *event)
{
rtgui_color_t color;
rtgui_rect_t rect, draw_rect;
struct rtgui_dc *dc;
/* 获得控件所属的DC */
dc = rtgui_dc_begin_drawing(view);
if (dc == RT_NULL) return ;
rtgui_widget_get_rect(view, &rect);
rtgui_rect_inflate(&rect, -5);
rect.y1 += 35;
draw_rect.x1 = RAND(rect.x1, rect.x2);
draw_rect.y1 = RAND(rect.y1, rect.y2);
draw_rect.x2 = RAND(draw_rect.x1, rect.x2);
draw_rect.y2 = RAND(draw_rect.y1, rect.y2);
color = RTGUI_RGB(rand() % 255, rand() % 255, rand() % 255);
RTGUI_WIDGET_BACKGROUND(view) = color;
rtgui_dc_fill_rect(dc, &draw_rect);
/* 绘图完成 */
rtgui_dc_end_drawing(dc);
}
static void info_timer_timeout(rtgui_timer_t* timer, void* parameter)
{
struct rtgui_dc* dc;
rtgui_color_t saved;
dc = rtgui_dc_begin_drawing(RTGUI_WIDGET(home_view));
if (dc == RT_NULL) return ;
saved = RTGUI_WIDGET_FOREGROUND(RTGUI_WIDGET(home_view));
RTGUI_WIDGET_FOREGROUND(RTGUI_WIDGET(home_view)) = RTGUI_RGB(206, 231, 255);
rtgui_dc_draw_hline(dc, 14, 14 + (tinfo.position * 212) / tinfo.duration, 75);
if ((player_mode == PLAYER_PLAY_RADIO) && ((tinfo.position * 212 + 14)/tinfo.duration) < 226)
{
tinfo.position = net_buf_get_usage();
RTGUI_WIDGET_FOREGROUND(RTGUI_WIDGET(home_view)) = RTGUI_RGB(82, 199, 16);
rtgui_dc_draw_hline(dc, 14 + (tinfo.position * 212) / tinfo.duration, 226, 75);
}
RTGUI_WIDGET_FOREGROUND(RTGUI_WIDGET(home_view)) = saved;
if (player_mode == PLAYER_PLAY_FILE)
{
rtgui_color_t saved;
rtgui_rect_t rect;
char line[32];
play_time++;
rt_snprintf(line, sizeof(line), "%3d:%02d", play_time / 60, play_time % 60);
rect.x1 = 172;
rect.y1 = 48;
rect.x2 = 220;
rect.y2 = rect.y1 + 16;
saved = RTGUI_DC_BC(dc);
RTGUI_DC_BC(dc) = RTGUI_RGB(0, 125, 198);
rtgui_dc_fill_rect(dc, &rect);
rtgui_dc_draw_text(dc, line, &rect);
RTGUI_DC_BC(dc) = saved;
}
rtgui_dc_end_drawing(dc);
}
void rtgui_textbox_ondraw(rtgui_textbox_t *box)
{
/* draw button */
rtgui_rect_t rect;
struct rtgui_dc *dc;
rtgui_color_t fc;
RT_ASSERT(box != RT_NULL);
/* begin drawing */
dc = rtgui_dc_begin_drawing(RTGUI_WIDGET(box));
if (dc == RT_NULL)
return;
/* get widget rect */
rtgui_widget_get_rect(RTGUI_WIDGET(box), &rect);
fc = RTGUI_WIDGET_FOREGROUND(box);
rtgui_rect_inflate(&rect, -1);
/* fill widget rect with white color */
RTGUI_WIDGET_BACKGROUND(box) = white;
rtgui_dc_fill_rect(dc, &rect);
rtgui_rect_inflate(&rect, 1);
/* draw border */
RTGUI_WIDGET_FOREGROUND(box) = RTGUI_RGB(123, 158, 189);
rtgui_dc_draw_rect(dc, &rect);
/* draw text */
RTGUI_WIDGET_FOREGROUND(box) = fc;
if (box->text != RT_NULL)
{
rect.x1 += RTGUI_WIDGET_DEFAULT_MARGIN;
/* draw single text */
if (box->flag & RTGUI_TEXTBOX_MASK)
{
/* draw mask char */
rt_size_t len = rt_strlen(box->text);
if (len > 0)
{
char *text_mask = rtgui_malloc(len + 1);
rt_memset(text_mask, box->mask_char, len + 1);
text_mask[len] = 0;
rtgui_dc_draw_text(dc, text_mask+box->first_pos, &rect);
rtgui_free(text_mask);
}
}
else
{
rtgui_dc_draw_text(dc, box->text+box->first_pos, &rect);
}
}
rtgui_dc_end_drawing(dc);
}
void tetris_removebox(struct rtgui_dc *dc, rt_uint16_t bx, rt_uint16_t by)
{
rtgui_rect_t rect = (rtgui_rect_t)
{
bx * 16 + XOFFSET,
by * 16 + YOFFSET,
bx * 16 + 15 + XOFFSET,
by * 16 + + 15 + YOFFSET
};
RTGUI_DC_FC(dc) = RTGUI_RGB(0x55, 0x55, 0x55);
rtgui_dc_fill_rect_forecolor(dc, &rect);
}
static void rtgui_freetype_font_draw_text(struct rtgui_font* font, struct rtgui_dc* dc, const char* text, rt_ubase_t len, struct rtgui_rect* rect)
{
int index = 0;
FT_Error err = 0;
rt_uint16_t *text_short, *text_ptr;
struct rtgui_freetype_font* freetype;
RT_ASSERT(font != RT_NULL);
freetype = (struct rtgui_freetype_font*) font->data;
RT_ASSERT(freetype != RT_NULL);
/* allocate unicode buffer */
text_short = (rt_uint16_t*)rtgui_malloc((len + 1)* 2);
if (text_short == RT_NULL) return ; /* out of memory */
/* convert gbk to unicode */
gbk_to_unicode(text_short, text, len);
text_ptr = text_short;
while (*text_ptr)
{
index = FT_Get_Char_Index(freetype->face, *text_ptr);
err = FT_Load_Glyph(freetype->face, index, FT_LOAD_DEFAULT|FT_LOAD_RENDER);
if (err == 0)
{
int rows, x;
rt_uint8_t* ptr;
/* render font */
ptr = (rt_uint8_t*)freetype->face->glyph->bitmap.buffer;
for (rows = 0; rows < freetype->face->glyph->bitmap.rows; rows ++)
for (x = 0; x < freetype->face->glyph->bitmap.width; x++)
{
if (*ptr > 0)
rtgui_dc_draw_color_point(dc, rect->x1 + x, rect->y1 + rows, RTGUI_RGB(0xff - *ptr, 0xff - *ptr, 0xff - *ptr));
ptr ++;
}
}
text_ptr ++;
rect->x1 += freetype->face->glyph->bitmap.width;
}
/* release unicode buffer */
rtgui_free(text_short);
}
static struct rtgui_image_palette *rtgui_image_bmp_load_palette(
struct rtgui_filerw *file,
rt_uint32_t colorsUsed,
rt_bool_t alpha)
{
/* Load the palette, if any */
rt_uint32_t i;
struct rtgui_image_palette *palette;
palette = rtgui_image_palette_create(colorsUsed);
if (palette == RT_NULL)
{
return RT_NULL;
}
palette->ncolors = colorsUsed;
if (alpha)
{
rt_uint8_t temp[4];
for (i = 0; i < colorsUsed; i++)
{
if (rtgui_filerw_read(file, (void *)&temp, 1, 4) != 4)
{
rtgui_free(palette);
return RT_NULL;
}
palette->colors[i] = RTGUI_ARGB(temp[3], temp[2], temp[1], temp[0]);
}
}
else
{
rt_uint8_t temp[3];
for (i = 0; i < colorsUsed; i++)
{
if (rtgui_filerw_read(file, (void *)&temp, 1, 3) != 3)
{
rtgui_free(palette);
return RT_NULL;
}
palette->colors[i] = RTGUI_RGB(temp[2], temp[1], temp[0]);
}
}
return palette;
}
void tetris_drawbox(struct rtgui_dc *dc, rt_uint16_t bx, rt_uint16_t by, rtgui_color_t bcolor)
{
rtgui_rect_t rect = (rtgui_rect_t)
{
bx * 16 + XOFFSET,
by * 16 + YOFFSET,
bx * 16 + 15 + XOFFSET,
by * 16 + 15 + YOFFSET
};
RTGUI_DC_FC(dc) = RTGUI_RGB(0x00, 0x00, 0xff);
rtgui_dc_draw_rect(dc, &rect);
rect.x1++;
rect.x2--;
rect.y1++;
rect.y2--;
RTGUI_DC_FC(dc) = bcolor;
rtgui_dc_fill_rect_forecolor(dc, &rect);
}
static void _rtgui_button_constructor(rtgui_button_t *button)
{
/* init widget and set event handler */
RTGUI_WIDGET(button)->flag |= RTGUI_WIDGET_FLAG_FOCUSABLE;
rtgui_widget_set_event_handler(RTGUI_WIDGET(button), rtgui_button_event_handler);
/* un-press button */
button->flag = 0;
/* set flag and on_button event handler */
button->pressed_image = RT_NULL;
button->unpressed_image = RT_NULL;
button->on_button = RT_NULL;
/* set gc */
RTGUI_WIDGET_FOREGROUND(RTGUI_WIDGET(button)) = default_foreground;
RTGUI_WIDGET_BACKGROUND(RTGUI_WIDGET(button)) = RTGUI_RGB(212, 208, 200);
RTGUI_WIDGET_TEXTALIGN(RTGUI_WIDGET(button)) = RTGUI_ALIGN_CENTER_HORIZONTAL | RTGUI_ALIGN_CENTER_VERTICAL;
}
static struct rtgui_image_palette* rtgui_image_bmp_load_palette(struct rtgui_image_bmp_header* header, struct rtgui_filerw* src)
{
/* Load the palette, if any */
rt_size_t i;
struct rtgui_image_palette* palette;
if (header->biClrUsed == 0)
header->biClrUsed = 1 << header->biBitCount;
palette = rtgui_image_palette_create(header->biClrUsed);
if (palette == RT_NULL) return RT_NULL;
if ( header->biSize == 12 )
{
rt_uint8_t r, g, b;
for ( i = 0; i < (int)header->biClrUsed; ++i )
{
rtgui_filerw_read(src, &b, 1, 1);
rtgui_filerw_read(src, &g, 1, 1);
rtgui_filerw_read(src, &r, 1, 1);
palette->colors[i] = RTGUI_RGB(r, g, b);
}
}
else
{
rt_uint8_t r, g, b, a;
for ( i = 0; i < (int)header->biClrUsed; ++i )
{
rtgui_filerw_read(src, &b, 1, 1);
rtgui_filerw_read(src, &g, 1, 1);
rtgui_filerw_read(src, &r, 1, 1);
rtgui_filerw_read(src, &a, 1, 1);
palette->colors[i] = RTGUI_ARGB(a, r, g, b);
}
}
return palette;
}
void rtgui_scrollbar_hide(rtgui_scrollbar_t* bar)
{
rtgui_rect_t rect;
struct rtgui_dc* dc;
RT_ASSERT(bar != RT_NULL);
/* begin drawing */
dc = rtgui_dc_begin_drawing(RTGUI_WIDGET(bar));
if(dc == RT_NULL)return;
RTGUI_WIDGET_HIDE(bar);
/* begin drawing */
rtgui_widget_get_rect(RTGUI_WIDGET(bar), &rect);
if((RTGUI_WIDGET(bar))->parent != RT_NULL)
RTGUI_DC_BC(dc) = RTGUI_WIDGET_BACKGROUND(RTGUI_WIDGET(bar)->parent);
else
RTGUI_DC_BC(dc) = RTGUI_RGB(225, 228, 220);
rtgui_dc_fill_rect(dc,&rect);
rtgui_dc_end_drawing(dc);
}
/*
* view的事件处理函数
*/
rt_bool_t dc_event_handler(rtgui_widget_t* widget, rtgui_event_t *event)
{
/* 仅对PAINT事件进行处理 */
if (event->type == RTGUI_EVENT_PAINT) {
struct rtgui_dc* dc;
rtgui_rect_t rect;
/* const int vx[] = {20, 50, 60, 45, 60, 20};
const int vy[] = {150, 50, 90, 60, 45, 50};
*/
/*
* 因为用的是demo view，上面本身有一部分控件，所以在绘图时先要让demo view
* 先绘图
*/
rtgui_view_event_handler(widget, event);
/************************************************************************/
/* 下面的是DC的操作 */
/************************************************************************/
/* 获得控件所属的DC */
dc = rtgui_dc_begin_drawing(widget);
/* 如果不能正常获得DC，返回（如果控件或父控件是隐藏状态，DC是获取不成功的） */
if (dc == RT_NULL)
return RT_FALSE;
/* 获得demo view允许绘图的区域 */
demo_view_get_logic_rect(RTGUI_VIEW(widget), &rect);
RTGUI_DC_TEXTALIGN(dc) = RTGUI_ALIGN_BOTTOM | RTGUI_ALIGN_CENTER_HORIZONTAL;
/* 显示GUI的版本信息 */
#ifdef RTGUI_USING_SMALL_SIZE
rtgui_dc_draw_text(dc, "RT-Thread/GUI小型版本", &rect);
#else
rtgui_dc_draw_text(dc, "RT-Thread/GUI标准版本", &rect);
#endif
{
rtgui_rect_t rect = {0, 0, 0x1c, 0x16};
rtgui_rect_moveto(&rect, 80, 80);
rtgui_image_blit((rtgui_image_t*)&play_image, dc, &rect);
rect.x1 = 0;
rect.y1 = 0;
rect.x2 = 0x1c;
rect.y2 = 0x16;
rtgui_rect_moveto(&rect, 130, 80);
rtgui_image_blit((rtgui_image_t*)&stop_image, dc, &rect);
}
/* 绘制一个圆形 */
RTGUI_DC_FC(dc) = red;
rtgui_dc_draw_circle(dc, rect.x1 + 10, rect.y1 + 10, 10);
/* 填充一个圆形 */
RTGUI_DC_FC(dc) = green;
rtgui_dc_fill_circle(dc, rect.x1 + 30, rect.y1 + 10, 10);
#if 0
/* 画一个圆角矩形 */
rect.x1 = 150;
rect.y1 = 180;
rect.x2 = 210;
rect.y2 = 260;
RTGUI_DC_FC(dc) = RTGUI_RGB(25, 70, 150);
rtgui_dc_draw_round_rect(dc, &rect, 10);
rect.x1 = 160;
rect.y1 = 190;
rect.x2 = 200;
rect.y2 = 250;
RTGUI_DC_FC(dc) = RTGUI_RGB(170, 7, 80);
rtgui_dc_fill_round_rect(dc, &rect, 7);
/* 画一个圆弧 */
RTGUI_DC_FC(dc) = RTGUI_RGB(250, 120, 120);
rtgui_dc_draw_arc(dc, rect.x1 + 120, rect.y1 + 60, 30, 0, 120);
/* 画一个扇形圆环 */
RTGUI_DC_FC(dc) = RTGUI_RGB(150, 23, 100);
rtgui_dc_draw_annulus(dc, 180, 170, 30, 50, 210, 330);
/* 多边形 */
RTGUI_DC_FC(dc) = blue;
rtgui_dc_draw_polygon(dc, vx, vy, 6);
#endif
RTGUI_DC_FC(dc) = blue;
/* 绘制不同的边框 */
{
rtgui_rect_t rect = {0, 0, 16, 16};
rtgui_rect_moveto(&rect, 30, 120);
rtgui_dc_draw_border(dc, &rect, RTGUI_BORDER_RAISE);
rect.x1 += 20;
rect.x2 += 20 + 50;
rtgui_dc_draw_text(dc, "raise", &rect);
rect.x1 -= 20;
rect.x2 -= 20 + 50;
rect.y1 += 20;
rect.y2 += 20;
rtgui_dc_draw_border(dc, &rect, RTGUI_BORDER_SIMPLE);
rect.x1 += 20;
rect.x2 += 20 + 50;
rtgui_dc_draw_text(dc, "simple", &rect);
rect.x1 -= 20;
rect.x2 -= 20 + 50;
rect.y1 += 20;
rect.y2 += 20;
rtgui_dc_draw_border(dc, &rect, RTGUI_BORDER_SUNKEN);
rect.x1 += 20;
rect.x2 += 20 + 50;
rtgui_dc_draw_text(dc, "sunken", &rect);
rect.x1 -= 20;
rect.x2 -= 20 + 50;
rect.y1 += 20;
rect.y2 += 20;
rtgui_dc_draw_border(dc, &rect, RTGUI_BORDER_BOX);
rect.x1 += 20;
rect.x2 += 20 + 50;
rtgui_dc_draw_text(dc, "box", &rect);
rect.x1 -= 20;
rect.x2 -= 20 + 50;
rect.y1 += 20;
rect.y2 += 20;
rtgui_dc_draw_border(dc, &rect, RTGUI_BORDER_STATIC);
rect.x1 += 20;
rect.x2 += 20 + 50;
rtgui_dc_draw_text(dc, "static", &rect);
rect.x1 -= 20;
rect.x2 -= 20 + 50;
rect.y1 += 20;
rect.y2 += 20;
rtgui_dc_draw_border(dc, &rect, RTGUI_BORDER_EXTRA);
rect.x1 += 20;
rect.x2 += 20 + 50;
rtgui_dc_draw_text(dc, "extera", &rect);
rect.x1 -= 20;
rect.x2 -= 20 + 50;
rect.y1 += 20;
rect.y2 += 20;
}
/* 绘图完成 */
rtgui_dc_end_drawing(dc);
} else {
/* 其他事件，调用默认的事件处理函数 */
return rtgui_view_event_handler(widget, event);
}
return RT_FALSE;
}
#include "tetris_ui.h"
/*声明定时器*/
rtgui_timer_t *timer;
rt_bool_t tobuttom = RT_FALSE;
rt_uint32_t score = 0;
rt_uint8_t level = 1;
rtgui_win_t *win;
const rtgui_color_t tetris_colors[] = {0, RTGUI_RGB(0x00, 0x00, 0xff), RTGUI_RGB(0xff, 0x00, 0x00), RTGUI_RGB(0xff, 0x00, 0xff), RTGUI_RGB(0x00, 0xff, 0x00), RTGUI_RGB(0xff, 0xff, 0x00)}; //颜色数组，声明要用到的颜色
const rt_uint8_t box[56] = //方块数组，包括七种方块，每种四种状态
{
0x80, 0x0e, 0x46, 0x04, 0x70, 0x01, 0x20, 0x62, /*J*/
0x20, 0x0e, 0x44, 0x06, 0x70, 0x04, 0x60, 0x22, /*L*/
0x60, 0x0c, 0x64, 0x02, 0x30, 0x06, 0x40, 0x26, /*s*/
0xc0, 0x06, 0x62, 0x04, 0x60, 0x03, 0x20, 0x46, /*z*/
0x40, 0x0e, 0x64, 0x04, 0x70, 0x02, 0x20, 0x26, /*T*/
0x44, 0x44, 0xf0, 0x00, 0x22, 0x22, 0x00, 0x0f, /*I*/
0xc0, 0x0c, 0x66, 0x00, 0x30, 0x03, 0x00, 0x66, /*O*/
};
tetrisBox now, next;
rt_uint8_t tetris_map[15][25]; //地图数组，包括二十行十列，存方块的颜色类型
void tetris_init_map()
{
rt_uint8_t i, j;
for (i = 0; i < 15; i++)
{
for (j = 0; j < 25; j++)
{
void rtgui_theme_draw_progressbar(struct rtgui_progressbar* bar)
{
/* draw progress bar */
struct rtgui_dc* dc;
struct rtgui_rect rect;
int max = bar->range;
int pos = bar->position;
int left;
rtgui_color_t bc;
/* begin drawing */
dc = rtgui_dc_begin_drawing(&(bar->parent));
if (dc == RT_NULL) return;
bc = RTGUI_DC_BC(dc);
rtgui_widget_get_rect(&(bar->parent), &rect);
/* fill button rect with background color */
bar->parent.gc.background = RTGUI_RGB(212, 208, 200);
/* draw border */
rect.x2 --; rect.y2 --;
rtgui_dc_draw_border(dc, &rect, RTGUI_BORDER_SUNKEN);
/* Nothing to draw */
if (max == 0)
{
rtgui_dc_end_drawing(dc);
return;
}
rect.x2 ++; rect.y2 ++;
left = max - pos;
rtgui_rect_inflate(&rect, -2);
bar->parent.gc.background = RTGUI_RGB(0, 0, 255);
if (bar->orient == RTGUI_VERTICAL)
{
/* Vertical bar grows from bottom to top */
int dy = (rtgui_rect_height(rect) * left) / max;
rect.y1 += dy;
rtgui_dc_fill_rect(dc, &rect);
RTGUI_DC_BC(dc) = bc;
rect.y1 -= dy; rect.y2 = dy;
rtgui_dc_fill_rect(dc, &rect);
}
else
{
/* Horizontal bar grows from left to right */
int dx = (rtgui_rect_width(rect) * left) / max;
rect.x2 -= dx;
rtgui_dc_fill_rect(dc, &rect);
RTGUI_DC_BC(dc) = bc;
rect.x1 = rect.x2; rect.x2 += dx;
rtgui_dc_fill_rect(dc, &rect);
}
/* end drawing */
rtgui_dc_end_drawing(dc);
return;
}
void rtgui_theme_draw_scrollbar(struct rtgui_scrollbar* bar)
{
/* draw scroll bar */
struct rtgui_dc* dc;
rtgui_rect_t rect, btn_rect, thum_rect, arrow_rect;
rtgui_color_t bc, fc;
/* begin drawing */
dc = rtgui_dc_begin_drawing(&(bar->parent));
if (dc == RT_NULL) return;
rtgui_widget_get_rect(RTGUI_WIDGET(bar), &rect);
/* draw background */
fc = RTGUI_WIDGET_FOREGROUND(RTGUI_WIDGET(bar));
if (!RTGUI_WIDGET_IS_ENABLE(RTGUI_WIDGET(bar)))
RTGUI_WIDGET_FOREGROUND(RTGUI_WIDGET(bar)) = RTGUI_RGB(128, 128, 128);
bc = RTGUI_WIDGET_BACKGROUND(RTGUI_WIDGET(bar));
RTGUI_WIDGET_BACKGROUND(RTGUI_WIDGET(bar)) = white;
rtgui_dc_fill_rect(dc, &rect);
RTGUI_WIDGET_BACKGROUND(RTGUI_WIDGET(bar)) = bc;
if (bar->orient == RTGUI_VERTICAL)
{
btn_rect = rect;
btn_rect.y2 = btn_rect.y1 + (rect.x2 - rect.x1);
/* draw up button */
rtgui_dc_fill_rect(dc, &btn_rect);
if (bar->status & SBS_UPARROW) rtgui_dc_draw_border(dc, &btn_rect, RTGUI_BORDER_SUNKEN);
else rtgui_dc_draw_border(dc, &btn_rect, RTGUI_BORDER_RAISE);
/* draw arrow */
arrow_rect.x1 = 0; arrow_rect.y1 = 0;
arrow_rect.x2 = 7; arrow_rect.y2 = 4;
rtgui_rect_moveto_align(&btn_rect, &arrow_rect,
RTGUI_ALIGN_CENTER_HORIZONTAL | RTGUI_ALIGN_CENTER_VERTICAL);
rtgui_dc_draw_byte(dc, arrow_rect.x1, arrow_rect.y1,
rtgui_rect_height(arrow_rect), _up_arrow);
/* draw thumb */
if (RTGUI_WIDGET_IS_ENABLE(RTGUI_WIDGET(bar)))
{
rtgui_scrollbar_get_thumb_rect(bar, &thum_rect);
rtgui_dc_fill_rect(dc, &thum_rect);
rtgui_dc_draw_border(dc, &thum_rect, RTGUI_BORDER_RAISE);
}
/* draw down button */
btn_rect.y1 = rect.y2 - (rect.x2 - rect.x1);
btn_rect.y2 = rect.y2;
rtgui_dc_fill_rect(dc, &btn_rect);
if (bar->status & SBS_DOWNARROW) rtgui_dc_draw_border(dc, &btn_rect, RTGUI_BORDER_SUNKEN);
else rtgui_dc_draw_border(dc, &btn_rect, RTGUI_BORDER_RAISE);
arrow_rect.x1 = 0; arrow_rect.y1 = 0;
arrow_rect.x2 = 7; arrow_rect.y2 = 4;
rtgui_rect_moveto_align(&btn_rect, &arrow_rect,
RTGUI_ALIGN_CENTER_HORIZONTAL | RTGUI_ALIGN_CENTER_VERTICAL);
rtgui_dc_draw_byte(dc, arrow_rect.x1, arrow_rect.y1,
rtgui_rect_height(arrow_rect), _down_arrow);
}
else
{
btn_rect.x1 = rect.x1;
btn_rect.y1 = rect.y1;
btn_rect.x2 = rect.y2;
btn_rect.y2 = rect.y2;
/* draw left button */
rtgui_dc_fill_rect(dc, &btn_rect);
if (bar->status & SBS_LEFTARROW) rtgui_dc_draw_border(dc, &btn_rect, RTGUI_BORDER_SUNKEN);
else rtgui_dc_draw_border(dc, &btn_rect, RTGUI_BORDER_RAISE);
arrow_rect.x1 = 0; arrow_rect.y1 = 0;
arrow_rect.x2 = 4; arrow_rect.y2 = 7;
rtgui_rect_moveto_align(&btn_rect, &arrow_rect,
RTGUI_ALIGN_CENTER_HORIZONTAL | RTGUI_ALIGN_CENTER_VERTICAL);
rtgui_dc_draw_byte(dc, arrow_rect.x1, arrow_rect.y1,
rtgui_rect_height(arrow_rect), _left_arrow);
/* draw thumb */
if (RTGUI_WIDGET_IS_ENABLE(RTGUI_WIDGET(bar)))
{
rtgui_scrollbar_get_thumb_rect(bar, &thum_rect);
rtgui_dc_fill_rect(dc, &thum_rect);
rtgui_dc_draw_border(dc, &thum_rect, RTGUI_BORDER_RAISE);
}
btn_rect.x1 = rect.x2 - rect.y2;
btn_rect.x2 = rect.x2;
/* draw right button */
rtgui_dc_fill_rect(dc, &btn_rect);
if (bar->status & SBS_RIGHTARROW) rtgui_dc_draw_border(dc, &btn_rect, RTGUI_BORDER_SUNKEN);
else rtgui_dc_draw_border(dc, &btn_rect, RTGUI_BORDER_RAISE);
arrow_rect.x1 = 0; arrow_rect.y1 = 0;
arrow_rect.x2 = 4; arrow_rect.y2 = 7;
rtgui_rect_moveto_align(&btn_rect, &arrow_rect,
RTGUI_ALIGN_CENTER_HORIZONTAL | RTGUI_ALIGN_CENTER_VERTICAL);
rtgui_dc_draw_byte(dc, arrow_rect.x1, arrow_rect.y1,
rtgui_rect_height(arrow_rect), _right_arrow);
}
/* end drawing */
rtgui_dc_end_drawing(dc);
RTGUI_WIDGET_FOREGROUND(RTGUI_WIDGET(bar)) = fc;
return;
}
void rtgui_theme_draw_radiobox(struct rtgui_radiobox* radiobox)
{
struct rtgui_dc* dc;
struct rtgui_rect rect, item_rect;
int item_size, bord_size, index;
rtgui_color_t fc;
/* begin drawing */
dc = rtgui_dc_begin_drawing(RTGUI_WIDGET(radiobox));
if (dc == RT_NULL) return;
/* get widget rect */
rtgui_widget_get_rect(RTGUI_WIDGET(radiobox), &rect);
rtgui_dc_fill_rect(dc, &rect);
item_size = radiobox->item_size;
/* get board size */
if (radiobox->orient == RTGUI_VERTICAL)
bord_size = item_size;
else
{
rtgui_font_get_metrics(RTGUI_DC_FONT(dc), "H", &item_rect);
bord_size = rtgui_rect_height(item_rect);
}
/* draw box */
rtgui_rect_inflate(&rect, -bord_size/2);
fc = RTGUI_WIDGET_FOREGROUND(RTGUI_WIDGET(radiobox));
RTGUI_WIDGET_FOREGROUND(RTGUI_WIDGET(radiobox)) = white;
rect.x1 ++; rect.y1 ++; rect.x2 ++; rect.y2 ++;
rtgui_dc_draw_rect(dc, &rect);
RTGUI_WIDGET_FOREGROUND(RTGUI_WIDGET(radiobox)) = RTGUI_RGB(128, 128, 128);
rect.x1 --; rect.y1 --; rect.x2 --; rect.y2 --;
rtgui_dc_draw_rect(dc, &rect);
RTGUI_WIDGET_FOREGROUND(RTGUI_WIDGET(radiobox)) = fc;
rtgui_rect_inflate(&rect, bord_size/2);
if (radiobox->text != RT_NULL)
{
struct rtgui_rect text_rect;
/* draw group text */
rtgui_font_get_metrics(RTGUI_DC_FONT(dc), radiobox->text, &text_rect);
rtgui_rect_moveto(&text_rect, rect.x1 + bord_size + 5, rect.y1);
rect.x1 -= 5; rect.x2 += 5;
rtgui_dc_fill_rect(dc, &text_rect);
rect.x1 += 5; rect.x2 -= 5;
rtgui_dc_draw_text(dc, radiobox->text, &text_rect);
}
/* set init item rect */
item_rect = rect;
rtgui_rect_inflate(&item_rect, - bord_size);
if (radiobox->orient == RTGUI_VERTICAL)
{
rt_uint16_t offset;
/* set the first text rect */
item_rect.y2 = item_rect.y1 + item_size;
offset = (item_size - RADIO_BOX_H) / 2;
/* draw each radio button */
for (index = 0; index < radiobox->item_count; index ++)
{
if (item_rect.y2 > rect.y2 - item_size) break;
/* draw radio */
if (radiobox->item_selection == index)
{
if (RTGUI_WIDGET_IS_FOCUSED(RTGUI_WIDGET(radiobox)))
rtgui_dc_draw_focus_rect(dc, &item_rect);
rtgui_dc_draw_word(dc, item_rect.x1, item_rect.y1 + offset, RADIO_BOX_H, radio_checked_byte);
}
else
{
rtgui_dc_draw_word(dc, item_rect.x1, item_rect.y1 + offset, RADIO_BOX_H, radio_unchecked_byte);
}
/* draw text */
item_rect.x1 += item_size + 3;
rtgui_dc_draw_text(dc, radiobox->items[index], &item_rect);
item_rect.x1 -= item_size + 3;
item_rect.y1 += item_size;
item_rect.y2 += item_size;
}
}
else
{
/* set the first text rect */
item_rect.x2 = item_rect.x1 + item_size;
item_rect.y2 = item_rect.y1 + bord_size;
/* draw each radio button */
for (index = 0; index < radiobox->item_count; index ++)
{
if (item_rect.x2 > rect.x2 - item_size) break;
/* draw radio */
if (radiobox->item_selection == index)
{
if (RTGUI_WIDGET_IS_FOCUSED(RTGUI_WIDGET(radiobox)))
rtgui_dc_draw_focus_rect(dc, &item_rect);
rtgui_dc_draw_word(dc, item_rect.x1, item_rect.y1, RADIO_BOX_H, radio_checked_byte);
}
else
{
rtgui_dc_draw_word(dc, item_rect.x1, item_rect.y1, RADIO_BOX_H, radio_unchecked_byte);
}
/* draw text */
item_rect.x1 += bord_size + 3;
rtgui_dc_draw_text(dc, radiobox->items[index], &item_rect);
item_rect.x1 -= bord_size + 3;
item_rect.x1 += item_size;
item_rect.x2 += (item_size - 1);
}
}
/* end drawing */
rtgui_dc_end_drawing(dc);
}
/* window drawing */
void rtgui_theme_draw_win(struct rtgui_topwin* win)
{
struct rtgui_dc* dc;
rtgui_rect_t rect;
if (win->title == RT_NULL) return; /* no title and no board */
/* begin drawing */
dc = rtgui_dc_begin_drawing(RTGUI_WIDGET(win->title));
if (dc == RT_NULL) return;
/* get rect */
rtgui_widget_get_rect(RTGUI_WIDGET(win->title), &rect);
/* draw border */
if (win->flag & WINTITLE_BORDER)
{
rect.x2 -= 1; rect.y2 -= 1;
RTGUI_WIDGET_FOREGROUND(RTGUI_WIDGET(win->title)) = RTGUI_RGB(212, 208, 200);
rtgui_dc_draw_hline(dc, rect.x1, rect.x2, rect.y1);
rtgui_dc_draw_vline(dc, rect.x1, rect.y1, rect.y2);
RTGUI_WIDGET_FOREGROUND(RTGUI_WIDGET(win->title)) = white;
rtgui_dc_draw_hline(dc, rect.x1 + 1, rect.x2 - 1, rect.y1 + 1);
rtgui_dc_draw_vline(dc, rect.x1 + 1, rect.y1 + 1, rect.y2 - 1);
RTGUI_WIDGET_FOREGROUND(RTGUI_WIDGET(win->title)) = RTGUI_RGB(128, 128, 128);
rtgui_dc_draw_hline(dc, rect.x1 + 1, rect.x2 - 1, rect.y2 - 1);
rtgui_dc_draw_vline(dc, rect.x2 - 1, rect.y1 + 1, rect.y2 - 1);
RTGUI_WIDGET_FOREGROUND(RTGUI_WIDGET(win->title)) = RTGUI_RGB(64, 64, 64);
rtgui_dc_draw_hline(dc, rect.x1, rect.x2, rect.y2);
rtgui_dc_draw_vline(dc, rect.x2, rect.y1, rect.y2);
/* shrink border */
rtgui_rect_inflate(&rect, -WINTITLE_BORDER_SIZE);
}
/* draw title */
if (!(win->flag & WINTITLE_NO))
{
rt_uint32_t index;
float r, g, b, delta;
if (win->flag & WINTITLE_ACTIVATE)
{
r = 10; g = 36; b = 106;
delta = 150 / (float)(rect.x2 - rect.x1);
}
else
{
r = 128; g = 128; b = 128;
delta = 64 / (float)(rect.x2 - rect.x1);
}
RTGUI_WIDGET_FOREGROUND(RTGUI_WIDGET(win->title)) = RTGUI_RGB(r, g, b);
for (index = rect.x1; index < rect.x2 + 1; index ++)
{
rtgui_dc_draw_vline(dc, index, rect.y1, rect.y2);
r += delta; g += delta; b += delta;
}
if (win->flag & WINTITLE_ACTIVATE)
{
RTGUI_WIDGET_FOREGROUND(RTGUI_WIDGET(win->title)) = white;
}
else
{
RTGUI_WIDGET_FOREGROUND(RTGUI_WIDGET(win->title)) = RTGUI_RGB(212, 208, 200);
}
rect.x1 += 4;
rect.y1 += 2; rect.y2 = rect.y1 + WINTITLE_CB_HEIGHT;
rtgui_dc_draw_text(dc, rtgui_wintitle_get_title(win->title), &rect);
if (win->flag & WINTITLE_CLOSEBOX)
{
/* get close button rect */
rtgui_rect_t box_rect = {0, 0, WINTITLE_CB_WIDTH, WINTITLE_CB_HEIGHT};
rtgui_rect_moveto_align(&rect, &box_rect, RTGUI_ALIGN_CENTER_VERTICAL | RTGUI_ALIGN_RIGHT);
box_rect.x1 -= 3; box_rect.x2 -= 3;
rtgui_dc_fill_rect(dc, &box_rect);
/* draw close box */
if (win->flag & WINTITLE_CB_PRESSED)
{
rtgui_dc_draw_border(dc, &box_rect, RTGUI_BORDER_SUNKEN);
RTGUI_WIDGET_FOREGROUND(RTGUI_WIDGET(win->title)) = red;
rtgui_dc_draw_word(dc, box_rect.x1, box_rect.y1 + 6, 7, close_byte);
}
else
{
rtgui_dc_draw_border(dc, &box_rect, RTGUI_BORDER_RAISE);
RTGUI_WIDGET_FOREGROUND(RTGUI_WIDGET(win->title)) = black;
rtgui_dc_draw_word(dc, box_rect.x1 - 1, box_rect.y1 + 5, 7, close_byte);
}
}
}
rtgui_dc_end_drawing(dc);
}
void rtgui_theme_draw_checkbox(struct rtgui_checkbox* checkbox)
{
struct rtgui_dc* dc;
struct rtgui_rect rect, box_rect;
rtgui_color_t bc, fc;
fc = RTGUI_WIDGET_FOREGROUND(RTGUI_WIDGET(checkbox));
bc = RTGUI_WIDGET_BACKGROUND(RTGUI_WIDGET(checkbox));
/* begin drawing */
dc = rtgui_dc_begin_drawing(RTGUI_WIDGET(checkbox));
if (dc == RT_NULL) return;
/* get rect */
rtgui_widget_get_rect(RTGUI_WIDGET(checkbox), &rect);
/* fill rect */
rtgui_dc_fill_rect(dc, &rect);
if (RTGUI_WIDGET_IS_FOCUSED(RTGUI_WIDGET(checkbox)))
{
RTGUI_WIDGET_FOREGROUND(RTGUI_WIDGET(checkbox)) = black;
/* draw focused border */
rtgui_rect_inflate(&rect, -1);
rtgui_dc_draw_focus_rect(dc, &rect);
rtgui_rect_inflate(&rect, 1);
}
/* draw check box */
box_rect.x1 = 0;
box_rect.y1 = 0;
box_rect.x2 = CHECK_BOX_W;
box_rect.y2 = CHECK_BOX_H;
rtgui_rect_moveto_align(&rect, &box_rect, RTGUI_ALIGN_CENTER_VERTICAL);
box_rect.x1 += 2; box_rect.x2 += 2;
rtgui_dc_draw_border(dc, &box_rect, RTGUI_BORDER_BOX);
rtgui_rect_inflate(&box_rect, -1);
RTGUI_WIDGET_BACKGROUND(RTGUI_WIDGET(checkbox)) = RTGUI_RGB(247, 247, 246);
rtgui_dc_fill_rect(dc, &box_rect);
if (checkbox->status_down == RTGUI_CHECKBOX_STATUS_CHECKED)
{
RTGUI_WIDGET_FOREGROUND(RTGUI_WIDGET(checkbox)) = RTGUI_RGB(33, 161, 33);
rtgui_dc_draw_byte(dc, box_rect.x1 + 2, box_rect.y1 + 2, 7, checked_byte);
}
/* restore saved color */
RTGUI_WIDGET_BACKGROUND(RTGUI_WIDGET(checkbox)) = bc;
RTGUI_WIDGET_FOREGROUND(RTGUI_WIDGET(checkbox)) = fc;
/* draw text */
rect.x1 += rtgui_rect_height(rect) - 4 + 5;
rtgui_dc_draw_text(dc, rtgui_label_get_text(RTGUI_LABEL(checkbox)), &rect);
/* end drawing */
rtgui_dc_end_drawing(dc);
return;
}
void rtgui_theme_draw_textbox(rtgui_textbox_t* box)
{
/* draw button */
struct rtgui_dc* dc;
struct rtgui_rect rect;
rtgui_color_t fc;
/* begin drawing */
dc = rtgui_dc_begin_drawing(RTGUI_WIDGET(box));
if (dc == RT_NULL) return;
/* get widget rect */
rtgui_widget_get_rect(RTGUI_WIDGET(box), &rect);
fc = RTGUI_WIDGET_FOREGROUND(RTGUI_WIDGET(box));
/* fill widget rect with white color */
RTGUI_WIDGET_BACKGROUND(RTGUI_WIDGET(box)) = white;
rtgui_dc_fill_rect(dc, &rect);
/* draw border */
RTGUI_WIDGET_FOREGROUND(RTGUI_WIDGET(box)) = RTGUI_RGB(123, 158, 189);
rtgui_dc_draw_rect(dc, &rect);
/* draw text */
RTGUI_WIDGET_FOREGROUND(RTGUI_WIDGET(box)) = fc;
if (box->text != RT_NULL)
{
rect.x1 += RTGUI_TEXTBOX_MARGIN;
if (box->flag & RTGUI_TEXTBOX_MASK)
{
/* draw '*' */
rt_size_t len = rt_strlen(box->text);
if (len > 0)
{
char *text_mask = rtgui_malloc(len + 1);
rt_memset(text_mask, '*', len + 1);
text_mask[len] = 0;
rtgui_dc_draw_text(dc, text_mask, &rect);
rt_free(text_mask);
}
}
else
{
rtgui_dc_draw_text(dc, box->text, &rect);
}
/* draw caret */
if (box->flag & RTGUI_TEXTBOX_CARET_SHOW)
{
rect.x1 += box->position * box->font_width;
rect.x2 = rect.x1 + box->font_width;
rect.y2 -= 2;
rect.y1 = rect.y2 - 3;
RTGUI_WIDGET_BACKGROUND(RTGUI_WIDGET(box)) = black;
rtgui_dc_fill_rect(dc, &rect);
}
}
/* end drawing */
rtgui_dc_end_drawing(dc);
}
/* widget drawing */
void rtgui_theme_draw_button(rtgui_button_t* btn)
{
/* draw button */
struct rtgui_dc* dc;
struct rtgui_rect rect;
rtgui_color_t bc, fc;
/* begin drawing */
dc = rtgui_dc_begin_drawing(RTGUI_WIDGET(btn));
if (dc == RT_NULL) return;
/* get widget rect */
rtgui_widget_get_rect(RTGUI_WIDGET(btn), &rect);
/* get foreground color */
bc = RTGUI_WIDGET_BACKGROUND(RTGUI_WIDGET(btn));
fc = RTGUI_WIDGET_FOREGROUND(RTGUI_WIDGET(btn));
if (btn->flag & RTGUI_BUTTON_TYPE_PUSH && btn->flag & RTGUI_BUTTON_FLAG_PRESS)
{
/* fill button rect with background color */
rtgui_dc_fill_rect(dc, &rect);
/* draw border */
RTGUI_WIDGET_FOREGROUND(RTGUI_WIDGET(btn)) = RTGUI_RGB(64, 64, 64);
rtgui_dc_draw_hline(dc, rect.x1, rect.x2, rect.y1);
rtgui_dc_draw_vline(dc, rect.x1, rect.y1, rect.y2);
RTGUI_WIDGET_FOREGROUND(RTGUI_WIDGET(btn)) = RTGUI_RGB(128, 128, 128);
rtgui_dc_draw_hline(dc, rect.x1, rect.x2 - 1, rect.y1 + 1);
rtgui_dc_draw_vline(dc, rect.x1 + 1, rect.y1 + 1, rect.y2 - 2);
RTGUI_WIDGET_FOREGROUND(RTGUI_WIDGET(btn)) = RTGUI_RGB(255, 255, 255);
rtgui_dc_draw_hline(dc, rect.x1, rect.x2 + 1, rect.y2 - 1);
rtgui_dc_draw_vline(dc, rect.x2 - 1, rect.y1, rect.y2);
if (btn->pressed_image != RT_NULL)
{
rtgui_rect_t image_rect;
image_rect.x1 = 0; image_rect.y1 = 0;
image_rect.x2 = btn->unpressed_image->w;
image_rect.y2 = btn->unpressed_image->h;
rtgui_rect_moveto_align(&rect, &image_rect, RTGUI_ALIGN_CENTER_HORIZONTAL | RTGUI_ALIGN_CENTER_VERTICAL);
rtgui_image_blit(btn->pressed_image, dc, &image_rect);
}
}
else if (btn->flag & RTGUI_BUTTON_FLAG_PRESS)
{
if (btn->pressed_image != RT_NULL)
{
rtgui_rect_t image_rect;
image_rect.x1 = 0; image_rect.y1 = 0;
image_rect.x2 = btn->unpressed_image->w;
image_rect.y2 = btn->unpressed_image->h;
rtgui_rect_moveto_align(&rect, &image_rect, RTGUI_ALIGN_CENTER_HORIZONTAL | RTGUI_ALIGN_CENTER_VERTICAL);
rtgui_image_blit(btn->pressed_image, dc, &image_rect);
}
else
{
/* fill button rect with background color */
RTGUI_WIDGET_BACKGROUND(RTGUI_WIDGET(btn)) = RTGUI_RGB(0xff, 0xff, 0xff);
rtgui_dc_fill_rect(dc, &rect);
/* draw border */
RTGUI_WIDGET(btn)->gc.foreground = RTGUI_RGB(0, 0, 0);
rtgui_dc_draw_rect(dc, &rect);
RTGUI_WIDGET(btn)->gc.foreground = RTGUI_RGB(128, 128, 128);
rect.x1 += 1; rect.y1 += 1; rect.x2 -= 1; rect.y2 -= 1;
rtgui_dc_draw_rect(dc, &rect);
}
}
else
{
if (btn->unpressed_image != RT_NULL)
{
rtgui_rect_t image_rect;
image_rect.x1 = 0; image_rect.y1 = 0;
image_rect.x2 = btn->unpressed_image->w;
image_rect.y2 = btn->unpressed_image->h;
rtgui_rect_moveto_align(&rect, &image_rect, RTGUI_ALIGN_CENTER_HORIZONTAL | RTGUI_ALIGN_CENTER_VERTICAL);
rtgui_image_blit(btn->unpressed_image, dc, &image_rect);
}
else
{
/* fill button rect with background color */
rtgui_dc_fill_rect(dc, &rect);
/* draw border */
RTGUI_WIDGET(btn)->gc.foreground = RTGUI_RGB(255, 255, 255);
rtgui_dc_draw_hline(dc, rect.x1, rect.x2, rect.y1);
rtgui_dc_draw_vline(dc, rect.x1, rect.y1, rect.y2);
RTGUI_WIDGET(btn)->gc.foreground = RTGUI_RGB(0, 0, 0);
rtgui_dc_draw_hline(dc, rect.x1, rect.x2 + 1, rect.y2);
rtgui_dc_draw_vline(dc, rect.x2, rect.y1, rect.y2);
RTGUI_WIDGET(btn)->gc.foreground = RTGUI_RGB(128, 128, 128);
rtgui_dc_draw_hline(dc, rect.x1 + 1, rect.x2, rect.y2 - 1);
rtgui_dc_draw_vline(dc, rect.x2 - 1, rect.y1 + 1, rect.y2 - 1);
}
}
if (RTGUI_WIDGET_IS_FOCUSED(RTGUI_WIDGET(btn)))
{
/* re-set foreground and get default rect */
rtgui_widget_get_rect(RTGUI_WIDGET(btn), &rect);
rtgui_rect_inflate(&rect, -2);
RTGUI_WIDGET_FOREGROUND(RTGUI_WIDGET(btn)) = black;
rtgui_dc_draw_focus_rect(dc, &rect);
}
/* set forecolor */
RTGUI_WIDGET_BACKGROUND(RTGUI_WIDGET(btn)) = bc;
RTGUI_WIDGET_FOREGROUND(RTGUI_WIDGET(btn)) = fc;
if (btn->pressed_image == RT_NULL)
{
/* re-set foreground and get default rect */
rtgui_widget_get_rect(RTGUI_WIDGET(btn), &rect);
/* remove border */
rtgui_rect_inflate(&rect, -2);
/* draw text */
rtgui_dc_draw_text(dc, rtgui_label_get_text(RTGUI_LABEL(btn)), &rect);
}
/* end drawing */
rtgui_dc_end_drawing(dc);
}
/*
* File : color.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
*/
#include <rtgui/color.h>
const rtgui_color_t red = RTGUI_RGB(0xff, 0x00, 0x00);
const rtgui_color_t green = RTGUI_RGB(0x00, 0xff, 0x00);
const rtgui_color_t blue = RTGUI_RGB(0x00, 0x00, 0xff);
const rtgui_color_t black = RTGUI_RGB(0x00, 0x00, 0x00);
const rtgui_color_t white = RTGUI_RGB(0xff, 0xff, 0xff);
const rtgui_color_t high_light = RTGUI_RGB(0xfc, 0xfc, 0xfc);
const rtgui_color_t dark_grey = RTGUI_RGB(0x7f, 0x7f, 0x7f);
const rtgui_color_t light_grey = RTGUI_RGB(0xc0, 0xc0, 0xc0);
const static rt_uint8_t pixel_bits_table[] =
{
1, /* mono */
2, /* 4 level for gray */
4, /* 16 level for gray */
8, /* RGB332 */
static void rtgui_image_png_blit(struct rtgui_image *image, struct rtgui_dc *dc, struct rtgui_rect *rect)
{
rt_uint16_t x, y, w, h;
rtgui_color_t *ptr;
struct rtgui_image_png *png;
int fg_maxsample;
int ialpha;
float alpha;
rtgui_color_t color;
rtgui_color_t c, bgcolor;
int fc[3], bc[3];
struct rtgui_graphic_driver *hwdev = rtgui_graphic_get_device();
RT_ASSERT(image != RT_NULL && dc != RT_NULL && rect != RT_NULL);
RT_ASSERT(image->data != RT_NULL);
png = (struct rtgui_image_png *) image->data;
w = _UI_MIN(image->w, rtgui_rect_width(*rect));
h = _UI_MIN(image->h, rtgui_rect_height(*rect));
fg_maxsample = (1 << png->info_ptr->bit_depth) - 1;
if (png->pixels != RT_NULL)
{
ptr = (rtgui_color_t *)png->pixels;
bgcolor = RTGUI_DC_BC(dc);
bc[0] = RTGUI_RGB_R(bgcolor);
bc[1] = RTGUI_RGB_G(bgcolor);
bc[2] = RTGUI_RGB_B(bgcolor);
/* draw each point within dc */
for (y = 0; y < h; y ++)
{
for (x = 0; x < w; x++)
{
c = *ptr;
ialpha = RTGUI_RGB_A(c);
if (ialpha == 0)
{
/*
* Foreground image is transparent hear.
* If the background image is already in the frame
* buffer, there is nothing to do.
*/
}
else if (ialpha == fg_maxsample)
{
/*
* Copy foreground pixel to frame buffer.
*/
rtgui_dc_draw_color_point(dc, x + rect->x1, y + rect->y1, c);
}
else
{
/* output = alpha * foreground + (1-alpha) * background */
/*
* Compositing is necessary.
* Get floating-point alpha and its complement.
* Note: alpha is always linear: gamma does not
* affect it.
*/
fc[0] = RTGUI_RGB_R(c);
fc[1] = RTGUI_RGB_G(c);
fc[2] = RTGUI_RGB_B(c);
alpha = (float) ialpha / fg_maxsample;
color = RTGUI_RGB((rt_uint8_t)(fc[0] * alpha + bc[0] * (1 - alpha)),
(rt_uint8_t)(fc[1] * alpha + bc[1] * (1 - alpha)),
(rt_uint8_t)(fc[2] * alpha + bc[2] * (1 - alpha)));
rtgui_dc_draw_color_point(dc, x + rect->x1, y + rect->y1, color);
}
/* move to next color buffer */
ptr ++;
}
}
}
else
{
png_bytep row;
png_bytep data;
row = (png_bytep) rtgui_malloc(png_get_rowbytes(png->png_ptr, png->info_ptr));
if (row == RT_NULL) return ;
switch (png->info_ptr->color_type)
{
case PNG_COLOR_TYPE_RGB:
for (y = 0; y < h; y++)
{
png_read_row(png->png_ptr, row, png_bytep_NULL);
for (x = 0; x < w; x++)
{
data = &(row[x * 3]);
rtgui_dc_draw_color_point(dc, x + rect->x1, y + rect->y1,
RTGUI_RGB(data[0], data[1], data[2]));
}
}
break;
case PNG_COLOR_TYPE_RGBA:
for (y = 0; y < h; y++)
{
png_read_row(png->png_ptr, row, png_bytep_NULL);
for (x = 0; x < w; x++)
{
data = &(row[x * 4]);
if (data[3] != 0)
{
rtgui_dc_draw_color_point(dc, x + rect->x1, y + rect->y1,
RTGUI_ARGB(data[3], data[0], data[1], data[2]));
}
}
}
break;
case PNG_COLOR_TYPE_PALETTE:
for (y = 0; y < h; y++)
{
png_read_row(png->png_ptr, row, png_bytep_NULL);
for (x = 0; x < w; x++)
{
data = &(row[x]);
rtgui_dc_draw_color_point(dc, x + rect->x1, y + rect->y1,
RTGUI_ARGB(0, png->info_ptr->palette[data[0]].red,
png->info_ptr->palette[data[0]].green,
png->info_ptr->palette[data[0]].blue));
}
}
default:
break;
};
rtgui_free(row);
}
}
void app_mgr_win_init(void)
{
struct rtgui_win* win;
rtgui_rect_t rect;
struct rtgui_notebook *notebook;
rtgui_listbox_t* box;
struct rtgui_image* pressed_image;
struct rtgui_image* unpressed_image;
int font_size;
struct block_panel* block;
int angle_y;
/* create main window of Application Manager */
win = rtgui_mainwin_create(RT_NULL, "AppMgr", RTGUI_WIN_STYLE_MAINWIN);
RTGUI_WIDGET_BACKGROUND(win) = RTGUI_RGB(241, 241, 241);
/* create icon image */
pressed_image = rtgui_image_create_from_mem("xpm", (const rt_uint8_t*)home_xpm, sizeof(home_xpm), RT_FALSE);
unpressed_image = rtgui_image_create_from_mem("xpm", (const rt_uint8_t*)home_gray_xpm, sizeof(home_gray_xpm), RT_FALSE);
rtgui_font_get_metrics(RTGUI_WIDGET_FONT(win), "AppMgr", &rect);
font_size = rtgui_rect_height(rect);
/* create notebook */
rtgui_widget_get_extent(RTGUI_WIDGET(win), &rect);
notebook = rtgui_notebook_create(&rect, RTGUI_NOTEBOOK_LEFT);
RTGUI_WIDGET_BACKGROUND(notebook) = RTGUI_RGB(241, 241, 241);
rtgui_notebook_set_tab_height(notebook, pressed_image->h + font_size + 3 * RTGUI_WIDGET_DEFAULT_MARGIN);
rtgui_notebook_set_tab_width(notebook, 65);
angle_y = rect.x1;
/* create navigation */
rtgui_notebook_get_client_rect(notebook, &rect);
block = block_panel_create(angle_y + notebook->tab_h/2, &rect);
RTGUI_WIDGET_BACKGROUND(block) = RTGUI_RGB(241, 241, 241);
rtgui_notebook_add_image(notebook, "AppTask", RTGUI_WIDGET(block),
pressed_image, unpressed_image);
apps_list_create(RTGUI_PANEL(block));
angle_y += notebook->tab_h;
block = block_panel_create(angle_y + notebook->tab_h/2, &rect);
RTGUI_WIDGET_BACKGROUND(block) = RTGUI_RGB(241, 241, 241);
rtgui_notebook_add_image(notebook, "Tab 1", RTGUI_WIDGET(block),
pressed_image, unpressed_image);
{
struct rtgui_rect box_rect;
block_panel_get_client_extent(block, &box_rect);
// rtgui_widget_get_extent(RTGUI_WIDGET(block), &box_rect);
// rtgui_rect_inflate(&box_rect, -15);
box = rtgui_listbox_create(items, sizeof(items)/sizeof(struct rtgui_listbox_item), &box_rect);
rtgui_container_add_child(RTGUI_CONTAINER(block), RTGUI_WIDGET(box));
}
angle_y += notebook->tab_h;
block = block_panel_create(angle_y + notebook->tab_h/2, &rect);
RTGUI_WIDGET_BACKGROUND(block) = RTGUI_RGB(241, 241, 241);
rtgui_notebook_add_image(notebook, "Tab 2", RTGUI_WIDGET(block),
pressed_image, unpressed_image);
angle_y += notebook->tab_h;
rtgui_container_add_child(RTGUI_CONTAINER(win), RTGUI_WIDGET(notebook));
rtgui_win_show(win, RT_FALSE);
/* set as main window */
rtgui_app_set_main_win(win);
}
*/
#include <rtgui/rtgui.h>
#include <rtgui/image.h>
#include <rtgui/font.h>
#include <rtgui/event.h>
#include <rtgui/rtgui_app.h>
#include <rtgui/rtgui_server.h>
#include <rtgui/rtgui_system.h>
#include <rtgui/widgets/window.h>
#ifdef _WIN32_NATIVE
#define RTGUI_MEM_TRACE
#endif
const rtgui_color_t default_foreground = RTGUI_RGB(0x00, 0x00, 0x00);
const rtgui_color_t default_background = RTGUI_RGB(212, 208, 200);
extern struct rtgui_font rtgui_font_asc16;
extern struct rtgui_font rtgui_font_asc12;
static rtgui_rect_t _mainwin_rect;
static struct rt_mutex _screen_lock;
int rtgui_system_server_init(void)
{
rt_mutex_init(&_screen_lock, "screen", RT_IPC_FLAG_FIFO);
/* init image */
rtgui_system_image_init();
/* init font */
/*
* container的事件处理函数
*/
rt_bool_t instrument_panel_event_handler(struct rtgui_object *object, rtgui_event_t *event)
{
struct rtgui_widget *widget = RTGUI_WIDGET(object);
char ac[4];
int i;
int x0 = 120;
int y0 = 170;
int x, y;
int default_color;
/* 仅对PAINT事件进行处理 */
if (event->type == RTGUI_EVENT_PAINT)
{
struct rtgui_dc *dc;
rtgui_rect_t rect;
const int arrowx[] = {120 + 75, 120 + 75, 120 + 85};
const int arrowy[] = {170 - 5, 170 + 5, 170};
/*
* 因为用的是demo container，上面本身有一部分控件，所以在绘图时先要让demo container
* 先绘图
*/
rtgui_container_event_handler(RTGUI_OBJECT(widget), event);
/************************************************************************/
/* 下面的是DC的操作 */
/************************************************************************/
/* 获得控件所属的DC */
dc = rtgui_dc_begin_drawing(widget);
/* 如果不能正常获得DC，返回（如果控件或父控件是隐藏状态，DC是获取不成功的） */
if (dc == RT_NULL)
return RT_FALSE;
/* 获得demo container允许绘图的区域 */
demo_view_get_rect(RTGUI_CONTAINER(widget), &rect);
RTGUI_DC_TEXTALIGN(dc) = RTGUI_ALIGN_BOTTOM | RTGUI_ALIGN_CENTER_HORIZONTAL;
/* 显示GUI的版本信息 */
#ifdef RTGUI_USING_SMALL_SIZE
rtgui_dc_draw_text(dc, "RT-Thread/GUI小型版本", &rect);
#else
rtgui_dc_draw_text(dc, "RT-Thread/GUI标准版本", &rect);
#endif
RTGUI_DC_TEXTALIGN(dc) = RTGUI_ALIGN_CENTER_VERTICAL | RTGUI_ALIGN_CENTER_HORIZONTAL;
RTGUI_DC_FC(dc) = blue;
rect.y2 = 270;
rtgui_dc_draw_text(dc, "rtgui-panel", &rect);
for (i = 0; i < 6; i++)
{
rtgui_dc_draw_arc(dc, x0, y0, 117 - i, 150, 30);
}
RTGUI_DC_FC(dc) = black;
RTGUI_DC_TEXTALIGN(dc) = RTGUI_ALIGN_LEFT;
for (i = 0; i <= 23; i++)
{
if (i < 12)
{
x = x0 + 105 * cos((150 + i * 10) * 3.1415926 / 180);
y = y0 + 105 * sin((150 + i * 10) * 3.1415926 / 180);
rect.x1 = x;
rect.y1 = y;
rect.x2 = rect.x1 + 12 * 3;
rect.y2 = rect.y1 + 12;
rt_sprintf(ac, "%d", 10 * i);
rtgui_dc_draw_text(dc, ac, &rect);
}
else
{
RTGUI_DC_TEXTALIGN(dc) = RTGUI_ALIGN_RIGHT;
x = x0 + 105 * cos((160 + i * 10) * 3.1415926 / 180);
y = y0 + 105 * sin((160 + i * 10) * 3.1415926 / 180);
rect.x1 = x - 12 * 3;
rect.y1 = y;
rect.x2 = rect.x1 + 12 * 3;
rect.y2 = rect.y1 + 12;
rt_sprintf(ac, "%d", 10 * i);
rtgui_dc_draw_text(dc, ac, &rect);
}
x = x0 + 107 * cos((150 + i * 10) * 3.1415926 / 180);
y = y0 + 107 * sin((150 + i * 10) * 3.1415926 / 180);
rtgui_dc_fill_circle(dc, x, y, 3);
}
RTGUI_DC_FC(dc) = RTGUI_RGB(166, 0, 166);
rtgui_dc_fill_circle(dc, x0, y0, 3);
RTGUI_DC_FC(dc) = RTGUI_RGB(120, 141, 30);
rtgui_dc_draw_circle(dc, x0, y0, 5);
default_color = RTGUI_DC_BC(dc);
RTGUI_DC_BC(dc) = red;
rect.x1 = x0 + 7;
rect.y1 = y0 - 1;
rect.x2 = x0 + 75;
rect.y2 = y0 + 1;
rtgui_dc_fill_rect(dc, &rect);
RTGUI_DC_BC(dc) = default_color;
rtgui_dc_fill_polygon(dc, arrowx, arrowy, 3);
/* 绘图完成 */
rtgui_dc_end_drawing(dc);
}
else
{
/* 其他事件，调用默认的事件处理函数 */
return rtgui_container_event_handler(RTGUI_OBJECT(widget), event);
}
return RT_FALSE;
}
#include <rtgui/rtgui.h>
#include <rtgui/dc.h>
#include <rtgui/widgets/widget.h>
#include <rtgui/widgets/button.h>
#include <rtgui/widgets/label.h>
#include <rtgui/widgets/textbox.h>
#include <rtgui/widgets/iconbox.h>
#include <rtgui/widgets/title.h>
#include <rtgui/rtgui_theme.h>
#include <rtgui/rtgui_server.h>
#include <rtgui/rtgui_system.h>
#define SELECTED_HEIGHT 25
const rtgui_color_t default_foreground = RTGUI_RGB(0x00, 0x00, 0x00);
const rtgui_color_t default_background = RTGUI_RGB(212, 208, 200);
const rtgui_color_t selected_color = RTGUI_RGB(0xc0, 0xc0, 0xc0);
const rtgui_color_t disable_foreground = RTGUI_RGB(0x80, 0x80, 0x80);
extern struct rtgui_font rtgui_font_asc16;
extern struct rtgui_font rtgui_font_arial16;
extern struct rtgui_font rtgui_font_asc12;
extern struct rtgui_font rtgui_font_arial12;
/* init theme */
void rtgui_system_theme_init()
{
#if RTGUI_DEFAULT_FONT_SIZE == 16
rtgui_font_set_defaut(&rtgui_font_asc16);
#elif RTGUI_DEFAULT_FONT_SIZE == 12
static rt_bool_t rtgui_image_png_process(png_structp png_ptr, png_infop info_ptr, struct rtgui_image_png *png)
{
rt_uint32_t x, y;
png_bytep row;
png_bytep data;
rtgui_color_t *ptr;
row = (png_bytep) rtgui_malloc(png_get_rowbytes(png_ptr, info_ptr));
if (row == RT_NULL) return RT_FALSE;
ptr = (rtgui_color_t *)png->pixels;
switch (info_ptr->color_type)
{
case PNG_COLOR_TYPE_RGB:
for (y = 0; y < info_ptr->height; y++)
{
png_read_row(png_ptr, row, png_bytep_NULL);
for (x = 0; x < info_ptr->width; x++)
{
data = &(row[x * 3]);
ptr[x + y * info_ptr->width] = RTGUI_RGB(data[0], data[1], data[2]);
}
}
break;
case PNG_COLOR_TYPE_RGBA:
for (y = 0; y < info_ptr->height; y++)
{
png_read_row(png_ptr, row, png_bytep_NULL);
for (x = 0; x < info_ptr->width; x++)
{
data = &(row[x * 4]);
ptr[x + y * info_ptr->width] = RTGUI_ARGB(data[3], data[0], data[1], data[2]);
}
}
break;
case PNG_COLOR_TYPE_PALETTE:
for (y = 0; y < info_ptr->height; y++)
{
png_read_row(png_ptr, row, png_bytep_NULL);
for (x = 0; x < info_ptr->width; x++)
{
data = &(row[x]);
ptr[x] = RTGUI_ARGB(0, info_ptr->palette[data[0]].red,
info_ptr->palette[data[0]].green,
info_ptr->palette[data[0]].blue);
}
}
default:
break;
};
rtgui_free(row);
return RT_TRUE;
}
static void player_update_tag_info()
{
char line[32];
struct rtgui_dc* dc;
rtgui_color_t bc, fc;
rtgui_rect_t rect;
rtgui_image_t *button;
/* get dc */
dc = rtgui_dc_begin_drawing(RTGUI_WIDGET(home_view));
if (dc == RT_NULL) return;
/* save old foreground and background color */
fc = RTGUI_DC_FC(dc);
bc = RTGUI_DC_BC(dc);
/* draw playing information */
rect.x1 = 25;
rect.y1 = 20;
rect.x2 = 220;
rect.y2 = rect.y1 + 16;
RTGUI_DC_BC(dc) = RTGUI_RGB(0, 134, 206);
rtgui_dc_fill_rect(dc, &rect);
RTGUI_DC_FC(dc) = black;
if (player_mode == PLAYER_STOP)
{
rt_snprintf(line, sizeof(line), "网络收音机");
rtgui_dc_draw_text(dc, line, &rect);
}
else
rtgui_dc_draw_text(dc, tinfo.title, &rect);
/* reset progress bar */
#if 0
if (tinfo.position != 0)
{
rt_snprintf(line, sizeof(line), "%3d:%02d", item->duration / 60, item->duration % 60);
}
else
#endif
{
RTGUI_DC_FC(dc) = RTGUI_RGB(82, 199, 16);
rtgui_dc_draw_hline(dc, 14, 226, 75);
}
rect.x1 = 25;
rect.y1 = 48;
rect.x2 = 220;
rect.y2 = rect.y1 + 16;
RTGUI_DC_BC(dc) = RTGUI_RGB(0, 125, 198);
rtgui_dc_fill_rect(dc, &rect);
RTGUI_DC_FC(dc) = black;
if (player_mode == PLAYER_STOP)
{
rt_snprintf(line, sizeof(line), "radio.rt-thread.org");
rtgui_dc_draw_text(dc, line, &rect);
}
else
{
rtgui_dc_draw_text(dc, tinfo.artist, &rect);
}
if ((tinfo.duration != 0) && player_mode == PLAYER_PLAY_FILE)
{
play_time = 0;
rect.x1 = 172;
rt_snprintf(line, sizeof(line), " 0:00");
rtgui_dc_draw_text(dc, line, &rect);
}
/* update playing button */
if (player_mode == PLAYER_STOP)
button = (rtgui_image_t*)&stop_image;
else
button = (rtgui_image_t*)&play_image;
rect.x1 = 32;
rect.y1 = 92;
rect.x2 = 61;
rect.y2 = 114;
rtgui_image_blit(button, dc, &rect);
RTGUI_DC_FC(dc) = fc;
RTGUI_DC_BC(dc) = bc;
rtgui_dc_end_drawing(dc);
}
