static void render(struct widget *w)
{
struct widget_priv *priv = (struct widget_priv*) w->priv;
struct canvas *ca = &w->ca;
unsigned char i;
unsigned int width = ca->width;
int x;
char buf[10];
for (i = 0; i < 8; i++) {
if ((w->cfg->props.mode == 0) || (w->cfg->props.mode == 1))
sprintf(buf, "CH%u %4d", i+1, priv->ch_raw[i]);
else
sprintf(buf, "CH%u", i+1);
draw_str(buf, 0, i*8+1, ca, 0);
if ((w->cfg->props.mode == 0) || (w->cfg->props.mode == 2)) {
x = priv->ch_raw[i] - 1000;
if (x < 0)
x = 0;
else if (x > 1000)
x = 1000;
x = (x * (unsigned int) priv->bar_size) / 1000;
draw_rect(width-priv->bar_size-1, i*8, width-1, i*8+6, 3, ca);
draw_rect(width-priv->bar_size, i*8+1, width-2, i*8+5, 1, ca);
draw_vline(width-priv->bar_size-1+x, i*8+1, i*8+5, 1, ca);
draw_vline(width-priv->bar_size-1+x-1, i*8+1, i*8+5, 3, ca);
draw_vline(width-priv->bar_size-1+x+1, i*8+1, i*8+5, 3, ca);
}
}
}
void draw_rect(Image* image, int x1, int y1, int x2, int y2, color_t color)
{
int t;
if (x1 > x2) {
t = x1;
x1 = x2;
x2 = t;
}
if (y1 > y2) {
t = y1;
y1 = y2;
y2 = t;
}
if ((x2 < 0) || (x1 >= image->width()) || (y2 < 0) || (y1 >= image->height()))
return;
draw_hline(image, x1, y1, x2, color);
draw_hline(image, x1, y2, x2, color);
if (y2-y1 > 1) {
draw_vline(image, x1, y1+1, y2-1, color);
draw_vline(image, x2, y1+1, y2-1, color);
}
}
void drawbox(int x1, int y1, int x2, int y2)
{
cputcharxy(x1, y1, '+');
draw_hline(x1, y1+1, y2-1, '-');
cputcharxy(x1, y2, '+');
draw_vline(x1+1, y2, x2-1, '|');
cputcharxy(x2, y2, '+');
draw_hline(x2, y1+1, y2-1, '-');
cputcharxy(x2, y1, '+');
draw_vline(x1+1, y1, x2-1, '|');
gotoxy(x1, y1);
}
void generic_draw_rect(u32 x, u32 y, u32 width, u32 height, pixel_t pixel)
{
draw_hline(x, y, width, pixel);
if (height >= 1) {
if (height >= 2) {
draw_vline(x, y+1, height-2, pixel);
if (width >= 1)
draw_vline(x+width-1, y+1, height-2, pixel);
}
draw_hline(x, y+height-1, width, pixel);
}
}
static void
draw_pixel_rect(DiaRenderer *self,
int x, int y,
int width, int height,
Color *color)
{
DiaLibartRenderer *renderer = DIA_LIBART_RENDERER (self);
guint8 r,g,b;
int start, len;
int stride;
r = color->red*0xff;
g = color->green*0xff;
b = color->blue*0xff;
stride = renderer->pixel_width*3;
/* clip in x */
start = x;
len = width;
CLIP_1D_LEN(renderer->clip_rect.left, renderer->clip_rect.right, start, len);
/* top line */
if ( (y>=renderer->clip_rect.top) &&
(y<=renderer->clip_rect.bottom) ) {
draw_hline(self, start, y, len, r, g, b);
}
/* bottom line */
if ( (y+height>=renderer->clip_rect.top) &&
(y+height<=renderer->clip_rect.bottom) ) {
draw_hline(self, start, y+height, len, r, g, b);
}
/* clip in y */
start = y;
len = height;
CLIP_1D_LEN(renderer->clip_rect.top, renderer->clip_rect.bottom, start, len);
/* left line */
if ( (x>=renderer->clip_rect.left) &&
(x<renderer->clip_rect.right) ) {
draw_vline(self, x, start, len, r, g, b);
}
/* right line */
if ( (x+width>=renderer->clip_rect.left) &&
(x+width<renderer->clip_rect.right) ) {
draw_vline(self, x+width, start, len, r, g, b);
}
}
void
draw_rubberbox(GtkWidget *drawing_area, GdkRect rect)
{
GdkRect c;
GdkRect oc;
GdkRect update_rect;
c = rect;
oc = old_rect;
if ((c.x > skin_infos.width) || (c.y > skin_infos.height) ||
((c.x + c.w) > skin_infos.width) || ((c.y + c.h) > skin_infos.height))
return;
g_object_unref(pixbuf);
pixbuf = gdk_pixbuf_copy(skin_infos.img_orig);
draw_hline(c.x, c.y, c.w);
draw_hline(c.x, c.y + c.h, c.w);
draw_vline(c.x, c.y, c.h);
draw_vline(c.x + c.w, c.y, c.h);
/*
* 2 calls to SDL_UpdateRect :
* + erase the old rect
* + draw the new one
*
* We could composite a new rectangle with the new and old ones,
* but this would consume more resources than these 2 calls.
* Plus it would complicate the code. *sigh*
*/
update_rect.x = oc.x;
update_rect.y = oc.y;
update_rect.w = ((oc.w + oc.x + 1) <= skin_infos.width) ? (oc.w + 1) : oc.w; /* add 2 to really erase the lines (right, bottom) ... */
update_rect.h = ((oc.h + oc.y + 1) <= skin_infos.height) ? (oc.h + 1) : oc.h; /* ... but be careful */
gtk_widget_draw (drawing_area, (GdkRectangle *)(&update_rect));
update_rect.x = c.x;
update_rect.y = c.y;
update_rect.w = ((c.w + c.x + 1) <= skin_infos.width) ? (c.w + 1) : c.w; /* add 2 to really erase the lines (right, bottom) ... */
update_rect.h = ((c.h + c.y + 1) <= skin_infos.height) ? (c.h + 1) : c.h; /* ... but be careful */
gtk_widget_draw (drawing_area, (GdkRectangle *)&update_rect);
tmp_rect = rect; /* when called from callbacks.c (for LCD or keys) */
old_rect = rect; /* save coords */
}
//-------------------------------------------------------------------
// Generic rectangle
// 'flags' defines type - filled, round corners, shadow and border thickness
void draw_rectangle(coord x1, coord y1, coord x2, coord y2, twoColors cl, int flags)
{
// Normalise values
if (x1 > x2)
swap(x1, x2);
if (y1 > y2)
swap(y1, y2);
// Check if completely off screen
if ((x2 < 0) || (y2 < 0) || (x1 >= camera_screen.width) || (y1 >= camera_screen.height))
return;
int round = (flags & RECT_ROUND_CORNERS) ? 1 : 0;
int thickness;
int i;
// Shadow (do this first, as edge draw shrinks rectangle for fill)
if (flags & RECT_SHADOW_MASK)
{
thickness = ((flags & RECT_SHADOW_MASK) >> 4);
for (i=1; i<=thickness; i++)
{
draw_vline(x2+i, y1+1, y2 - y1, COLOR_BLACK);
draw_hline(x1+1, y2+i, x2 - x1 + thickness, COLOR_BLACK);
}
}
static enum test_res test002_func(void)
{
int i;
u32 a, b, x1, x2, y1, y2;
fill_rect(0, 0, fb_var.xres, fb_var.yres, black_pixel);
for (i = 0; i <= Y_BLOCKS; i++)
draw_hline(0, i*(fb_var.yres-1)/Y_BLOCKS, fb_var.xres, white_pixel);
for (i = 0; i <= X_BLOCKS; i++)
draw_vline(i*(fb_var.xres-1)/X_BLOCKS, 0, fb_var.yres, white_pixel);
draw_ellipse(fb_var.xres/2, fb_var.yres/2, 3*fb_var.xres/8,
fb_var.yres/2-1, white_pixel);
a = (fb_var.xres-1)/X_BLOCKS;
b = (fb_var.yres-1)/Y_BLOCKS;
x1 = (fb_var.xres-1)/X_BLOCKS;
y1 = (fb_var.yres-1)/Y_BLOCKS;
x2 = (X_BLOCKS-1)*(fb_var.xres-1)/X_BLOCKS;
y2 = (Y_BLOCKS-1)*(fb_var.yres-1)/Y_BLOCKS;
draw_ellipse(x1, y1, a, b, white_pixel);
draw_ellipse(x2, y1, a, b, white_pixel);
draw_ellipse(x1, y2, a, b, white_pixel);
draw_ellipse(x2, y2, a, b, white_pixel);
wait_for_key(10);
return TEST_OK;
}
void generic_draw_line(u32 x1, u32 y1, u32 x2, u32 y2, pixel_t pixel)
{
int dx, dy, sx, sy, e;
dx = x2-x1;
dy = y2-y1;
if (dy == 0) {
if (dx < 0) {
dx = -dx;
x1 = x2;
}
draw_hline(x1, y1, dx+1, pixel);
} else if (dx == 0) {
if (dy < 0) {
dy = -dy;
y1 = y2;
}
draw_vline(x1, y1, dy+1, pixel);
} else {
if (dy < 0) {
dy = -dy;
sy = -1;
} else {
sy = 1;
}
if (dx < 0) {
dx = -dx;
sx = -1;
} else {
sx = 1;
}
if (dx > dy) {
e = -dx/2;
set_pixel(x1, y1, pixel);
while (x1 != x2) {
e += dy;
if (e >= 0) {
y1 += sy;
e -= dx;
}
x1 += sx;
set_pixel(x1, y1, pixel);
}
} else {
e = -dy/2;
set_pixel(x1, y1, pixel);
while (y1 != y2) {
e += dx;
if (e >= 0) {
x1 += sx;
e -= dy;
}
y1 += sy;
set_pixel(x1, y1, pixel);
}
}
}
}
void main(void)
{
fb_init(WIDTH, HEIGHT, DEPTH, FB_SINGLEBUFFER);
for( int y = 0; y < HEIGHT; y += 16 )
draw_hline(y, GL_WHITE);
for( int x = 0; x < WIDTH; x += 16 )
draw_vline(x, GL_WHITE);
}
void draw_ant(unsigned char x, unsigned char y, unsigned char m) {
draw_vline(x+3,y,7,3,m);
draw_pixel(x,y,3,m);
draw_pixel(x+1,y+1,3,m);
draw_pixel(x+2,y+2,3,m);
draw_pixel(x+6,y,3,m);
draw_pixel(x+5,y+1,3,m);
draw_pixel(x+4,y+2,3,m);
}
static void render(struct widget *w)
{
struct widget_priv *priv = (struct widget_priv*) w->priv;
struct canvas *ca = &w->ca;
char buf[20];
int i;
switch (w->cfg->props.mode) {
case 0:
default:
sprintf(buf, "%5.2fV\n%5.2fA", priv->bat_voltage, priv->bat_current);
draw_str(buf, 4, BAT_BAR_Y + BAT_BAR_H + 3, ca, 2);
draw_rect(BAT_BAR_X, BAT_BAR_Y, BAT_BAR_X + BAT_BAR_W, BAT_BAR_Y + BAT_BAR_H, 3, ca);
draw_rect(BAT_BAR_X+1, BAT_BAR_Y+1, BAT_BAR_X + BAT_BAR_W-1, BAT_BAR_Y + BAT_BAR_H-1, 1, ca);
draw_vline(BAT_BAR_X - 1, BAT_BAR_Y + 4, BAT_BAR_Y + BAT_BAR_H - 4, 1, ca);
draw_vline(BAT_BAR_X - 2, BAT_BAR_Y + 4, BAT_BAR_Y + BAT_BAR_H - 4, 1, ca);
draw_vline(BAT_BAR_X - 3, BAT_BAR_Y + 4, BAT_BAR_Y + BAT_BAR_H - 4, 3, ca);
for (i = 0; i < (priv->bat_remaining*BAT_BAR_W)/100 - 2; i++) {
draw_vline(BAT_BAR_X + 2 + i, BAT_BAR_Y + 2, BAT_BAR_Y + BAT_BAR_H - 2, 2, ca);
}
sprintf(buf, "%d", priv->bat_remaining);
draw_str(buf, BAT_BAR_X + BAT_BAR_W/2 - 6, BAT_BAR_Y + 3, ca, 0);
break;
case 1:
case 2:
sprintf(buf, "%5.2fV", priv->bat_voltage);
draw_str(buf, 0, 0, ca, 2);
break;
case 3:
sprintf(buf, "%5.2fV\n%5.2fV", priv->bat_voltage, priv->bat_voltage2);
draw_str(buf, 0, 0, ca, 2);
break;
}
}
static void render(struct widget *w)
{
struct widget_priv *priv = w->priv;
struct canvas *ca = &w->ca;
unsigned char i;
unsigned int width = ca->width;
int x, y;
char buf[10];
const struct font *f = get_font(0);
unsigned int *ch = priv->ch;
for (i = 0; i < priv->total_ch; i++) {
if ((w->cfg->props.mode == 0) || (w->cfg->props.mode == 1))
sprintf(buf, "CH%u %4d", i+1, *ch);
else
sprintf(buf, "CH%u", i+1);
draw_str(buf, 0, i*f->size, ca, 0);
if ((w->cfg->props.mode == 0) || (w->cfg->props.mode == 2)) {
x = *ch - 1000;
if (x < 0)
x = 0;
else if (x > 1000)
x = 1000;
x = (x * (unsigned int) priv->bar_size) / 1000;
y = i * f->size;
draw_rect(width-priv->bar_size-1, y, width-1, y+BAR_SIZE, 3, ca);
draw_rect(width-priv->bar_size, y+1, width-2, y+BAR_SIZE-1, 1, ca);
draw_vline(width-priv->bar_size-1+x, y+1, y+BAR_SIZE-1, 1, ca);
draw_vline(width-priv->bar_size-1+x-1, y+1, y+BAR_SIZE-1, 3, ca);
draw_vline(width-priv->bar_size-1+x+1, y+1, y+BAR_SIZE-1, 3, ca);
}
ch++;
}
}
void draw_line(FBDev *dev, int x1, int y1, int x2, int y2, uint32_t pixel) {
int i, dx, dy, sdx, sdy, dxabs, dyabs, x, y, px, py;
// Handle simple cases first
if (x1 == x2) {
draw_vline(dev, x1, y1, y2, pixel);
} else if (y1 == y2) {
draw_hline(dev, x1, x2, y1, pixel);
}
dx = x2 - x1; // Delta x
dy = y2 - y1; // Delta y
dxabs = abs(dx); // Absolute delta
dyabs = abs(dy); // Absolute delta
sdx = (dx > 0) ? 1 : -1; // signum function
sdy = (dy > 0) ? 1 : -1; // signum function
x = dyabs >> 1;
y = dxabs >> 1;
px = x1;
py = y1;
if (dxabs >= dyabs) {
// Draw along x
for (i = 0; i < dxabs; i++) {
y += dyabs;
if (y >= dxabs) {
y -= dxabs;
py += sdy;
}
px += sdx;
fb_draw(dev, px, py, pixel);
}
} else {
// Draw along y
for (i = 0; i < dyabs; i++) {
x += dxabs;
if (x >= dyabs) {
x -= dyabs;
px += sdx;
}
py += sdy;
fb_draw(dev, px, py, pixel);
}
}
}
static void render(struct widget *w)
{
struct widget_priv *priv = w->priv;
struct canvas *ca = &w->ca;
int i, j, y = -1;
long yy;
char buf[10], d = 0;
int major_tick = priv->range / 5;
int minor_tick = major_tick / 4;
for (i = 0; i < priv->range; i++) {
yy = ((long) i * Y_SIZE) / priv->range;
if ((yy == y) && (d == 1))
continue;
y = Y_SIZE - (int) yy;
j = priv->altitude + i - priv->range/2;
if (j % major_tick == 0) {
draw_ohline(X_CENTER + 2, X_CENTER - 4, y, 1, 3, ca);
sprintf(buf, "%d", j);
draw_jstr(buf, X_SIZE-2, y, JUST_RIGHT | JUST_VCENTER, ca, 0);
d = 1;
} else if (j % minor_tick == 0) {
draw_ohline(X_CENTER + 2, X_CENTER - 2, y, 1, 3, ca);
d = 1;
} else {
d = 0;
}
}
draw_frect(X_CENTER + 11, Y_CENTER-5, X_SIZE-2, Y_CENTER + 5, 0, ca);
draw_hline(X_CENTER + 10, X_SIZE - 1, Y_CENTER-6, 1, ca);
draw_hline(X_CENTER + 10, X_SIZE - 1, Y_CENTER+6, 1, ca);
draw_vline(X_SIZE - 1, Y_CENTER-5, Y_CENTER+5, 1, ca);
/* draw arrow */
draw_line(X_CENTER+10, Y_CENTER-6, X_CENTER+10-5, Y_CENTER, 1, ca);
draw_line(X_CENTER+10, Y_CENTER+6, X_CENTER+10-5, Y_CENTER, 1, ca);
sprintf(buf, "%d", (unsigned int) priv->altitude);
draw_jstr(buf, X_SIZE-2, Y_CENTER, JUST_RIGHT | JUST_VCENTER, ca, 0);
}
static void render(struct widget *w)
{
struct widget_priv *priv = (struct widget_priv*) w->priv;
struct canvas *ca = &w->ca;
int i, j, y = -1;
long yy;
char buf[10], d = 0;
int major_tick = priv->range / 5;
int minor_tick = major_tick / 4;
for (i = 0; i < priv->range; i++) {
yy = ((long) i * Y_SIZE) / priv->range;
if ((yy == y) && (d == 1))
continue;
y = Y_SIZE - (int) yy;
j = priv->speed_i + i - priv->range/2;
if(j < 0)
continue;
if (j % major_tick == 0) {
sprintf(buf, "%3d", j);
draw_str(buf, 2, y - 2, ca, 0);
draw_ohline(X_CENTER - 2, X_CENTER + 4, y, 1, 3, ca);
d = 1;
} else if (j % minor_tick == 0) {
draw_ohline(X_CENTER - 2, X_CENTER + 2, y, 1, 3, ca);
d = 1;
} else {
d = 0;
}
}
draw_frect(1, Y_CENTER-4, X_CENTER - 10, Y_CENTER + 4, 0, ca);
sprintf(buf, "%3d", (int) priv->speed_i);
draw_str(buf, 2, Y_CENTER - 3, ca, 0);
draw_hline(0, X_CENTER - 10, Y_CENTER - 5, 1, ca);
draw_hline(0, X_CENTER - 10, Y_CENTER + 5, 1, ca);
draw_vline(0, Y_CENTER - 3 , Y_CENTER + 3, 1, ca);
draw_line(X_CENTER-10, Y_CENTER-5, X_CENTER-10+5, Y_CENTER, 1, ca);
draw_line(X_CENTER-10, Y_CENTER+5, X_CENTER-10+5, Y_CENTER, 1, ca);
}
void draw_b(unsigned char x, unsigned char y)
{
unsigned char w;
if(!(is_drawing))
{
if(bat_state & BAT_DEBUG)
{
draw_block(4,0,108,24,3,DRAW_ERASE);
draw_numU(4,0,bat_min>>2,0,3,DRAW_PUT);
draw_numU(32,0,bat_max>>2,0,3,DRAW_PUT);
draw_numU(4,8,(bat_max>>2)-(bat_min>>2),0,3,DRAW_PUT);
draw_numU(60,0,bat_min,0,3,DRAW_PUT);
draw_numU(88,0,bat_max,0,3,DRAW_PUT);
draw_numU(60,8,bat_max-bat_min,0,3,DRAW_PUT);
if((bat_state & BAT_NORMAL))
draw_string(4,16,"Bat.Operation",3,DRAW_PUT);
if((bat_state & BAT_CHARGE))
draw_string(4,16,"Charging",3,DRAW_PUT);
if((bat_state & BAT_CHARGE_DONE))
draw_string(4,16,"Done Charging",3,DRAW_PUT);
}
if (bat_min<0x320)
w = 0;
else if (bat_min>0x380)
w = 12;
else
w = (bat_min-0x320)/8;
draw_block(x+1,y+1,12,5,3,DRAW_ERASE);
draw_rect(x,y,14,7,1,3,DRAW_PUT);
draw_vline(x+14,y+2,3,3,DRAW_PUT);
if(w>0)
draw_block(x+1,y+1,w,5,2,DRAW_PUT);
if(w<12)
draw_block(x+1+w,y+1,12-w,5,0,DRAW_PUT);
}
static void drawpanel_1p()
{
int h24 = _HEIGHT_24L;
int clr = (player1.level % 6)+1;
int i;
setwcurs(WIN_PANEL, 0, 0);
setblockcolor(clr);
printstr_acs("lqNu", 8);
for (i = 0; i <= 8; i += 4)
drawstr("\\xhNx\\3tqNu", 8, 0, i);
if (h24) {
setcurs(0, 12);
putch(LOWLEFT);
drawpanel_labels("Score", 1);
} else {
setcurs(0, 13);
printstr_acs("xhNx", 8);
drawpanel_labels("Score", 1);
setcurs(2, 13);
printstr(" Next ");
}
printstat_1p();
drawpanel_bordercolor(clr);
if (h24)
drawstr("\\x\\6x", 6, 9, 12);
else {
drawstr("\\x Nx\\3mqNu", 8, 0, 13);
drawstr("\\x\\x", 0, 9, 17);
}
i = 0;
if (h24)
i = 4;
setwcurs(0, 0, i);
drawpanel_bordercolor(clr);
draw_vline(board_x(1, 10)+1, i, 20);
}
inline void draw_vline_b(T& os, pos_t x, pos_t y, pos_t len, char const* c = "┃")
{
draw_vline(os, x, y, len, c);
}
static void
draw_pixel_line(DiaRenderer *self,
int x1, int y1,
int x2, int y2,
Color *color)
{
DiaLibartRenderer *renderer = DIA_LIBART_RENDERER (self);
guint8 r,g,b;
guint8 *ptr;
int start, len;
int stride;
int i;
int x, y;
int dx, dy, adx, ady;
int incx, incy;
int incx_ptr, incy_ptr;
int frac_pos;
IntRectangle *clip_rect;
r = color->red*0xff;
g = color->green*0xff;
b = color->blue*0xff;
if (y1==y2) { /* Horizontal line */
start = x1;
len = x2-x1;
CLIP_1D_LEN(renderer->clip_rect.left, renderer->clip_rect.right, start, len);
/* top line */
if ( (y1>=renderer->clip_rect.top) &&
(y1<=renderer->clip_rect.bottom) ) {
draw_hline(self, start, y1, len, r, g, b);
}
return;
}
if (x1==x2) { /* Vertical line */
start = y1;
len = y2-y1;
CLIP_1D_LEN(renderer->clip_rect.top, renderer->clip_rect.bottom, start, len);
/* left line */
if ( (x1>=renderer->clip_rect.left) &&
(x1<=renderer->clip_rect.right) ) {
draw_vline(self, x1, start, len, r, g, b);
}
return;
}
/* Ugh, kill me slowly for writing this line-drawer.
* It is actually a standard bresenham, but not very optimized.
* It is also not very well tested.
*/
stride = renderer->pixel_width*3;
clip_rect = &renderer->clip_rect;
dx = x2-x1;
dy = y2-y1;
adx = (dx>=0)?dx:-dx;
ady = (dy>=0)?dy:-dy;
x = x1; y = y1;
ptr = renderer->rgb_buffer + x*3 + y*stride;
if (adx>=ady) { /* x-major */
if (dx>0) {
incx = 1;
incx_ptr = 3;
} else {
incx = -1;
incx_ptr = -3;
}
if (dy>0) {
incy = 1;
incy_ptr = stride;
} else {
incy = -1;
incy_ptr = -stride;
}
frac_pos = adx;
for (i=0;i<=adx;i++) {
/* Amazing... He does the clipping in the inner loop!
It must be horribly inefficient! */
if ( (x>=clip_rect->left) &&
(x<=clip_rect->right) &&
(y>=clip_rect->top) &&
(y<=clip_rect->bottom) ) {
ptr[0] = r;
ptr[1] = g;
ptr[2] = b;
}
x += incx;
ptr += incx_ptr;
frac_pos += ady*2;
if ((frac_pos > 2*adx) || ((dy>0)&&(frac_pos == 2*adx))) {
y += incy;
ptr += incy_ptr;
frac_pos -= 2*adx;
}
}
} else { /* y-major */
if (dx>0) {
incx = 1;
incx_ptr = 3;
} else {
incx = -1;
incx_ptr = -3;
}
if (dy>0) {
incy = 1;
incy_ptr = stride;
} else {
incy = -1;
incy_ptr = -stride;
}
frac_pos = ady;
for (i=0;i<=ady;i++) {
/* Amazing... He does the clipping in the inner loop!
It must be horribly inefficient! */
if ( (x>=clip_rect->left) &&
(x<=clip_rect->right) &&
(y>=clip_rect->top) &&
(y<=clip_rect->bottom) ) {
ptr[0] = r;
ptr[1] = g;
ptr[2] = b;
}
y += incy;
ptr += incy_ptr;
frac_pos += adx*2;
if ((frac_pos > 2*ady) || ((dx>0)&&(frac_pos == 2*ady))) {
x += incx;
ptr += incx_ptr;
frac_pos -= 2*ady;
}
}
}
}
int main(void)
{
tga_init(128,64);
ucg_Init(&ucg, &ucg_dev_tga, ucg_ext_none, (ucg_com_fnptr)0);
ucg_SetFontMode(&ucg, UCG_FONT_MODE_TRANSPARENT);
ucg_SetColor(&ucg, 0, 0, 0, 0);
ucg_DrawBox(&ucg, 0, 0, 128, 64);
ucg_SetFont(&ucg, ucg_font_ncenB18_tf);
ucg_SetColor(&ucg, 0, 0, 0, 255);
ucg_DrawPixel(&ucg, 70,20);
ucg_SetColor(&ucg, 0, 255, 0, 0);
//ucg_SetFontPosBottom(&ucg);
/*
ucg_DrawGlyph(&ucg, 70, 20, 0, 'A');
ucg_DrawGlyph(&ucg, 70, 20, 1, 'A');
ucg_DrawGlyph(&ucg, 70, 20, 2, 'A');
ucg_DrawGlyph(&ucg, 70, 20, 3, 'A');
ucg_SetColor(&ucg, 0, 255, 255, 255);
vrule(&ucg, 30, 0, 20, 1);
vrule(&ucg, 30, 0, 20, 0);
*/
//pos(&ucg, 70, 20, 0);
//hrule(&ucg, 0, 20, 70, 1);
//hrule(&ucg, 0, 20, 70, 0);
ucg_SetColor(&ucg, 0, 255, 0, 0);
ucg_SetColor(&ucg, 1, 0, 255, 0);
ucg_SetColor(&ucg, 2, 255, 0, 255);
ucg_SetColor(&ucg, 3, 0, 255, 255);
ucg_DrawGradientLine(&ucg, 10, 40, 100, 0);
ucg_DrawGradientBox(&ucg, 10, 43, 100, 20);
tga_save("test.tga");
draw_pixel(&ucg);
draw_hline(&ucg);
draw_vline(&ucg);
set_clip_range(&ucg);
draw_text_baseline(&ucg);
draw_text_bottom(&ucg);
draw_text_top(&ucg);
draw_text_center(&ucg);
draw_text_ascent_descent(&ucg);
draw_text_dir1(&ucg);
draw_box(&ucg);
draw_frame(&ucg);
draw_rbox(&ucg);
draw_rframe(&ucg);
draw_gradient_box(&ucg);
draw_gradient_line(&ucg);
draw_disc(&ucg);
draw_circle(&ucg);
draw_triangle(&ucg);
set_scale2x2(&ucg);
set_font_mode_1(&ucg);
set_font_mode_2(&ucg);
solid_font_variants(&ucg);
string_overwrite(&ucg, 1);
string_overwrite(&ucg, 5);
string_overwrite(&ucg, 10);
return 0;
}
void draw_rect(FBDev *dev, int x, int y, int w, int h, uint32_t pixel) {
draw_hline(dev, x, x+w, y, pixel);
draw_hline(dev, x, x+w, y+h, pixel);
draw_vline(dev, x, y, y+h, pixel);
draw_vline(dev, x+w, y, y+h, pixel);
}
static void render(struct widget *w)
{
struct widget_priv *priv = w->priv;
struct canvas *ca = &w->ca;
char buf[10];
unsigned long d = (unsigned long) priv->home->distance;
unsigned int r = (w->ca.width/2)-2;
int x, y;
int min_increment;
long i, scale;
struct point ils_points[5] = { {-4, -6}, {-4, 6}, {0, 10}, {4, 6}, {4, -6} };
struct polygon ils = {
.len = 5,
.points = ils_points,
};
struct point uav_points[4] = { {0, 0}, {6, 8}, {0, -8}, {-6, 8} };
struct polygon uav = {
.len = 4,
.points = uav_points,
};
struct polygon *p;
x = (w->ca.width/2)-1;
y = (w->ca.height/2)-1;
draw_vline(x, 0, r*2, 2, ca);
draw_hline(0, r*2, y, 2, ca);
//draw_circle(x, y, r+1, 3, ca);
draw_circle(x, y, r , 2, ca);
/* auto scale */
switch (get_units(w->cfg)) {
default:
case UNITS_METRIC:
min_increment = 500;
scale = ((d / min_increment) + 1) * min_increment;
sprintf(buf, "%um", (unsigned int) scale);
break;
case UNITS_IMPERIAL:
d *= M2FEET;
min_increment = 1000;
scale = ((d / min_increment) + 1) * min_increment;
if (d > 5000) {
d = (d * 1000) / MILE2FEET;
scale /= 1000;
sprintf(buf, "%umi", (unsigned int) scale);
} else {
sprintf(buf, "%uf", (unsigned int) scale);
}
break;
}
draw_str(buf, 0, 0, ca, 0);
i = (long) d * r;
i /= scale;
switch (w->cfg->props.mode >> 1) {
case 0:
default:
/* radar fixed at uav heading, home moves */
x += sin(DEG2RAD(priv->home->direction)) * i;
y -= cos(DEG2RAD(priv->home->direction)) * i;
transform_polygon(&ils, x, y, priv->stats->launch_heading - priv->heading - 180);
p = &ils;
break;
case 1:
/* radar always facing north, uav moves */
x += sin(DEG2RAD(priv->home->uav_bearing)) * i;
y -= cos(DEG2RAD(priv->home->uav_bearing)) * i;
transform_polygon(&uav, x, y, priv->heading);
p = &uav;
break;
case 2:
/* radar always facing launch direction, uav moves */
x += sin(DEG2RAD(priv->home->uav_bearing - priv->stats->launch_heading)) * i;
y -= cos(DEG2RAD(priv->home->uav_bearing - priv->stats->launch_heading)) * i;
transform_polygon(&uav, x, y, priv->heading - priv->stats->launch_heading);
p = &uav;
break;
case 3:
/* testing waypoints */
/* radar always facing north, uav moves with waypoints */
if (priv->wp_seq > 0) {
long i_wp = (long) priv->wp_distance * r;
i_wp /= scale;
int x_wp = x, y_wp = y;
x_wp += sin(DEG2RAD(priv->wp_target_bearing - priv->heading)) * i_wp;
y_wp -= cos(DEG2RAD(priv->wp_target_bearing - priv->heading)) * i_wp;
sprintf(buf, "%d", priv->wp_seq);
draw_str(buf, x_wp, y_wp, ca, 0);
}
x += sin(DEG2RAD(priv->home->uav_bearing)) * i;
y -= cos(DEG2RAD(priv->home->uav_bearing)) * i;
transform_polygon(&uav, x, y, priv->heading);
p = &uav;
break;
}
draw_polygon(p, 3, ca);
move_polygon(p, -1, -1);
draw_polygon(p, 1, ca);
}
const struct widget_ops radar_widget_ops = {
.name = "Radar",
.mavname = "RADAR",
.id = WIDGET_RADAR_ID,
.init = NULL,
.open = open,
.render = render,
.close = NULL,
};
static void render(struct widget *w)
{
struct widget_priv *priv = w->priv;
struct canvas *ca = &w->ca;
int y, i, j;
int x0, x1, y0, y1, offset, cx, cy;
unsigned char size, gap;
char buf[10];
for (i = -RANGE/2; i <= RANGE/2; i++) {
y = Y_CENTER - i;
//j = priv->pitch_deg*SCALE + i;
j = priv->pitch_deg + i;
if (j % (MINOR_TICK*SCALE) == 0) {
if (j == 0) {
size = 40;
gap = 10;
} else {
if (j % (MAJOR_TICK*SCALE) == 0)
size = 20;
else
size = 10;
gap = 10;
}
cx = X_CENTER + (int) (i * priv->sin_roll);
cy = y + i - (int) (i * priv->cos_roll);
if ((j != 0) && (j % (MAJOR_TICK*SCALE) == 0)) {
sprintf(buf, "%d", j / SCALE);
draw_jstr(buf, cx, cy, JUST_HCENTER | JUST_VCENTER, ca, 0);
}
offset = (int) gap * priv->cos_roll;
x0 = cx + offset;
offset = (int) size * priv->cos_roll;
x1 = x0 + offset;
offset = (int) gap * priv->sin_roll;
y0 = cy + offset;
offset = (int) size * priv->sin_roll;
y1 = y0 + offset;
if (j == 0) {
draw_line(x0-1, y0-1, x1+1, y1-1, 3, ca);
//draw_line(x0, y0-1, x1, y1-1, 1, ca);
}
draw_line(x0-1, y0+1, x1+1, y1+1, 3, ca);
draw_line(x0, y0, x1, y1, 1, ca);
offset = (int) gap * priv->cos_roll;
x0 = cx - offset;
offset = (int) size * priv->cos_roll;
x1 = x0 - offset;
offset = (int) gap * priv->sin_roll;
y0 = cy - offset;
offset = (int) size * priv->sin_roll;
y1 = y0 - offset;
if (j == 0) {
draw_line(x0-1, y0-1, x1+1, y1-1, 3, ca);
//draw_line(x0, y0-1, x1, y1-1, 1, ca);
}
draw_line(x0-1, y0+1, x1+1, y1+1, 3, ca);
draw_line(x0, y0, x1, y1, 1, ca);
}
}
draw_ohline(X_CENTER - 3, X_CENTER + 3, Y_CENTER, 1, 3, ca);
draw_vline(X_CENTER, Y_CENTER - 3, Y_CENTER + 3, 1, ca);
float cos_i, sin_i;
for (i = -ROLL_RANGE/2; i <= ROLL_RANGE/2; i++) {
y = Y_CENTER - i;
//j = priv->pitch_deg*SCALE + i;
//j = priv->roll_deg + i;
if (i % (MINOR_ROLL_TICK) == 0) {
gap = 70;
if (i == 0) {
size = 10;
} else {
if (i % (MAJOR_ROLL_TICK) == 0)
size = 10;
else
size = 5;
}
cos_i = cos(DEG2RAD(i));
sin_i = sin(DEG2RAD(i));
cx = X_CENTER;// + (int) (gap * cos_i);
cy = Y_CENTER;// - (int) (gap * sin_i);
offset = (int) gap * cos_i;
x0 = cx + offset;
offset = (int) size * cos_i;
x1 = x0 + offset;
offset = (int) gap * sin_i;
y0 = cy - offset;
offset = (int) size * sin_i;
y1 = y0 - offset;
draw_line(x0, y0, x1, y1, 1, ca);
if ((i != 0) && (i % (MAJOR_ROLL_TICK) == 0)) {
sprintf(buf, "%d", i);
draw_jstr(buf, x1, y1, JUST_VCENTER, ca, 0);
}
}
}
cx = X_CENTER; // + (int) (gap * priv->sin_roll);
cy = Y_CENTER ; //- (int) (gap * priv->cos_roll);
size = 10;
offset = (int) (gap-size) * priv->cos_roll;
x0 = cx + offset;
offset = (int) size * priv->cos_roll;
x1 = x0 + offset;
offset = (int) (gap-size) * priv->sin_roll;
y0 = cy + offset;
offset = (int) size * priv->sin_roll;
y1 = y0 + offset;
draw_line(x0-1, y0-1, x1+1, y1-1, 3, ca);
draw_line(x0-1, y0+1, x1+1, y1+1, 3, ca);
draw_line(x0, y0, x1, y1, 1, ca);
}
