void render()
{
// Lock surface if needed
if (SDL_MUSTLOCK(screen))
if (SDL_LockSurface(screen) < 0)
return;
// Clear the screen with a green color
int i, j;
for (i = 0; i < 480; i++)
{
for (j = 0; j < 640; j++)
{
*(((unsigned long*)screen->pixels) + i * PITCH + j) = 0x005f00;
}
}
// Ask SDL for the time in milliseconds
int tick = SDL_GetTicks();
float pos_x = (float)sin(tick * 0.00037234f) * 2;
float pos_y = (float)cos(tick * 0.00057234f) * 2;
float shadow_x = (float)sin(tick * 0.0002934872f) * 16;
float shadow_y = (float)cos(tick * 0.0001813431f) * 16;
for (j = 0; j < TREECOUNT; j++)
{
float x = xy[j * 2 + 0] + pos_x;
float y = xy[j * 2 + 1] + pos_y;
for (i = 0; i < 8; i++)
{
drawcircle((int)(x * 200 + 320 + (i + 1) * shadow_x),
(int)(y * 200 + 240 + (i + 1) * shadow_y),
(10 - i) * 5,
0x1f4f1f);
}
}
for (i = 0; i < 8; i++)
{
for (j = 0; j < TREECOUNT; j++)
{
float x = xy[j * 2 + 0] + pos_x;
float y = xy[j * 2 + 1] + pos_y;
drawcircle((int)(x * (200 + i * 4) + 320),
(int)(y * (200 + i * 4) + 240),
(9 - i) * 5,
i * 0x030906 + 0x1f671f);
}
}
// Unlock if needed
if (SDL_MUSTLOCK(screen))
SDL_UnlockSurface(screen);
// Tell SDL to update the whole screen
SDL_UpdateRect(screen, 0, 0, 640, 480);
}
int
main (int argc, char *argv[])
{
panda_pdf *document;
panda_page *mypage;
int *results, count;
if ((document = panda_open ("circles.pdf", "w")) == NULL)
panda_error (panda_true, "Could not create circles.pdf");
mypage = panda_newpage (document, panda_pagesize_a4);
// We are going to draw some circles to prove that I can...
results = drawcircle (mypage, 200, 200, 100, 10);
for (count = 0; count < 20; count += 2)
{
printf ("[%d, %d]\n", results[count], results[count + 1]);
free (drawcircle (mypage, results[count], results[count + 1], 10, 30));
}
// Close the PDF
panda_close (document);
}
int main()
{
int gd=DETECT, gm ,i;
float p, q, r, d, x, y;
printf("Enter the co-ordinates of the center : ");
scanf("%f%f",&x, &y);
printf("\nEnter the radius : ");
scanf("%f",&r);
p=0; q=r;
d=3-2*r;
initgraph(&gd, &gm, NULL);
while(p<q)
{
p++;
if(d<0)
d+=4*p+6;
else
{
q--;
d+=4*(p-q)+10;
}
drawcircle(x, y, p, q);
delay(100);
}
closegraph();
}
void task1(void* pdata)
{
ALT_SEM_PEND(display,0);
OSTimeDly(1);
volatile short * pixel_ctrl_ptr = (volatile short *) pdata;
int i=0;
//d-pad
drawrectangle( pixel_ctrl_ptr , 80, 100, 10, 15, 0xFFFF);
drawrectangle( pixel_ctrl_ptr , 80, 130, 10, 15, 0xFFFF);
drawrectangle( pixel_ctrl_ptr , 62, 117, 15, 10, 0xFFFF);
drawrectangle( pixel_ctrl_ptr , 93, 117, 15, 10, 0xFFFF);
//select start
drawrectangle( pixel_ctrl_ptr , 130, 117,15, 10, 0xFFFF);
drawrectangle( pixel_ctrl_ptr , 160, 117, 15, 10, 0xFFFF);
//buttons
drawcircle( pixel_ctrl_ptr ,205,121,7,0xFFFF);
drawcircle( pixel_ctrl_ptr ,235,121,7,0xFFFF);
drawcircle( pixel_ctrl_ptr ,220,106,7,0xFFFF);
drawcircle( pixel_ctrl_ptr ,220,136,7,0xFFFF);
//upper keys
drawrectangle( pixel_ctrl_ptr , 75, 80, 20, 10, 0xFFFF);
drawrectangle( pixel_ctrl_ptr , 75, 65, 20, 10, 0xFFFF);
drawrectangle( pixel_ctrl_ptr , 210, 80, 20,10, 0xFFFF);
drawrectangle( pixel_ctrl_ptr , 210, 65, 20, 10, 0xFFFF);
//analog sticks
drawcircle( pixel_ctrl_ptr ,110,155,15,0xFFFF);
drawcircle( pixel_ctrl_ptr ,195,155,15,0xFFFF);
drawcircle( pixel_ctrl_ptr ,110,155,9,0xFFFF);
drawcircle( pixel_ctrl_ptr ,195,155,9,0xFFFF);
while(1)
{
if(i>=10)
{
drawline(pixel_ctrl_ptr,0+i-10,50,0+i-10,60,0x0000);
drawline(pixel_ctrl_ptr,0+i-11,50,0+i-11,60,0x0000);
}
if(i<=320)
{
drawline(pixel_ctrl_ptr,0+i,50,0+i,60,0x0FFF);
drawline(pixel_ctrl_ptr,0+i+1,50,0+i+1,60,0x0FFF);
}
if(i==330)
{
i = 0;
}
i++;
wait_for_vsync(buffer_register,dma_control);
OSTimeDly(1);
ALT_SEM_POST(display);
}
}
void circle(int xc,int yc,int r)
{
int x=0,y=r,d=3-2*r;
while(x<y)
{
drawcircle(xc,yc,x,y);
x=x+1;
if(d<0)
d=d+4*x+6;
else
{
y=y-1;
d=d+4*(x-y)+10;
}
drawcircle(xc,yc,x,y);
}
}
void Graph::scatterPlotCircle() {
init(); // Draws the axis.
setcolor(WHITE);
outtextxy(425, 40, "SCATTER PLOT CIRCLE");
setcolor(YELLOW);
for (int i = 0; i < counter; ++i) {
drawcircle(points[i][0], points[i][1], 3);
}
}
void effect::drawcircle(rpgent *d, use_weapon *wep, float size, int type, int elapse)
{
vec axis;
if(wep->target == T_HORIZ)
axis = vec(d->yaw * RAD, (d->pitch + 90) * RAD);
else
axis = vec((d->yaw + 90) * RAD, 0);
vec dir = vec(d->yaw * RAD, d->pitch * RAD).rotate(-wep->angle / 2.f * RAD, axis);
vec o = vec(d->o).sub(vec(0, 0, d->eyeheight / 2));
drawcircle(o, dir, axis, wep->angle, d->radius + wep->range, size, type, elapse);
}
static void drawentity(t_entity *e)
{
glColor3f(e->color.red, e->color.green, e->color.blue);
if (e->type == V2)
;
if (e->type == V3)
drawcircle(e->shape.v3f.x, e->shape.v3f.y, e->shape.v3f.radius);
if (e->type == V4)
{
if (e->typegame == BRICK_OVERTIME)
drawovertime(e);
else
drawvertex4f(&e->shape.v4f);
}
glColor3f(1, 1, 1);
}
void svg_draw(void)
{
bm_scroll_bits = malloc(SCROLL_WIDTH * SCROLL_WIDTH);
drawcircle(bm_scroll_bits, SCROLL_WIDTH);
bm_statusarea = malloc(BM_STATUSAREA_WIDTH * BM_STATUSAREA_HEIGHT);
drawrectrounded(bm_statusarea, BM_STATUSAREA_WIDTH, BM_STATUSAREA_HEIGHT, SCALE * 2);
bm_add = malloc(BM_ADD_WIDTH * BM_ADD_WIDTH);
drawcross(bm_add, BM_ADD_WIDTH);
int s = BM_ADD_WIDTH * BM_ADD_WIDTH;
bm_groups = calloc(1, s);
drawgroup(bm_groups, BM_ADD_WIDTH);
bm_transfer = calloc(1, s);
drawline(bm_transfer, BM_ADD_WIDTH, BM_ADD_WIDTH, SCALE * 3, SCALE * 3, SCALE * 5, 0.75 * SCALE);
drawline(bm_transfer, BM_ADD_WIDTH, BM_ADD_WIDTH, SCALE * 6, SCALE * 6, SCALE * 5, 0.75 * SCALE);
drawtri(bm_transfer, BM_ADD_WIDTH, BM_ADD_WIDTH, 6 * SCALE, 0, 4 * SCALE, 0);
drawtri(bm_transfer, BM_ADD_WIDTH, BM_ADD_WIDTH, 3 * SCALE, 9 * SCALE, 4 * SCALE, 1);
bm_settings = malloc(s);
drawcross(bm_settings, BM_ADD_WIDTH);
drawxcross(bm_settings, BM_ADD_WIDTH, BM_ADD_WIDTH, BM_ADD_WIDTH);
drawnewcircle(bm_settings, BM_ADD_WIDTH, BM_ADD_WIDTH, 0.5 * BM_ADD_WIDTH, 0.5 * BM_ADD_WIDTH, 8 * SCALE);
drawsubcircle(bm_settings, BM_ADD_WIDTH, 0.5 * BM_ADD_WIDTH, 0.5 * BM_ADD_WIDTH, 4 * SCALE);
s = BM_CONTACT_WIDTH * BM_CONTACT_WIDTH;
bm_contact = calloc(1, s);
drawnewcircle(bm_contact, BM_CONTACT_WIDTH, 18 * SCALE, 10 * SCALE, 18 * SCALE, 15 * SCALE);
drawsubcircle(bm_contact, BM_CONTACT_WIDTH, 10 * SCALE, 10 * SCALE, 7 * SCALE);
drawhead(bm_contact, BM_CONTACT_WIDTH, 10 * SCALE, 6 * SCALE, 8 * SCALE);
bm_group = calloc(1, s);
drawgroup(bm_group, BM_CONTACT_WIDTH);
s = BM_LBICON_WIDTH * BM_LBICON_HEIGHT;
bm_file = malloc(s);
convert(bm_file, bm_file_bits, s);
bm_call = malloc(s);
convert(bm_call, bm_call_bits, s);
#define S (BM_STATUS_WIDTH * BM_STATUS_WIDTH)
bm_status_bits = malloc(S * 4);
drawcircle(bm_status_bits, BM_STATUS_WIDTH);
drawcircle(bm_status_bits + S, BM_STATUS_WIDTH);
drawcircle(bm_status_bits + S * 2, BM_STATUS_WIDTH);
drawcircle(bm_status_bits + S * 3, BM_STATUS_WIDTH);
drawsubcircle(bm_status_bits + S * 3, BM_STATUS_WIDTH, 0.5 * BM_STATUS_WIDTH, 0.5 * BM_STATUS_WIDTH, 4 * SCALE);
#undef S
bm_lbutton = malloc(BM_LBUTTON_WIDTH * BM_LBUTTON_HEIGHT);
drawrectrounded(bm_lbutton, BM_LBUTTON_WIDTH, BM_LBUTTON_HEIGHT, SCALE * 2);
bm_sbutton = malloc(BM_SBUTTON_WIDTH * BM_SBUTTON_HEIGHT);
drawrectrounded(bm_sbutton, BM_SBUTTON_WIDTH, BM_SBUTTON_HEIGHT, SCALE);
bm_ft = malloc(BM_FT_WIDTH * BM_FT_HEIGHT);
drawrectrounded(bm_ft, BM_FT_WIDTH, BM_FT_HEIGHT, SCALE * 2);
bm_ftm = malloc(BM_FTM_WIDTH * BM_FT_HEIGHT);
drawrectroundedex(bm_ftm, BM_FTM_WIDTH, BM_FT_HEIGHT, SCALE * 2, 13);
bm_ftb = malloc(BM_FTB_WIDTH * (BM_FTB_HEIGHT + SCALE) + BM_FTB_WIDTH * BM_FTB_HEIGHT);
drawrectroundedex(bm_ftb, BM_FTB_WIDTH, BM_FTB_HEIGHT + SCALE, SCALE * 2, 6);
drawrectroundedex(bm_ftb + BM_FTB_WIDTH * (BM_FTB_HEIGHT + SCALE), BM_FTB_WIDTH, BM_FTB_HEIGHT, SCALE * 2, 10);
s = BM_FB_WIDTH * BM_FB_HEIGHT;
bm_no = calloc(1, s);
drawxcross(bm_no, BM_FB_WIDTH, BM_FB_HEIGHT, BM_FB_HEIGHT);
bm_pause = calloc(1, s);
drawlinevert(bm_pause, BM_FB_WIDTH, BM_FB_HEIGHT, 0.75 * SCALE, 1.25 * SCALE);
drawlinevert(bm_pause, BM_FB_WIDTH, BM_FB_HEIGHT, 4.25 * SCALE, 1.25 * SCALE);
bm_yes = calloc(1, s);
drawline(bm_yes, BM_FB_WIDTH, BM_FB_HEIGHT, SCALE * 3.75, SCALE * 2.75, SCALE * 4, 0.5 * SCALE);
drawlinedown(bm_yes, BM_FB_WIDTH, BM_FB_HEIGHT, SCALE * 1.9, SCALE * 3.25, SCALE * 2.5, 0.5 * SCALE);
}
void testdrawcircle(uint8_t *buff) {
for (uint8_t i=0; i<64; i+=2) {
drawcircle(buffer, 63, 31, i, 1);
}
}
_Bool svg_draw(_Bool needmemory) {
int size, s;
void *p;
if(svg_data) {
free(svg_data);
}
/* Build what we expect the size to be.
* This section uses unnamed shortcuts, so it really serves no purpose and makes it harder to debug, it needs to be
* fixed, without shortcuts, and proper comments... TODO FIXME */
size = SCROLL_WIDTH * SCROLL_WIDTH + SCROLL_WIDTH * SCROLL_WIDTH /2 +
BM_STATUSAREA_WIDTH * BM_STATUSAREA_HEIGHT +
/* Panel buttons */
BM_ADD_WIDTH * BM_ADD_WIDTH * 4 +
BM_CONTACT_WIDTH * BM_CONTACT_WIDTH * 2 +
BM_LBICON_WIDTH * BM_LBICON_HEIGHT * 2 + // call, video
BM_FILE_WIDTH * BM_FILE_HEIGHT + BM_FILE_BIG_WIDTH * BM_FILE_BIG_HEIGHT + // file small and big
BM_STATUS_WIDTH * BM_STATUS_WIDTH * 4 +
BM_STATUS_NOTIFY_WIDTH * BM_STATUS_NOTIFY_WIDTH +
BM_LBUTTON_WIDTH * BM_LBUTTON_HEIGHT +
BM_SBUTTON_WIDTH * BM_SBUTTON_HEIGHT +
/* File transfer */
BM_FT_CAP_WIDTH * BM_FTB_HEIGHT +
BM_FT_WIDTH * BM_FT_HEIGHT +
BM_FTM_WIDTH * BM_FT_HEIGHT +
(BM_FTB_WIDTH * (BM_FTB_HEIGHT + UTOX_SCALE(1)) + BM_FTB_WIDTH * BM_FTB_HEIGHT) +
BM_FB_WIDTH * BM_FB_HEIGHT * 4 +
/* Chat Buttons */
BM_CHAT_BUTTON_WIDTH * BM_CHAT_BUTTON_HEIGHT * 2 + // Chat button 1, 2
BM_CHAT_SEND_WIDTH * BM_CHAT_SEND_HEIGHT +
BM_CHAT_SEND_OVERLAY_WIDTH * BM_CHAT_SEND_OVERLAY_HEIGHT +
BM_CHAT_BUTTON_OVERLAY_WIDTH * BM_CHAT_BUTTON_OVERLAY_HEIGHT;
svg_data = calloc(1, size);
if(!svg_data) {
return 0;
}
p = svg_data;
/* Scroll bars top bottom halves */
drawcircle(p, SCROLL_WIDTH);
loadalpha(BM_SCROLLHALFTOP, p, SCROLL_WIDTH, SCROLL_WIDTH /2);
loadalpha(BM_SCROLLHALFBOT, p + SCROLL_WIDTH * SCROLL_WIDTH /2, SCROLL_WIDTH, SCROLL_WIDTH /2);
p += SCROLL_WIDTH * SCROLL_WIDTH;
/* Scroll bars top bottom halves (small)*/
drawcircle(p, SCROLL_WIDTH /2);
loadalpha(BM_SCROLLHALFTOP_SMALL, p, SCROLL_WIDTH /2, SCROLL_WIDTH /4);
loadalpha(BM_SCROLLHALFBOT_SMALL, p + SCROLL_WIDTH /2 * SCROLL_WIDTH /4, SCROLL_WIDTH /2, SCROLL_WIDTH /4);
p += SCROLL_WIDTH * SCROLL_WIDTH /2;
drawrectrounded(p, BM_STATUSAREA_WIDTH, BM_STATUSAREA_HEIGHT, UTOX_SCALE(2));
loadalpha(BM_STATUSAREA, p, BM_STATUSAREA_WIDTH, BM_STATUSAREA_HEIGHT);
p += BM_STATUSAREA_WIDTH * BM_STATUSAREA_HEIGHT;
/* Draw panel Buttons */
drawcross(p, BM_ADD_WIDTH);
loadalpha(BM_ADD, p, BM_ADD_WIDTH, BM_ADD_WIDTH);
p += BM_ADD_WIDTH * BM_ADD_WIDTH;
/* New group bitmap */
drawgroup(p, BM_ADD_WIDTH);
loadalpha(BM_GROUPS, p, BM_ADD_WIDTH, BM_ADD_WIDTH);
p += BM_ADD_WIDTH * BM_ADD_WIDTH;
drawline(p, BM_ADD_WIDTH, BM_ADD_WIDTH, UTOX_SCALE(3), UTOX_SCALE(3), UTOX_SCALE(5), UTOX_SCALE(0.75 ));
drawline(p, BM_ADD_WIDTH, BM_ADD_WIDTH, UTOX_SCALE(6), UTOX_SCALE(6), UTOX_SCALE(5), UTOX_SCALE(0.75 ));
drawtri(p, BM_ADD_WIDTH, BM_ADD_WIDTH, UTOX_SCALE(6 ), 0, UTOX_SCALE(4 ), 0);
drawtri(p, BM_ADD_WIDTH, BM_ADD_WIDTH, UTOX_SCALE(3 ), UTOX_SCALE(9 ), UTOX_SCALE(4 ), 1);
loadalpha(BM_TRANSFER, p, BM_ADD_WIDTH, BM_ADD_WIDTH);
p += BM_ADD_WIDTH * BM_ADD_WIDTH;
/* Settings gear bitmap */
drawcross(p, BM_ADD_WIDTH);
drawxcross(p, BM_ADD_WIDTH, BM_ADD_WIDTH, BM_ADD_WIDTH);
drawnewcircle(p, BM_ADD_WIDTH, BM_ADD_WIDTH, 0.5 * BM_ADD_WIDTH, 0.5 * BM_ADD_WIDTH, UTOX_SCALE(7 ));
drawsubcircle(p, BM_ADD_WIDTH, BM_ADD_WIDTH, 0.5 * BM_ADD_WIDTH, 0.5 * BM_ADD_WIDTH, UTOX_SCALE(3 ));
loadalpha(BM_SETTINGS, p, BM_ADD_WIDTH, BM_ADD_WIDTH);
p += BM_ADD_WIDTH * BM_ADD_WIDTH;
/* Contact avatar default bitmap */
drawnewcircle(p, BM_CONTACT_WIDTH, UTOX_SCALE(18 ), UTOX_SCALE(10 ), UTOX_SCALE(18 ), UTOX_SCALE(14 ));
drawsubcircle(p, BM_CONTACT_WIDTH, BM_CONTACT_WIDTH, UTOX_SCALE(10 ), UTOX_SCALE(10 ), UTOX_SCALE(6 ));
drawhead(p, BM_CONTACT_WIDTH, UTOX_SCALE(10 ), UTOX_SCALE(6 ), UTOX_SCALE(8 ));
loadalpha(BM_CONTACT, p, BM_CONTACT_WIDTH, BM_CONTACT_WIDTH);
p += BM_CONTACT_WIDTH * BM_CONTACT_WIDTH;
/* Group heads default bitmap */
drawgroup(p, BM_CONTACT_WIDTH);
loadalpha(BM_GROUP, p, BM_CONTACT_WIDTH, BM_CONTACT_WIDTH);
p += BM_CONTACT_WIDTH * BM_CONTACT_WIDTH;
/* Draw button icon overlays. */
drawlineround(p, BM_FILE_WIDTH, BM_FILE_HEIGHT, UTOX_SCALE(5.5 ), UTOX_SCALE(5 ), UTOX_SCALE(1 ), UTOX_SCALE(3.85 ), UTOX_SCALE(6.6 ), 0);
drawlineroundempty(p, BM_FILE_WIDTH, BM_FILE_HEIGHT, UTOX_SCALE(5.5 ), UTOX_SCALE(5 ), UTOX_SCALE(1 ), UTOX_SCALE(2.4 ), UTOX_SCALE(4.5 ));
drawsubcircle(p, BM_FILE_WIDTH, BM_FILE_HEIGHT, UTOX_SCALE(6.0 ), UTOX_SCALE(8.1 ), UTOX_SCALE(2.5 ));
drawlineround(p, BM_FILE_WIDTH, BM_FILE_HEIGHT, UTOX_SCALE(7.0 ), UTOX_SCALE(5.40 ), UTOX_SCALE(0.5 ), UTOX_SCALE(2.2 ), UTOX_SCALE(3.75 ), 1);
drawlineroundempty(p, BM_FILE_WIDTH, BM_FILE_HEIGHT, UTOX_SCALE(7.25 ), UTOX_SCALE(5.15 ), UTOX_SCALE(0.75 ), UTOX_SCALE(0.75 ), UTOX_SCALE(1.5 ));
loadalpha(BM_FILE, p, BM_FILE_WIDTH, BM_FILE_HEIGHT);
p += BM_FILE_WIDTH * BM_FILE_HEIGHT;
/* and the big one... */
// TODO convert the *2 hack
drawlineround(p, BM_FILE_BIG_WIDTH, BM_FILE_BIG_HEIGHT, UTOX_SCALE(5.5 ) * 2, UTOX_SCALE(5 ) * 2, UTOX_SCALE(1 ) * 2, UTOX_SCALE(3.85 ) * 2, UTOX_SCALE(6.6 ) * 2, 0);
drawlineroundempty(p, BM_FILE_BIG_WIDTH, BM_FILE_BIG_HEIGHT, UTOX_SCALE(5.5 ) * 2, UTOX_SCALE(5 ) * 2, UTOX_SCALE(1 ) * 2, UTOX_SCALE(2.4 ) * 2, UTOX_SCALE(4.5 ) * 2);
drawsubcircle(p, BM_FILE_BIG_WIDTH, BM_FILE_BIG_HEIGHT, UTOX_SCALE(6.0 ) * 2, UTOX_SCALE(8.1 ) * 2, UTOX_SCALE(2.5 ) * 2);
drawlineround(p, BM_FILE_BIG_WIDTH, BM_FILE_BIG_HEIGHT, UTOX_SCALE(7.0 ) * 2, UTOX_SCALE(5.40 ) * 2, UTOX_SCALE(0.5 ) * 2, UTOX_SCALE(2.2 ) * 2, UTOX_SCALE(3.75 ) * 2, 1);
drawlineroundempty(p, BM_FILE_BIG_WIDTH, BM_FILE_BIG_HEIGHT, UTOX_SCALE(7.25 ) * 2, UTOX_SCALE(5.15 ) * 2, UTOX_SCALE(0.75 ) * 2, UTOX_SCALE(0.75 ) * 2, UTOX_SCALE(1.5 ) * 2);
loadalpha(BM_FILE_BIG, p, BM_FILE_BIG_WIDTH, BM_FILE_BIG_HEIGHT);
p += BM_FILE_BIG_WIDTH * BM_FILE_BIG_HEIGHT;
drawnewcircle(p, BM_LBICON_WIDTH, BM_LBICON_HEIGHT, UTOX_SCALE(1), 0, UTOX_SCALE(19 ));
drawsubcircle(p, BM_LBICON_WIDTH, BM_LBICON_HEIGHT, UTOX_SCALE(1), 0, UTOX_SCALE(15 ));
drawnewcircle2(p, BM_LBICON_WIDTH, BM_LBICON_HEIGHT, UTOX_SCALE(9 ), UTOX_SCALE(2 ), UTOX_SCALE(3 ), 0);
drawnewcircle2(p, BM_LBICON_WIDTH, BM_LBICON_HEIGHT, UTOX_SCALE(3 ), UTOX_SCALE(8 ), UTOX_SCALE(3 ), 1);
loadalpha(BM_CALL, p, BM_LBICON_WIDTH, BM_LBICON_HEIGHT);
p += BM_LBICON_WIDTH * BM_LBICON_HEIGHT;
/* Video start end bitmap */
int x, y;
uint8_t *data = p;
/* left triangle lens thing */
for(y = 0; y != BM_LBICON_HEIGHT; y++) {
for(x = 0; x != UTOX_SCALE(4); x++) {
double d = fabs(y - UTOX_SCALE(4.5 )) - 0.66 * (UTOX_SCALE(4) - x);
*data++ = pixel(d);
}
data += BM_LBICON_WIDTH - UTOX_SCALE(4);
}
drawrectroundedsub(p, BM_LBICON_WIDTH, BM_LBICON_HEIGHT, UTOX_SCALE(4 ), UTOX_SCALE(1), UTOX_SCALE(7 ), UTOX_SCALE(7 ), UTOX_SCALE(1));
loadalpha(BM_VIDEO, p, BM_LBICON_WIDTH, BM_LBICON_HEIGHT);
p += BM_LBICON_WIDTH * BM_LBICON_HEIGHT;
/* Draw user status Buttons */
s = BM_STATUS_WIDTH * BM_STATUS_WIDTH;
drawcircle(p, BM_STATUS_WIDTH);
loadalpha(BM_ONLINE, p, BM_STATUS_WIDTH, BM_STATUS_WIDTH);
p += s;
drawcircle(p, BM_STATUS_WIDTH);
drawsubcircle(p, BM_STATUS_WIDTH, BM_STATUS_WIDTH / 2, 0.5 * BM_STATUS_WIDTH, 0.5 * BM_STATUS_WIDTH, SCALE(6));
loadalpha(BM_AWAY, p, BM_STATUS_WIDTH, BM_STATUS_WIDTH);
p += s;
drawcircle(p, BM_STATUS_WIDTH);
drawsubcircle(p, BM_STATUS_WIDTH, BM_STATUS_WIDTH / 2, 0.5 * BM_STATUS_WIDTH, 0.5 * BM_STATUS_WIDTH, SCALE(6));
loadalpha(BM_BUSY, p, BM_STATUS_WIDTH, BM_STATUS_WIDTH);
p += s;
drawcircle(p, BM_STATUS_WIDTH);
drawsubcircle(p, BM_STATUS_WIDTH, BM_STATUS_WIDTH, 0.5 * BM_STATUS_WIDTH, 0.5 * BM_STATUS_WIDTH, SCALE(6));
loadalpha(BM_OFFLINE, p, BM_STATUS_WIDTH, BM_STATUS_WIDTH);
p += s;
drawcircle(p, BM_STATUS_NOTIFY_WIDTH);
drawsubcircle(p, BM_STATUS_NOTIFY_WIDTH, BM_STATUS_NOTIFY_WIDTH, 0.5 * BM_STATUS_NOTIFY_WIDTH, 0.5 * BM_STATUS_NOTIFY_WIDTH, SCALE(10));
loadalpha(BM_STATUS_NOTIFY, p, BM_STATUS_NOTIFY_WIDTH, BM_STATUS_NOTIFY_WIDTH);
p += BM_STATUS_NOTIFY_WIDTH * BM_STATUS_NOTIFY_WIDTH;
drawrectrounded(p, BM_LBUTTON_WIDTH, BM_LBUTTON_HEIGHT, UTOX_SCALE(2));
loadalpha(BM_LBUTTON, p, BM_LBUTTON_WIDTH, BM_LBUTTON_HEIGHT);
p += BM_LBUTTON_WIDTH * BM_LBUTTON_HEIGHT;
drawrectrounded(p, BM_SBUTTON_WIDTH, BM_SBUTTON_HEIGHT, UTOX_SCALE(2));
loadalpha(BM_SBUTTON, p, BM_SBUTTON_WIDTH, BM_SBUTTON_HEIGHT);
p += BM_SBUTTON_WIDTH * BM_SBUTTON_HEIGHT;
/* Draw file transfer buttons */
drawrectroundedex(p, BM_FT_CAP_WIDTH, BM_FTB_HEIGHT, UTOX_SCALE(2), 13);
loadalpha(BM_FT_CAP, p, BM_FT_CAP_WIDTH, BM_FTB_HEIGHT);
p += BM_FT_CAP_WIDTH * BM_FTB_HEIGHT;
drawrectrounded(p, BM_FT_WIDTH, BM_FT_HEIGHT, UTOX_SCALE(2));
loadalpha(BM_FT, p, BM_FT_WIDTH, BM_FT_HEIGHT);
p += BM_FT_WIDTH * BM_FT_HEIGHT;
drawrectroundedex(p, BM_FTM_WIDTH, BM_FT_HEIGHT, UTOX_SCALE(2), 13);
loadalpha(BM_FTM, p, BM_FTM_WIDTH, BM_FT_HEIGHT);
p += BM_FTM_WIDTH * BM_FT_HEIGHT;
drawrectroundedex(p, BM_FTB_WIDTH, BM_FTB_HEIGHT + UTOX_SCALE(1), UTOX_SCALE(2), 0);
loadalpha(BM_FTB1, p, BM_FTB_WIDTH, BM_FTB_HEIGHT + UTOX_SCALE(1));
p += BM_FTB_WIDTH * (BM_FTB_HEIGHT + UTOX_SCALE(1));
drawrectroundedex(p, BM_FTB_WIDTH, BM_FTB_HEIGHT, UTOX_SCALE(2), 14);
loadalpha(BM_FTB2, p, BM_FTB_WIDTH, BM_FTB_HEIGHT);
p += BM_FTB_WIDTH * BM_FTB_HEIGHT;
s = BM_FB_WIDTH * BM_FB_HEIGHT;
drawxcross(p, BM_FB_WIDTH, BM_FB_HEIGHT, BM_FB_HEIGHT);
loadalpha(BM_NO, p, BM_FB_WIDTH, BM_FB_HEIGHT);
p += s;
drawlinevert(p, BM_FB_WIDTH, BM_FB_HEIGHT, UTOX_SCALE(0.75 ), UTOX_SCALE(1.25 ));
drawlinevert(p, BM_FB_WIDTH, BM_FB_HEIGHT, UTOX_SCALE(4.25 ), UTOX_SCALE(1.25 ));
loadalpha(BM_PAUSE, p, BM_FB_WIDTH, BM_FB_HEIGHT);
p += s;
drawline(p, BM_FB_WIDTH, BM_FB_HEIGHT, UTOX_SCALE(1.75), UTOX_SCALE(3.5), UTOX_SCALE(2.5), UTOX_SCALE(0.5 ));
drawline(p, BM_FB_WIDTH, BM_FB_HEIGHT, UTOX_SCALE(4), UTOX_SCALE(3.5), UTOX_SCALE(2.5), UTOX_SCALE(0.5 ));
drawlinedown(p, BM_FB_WIDTH, BM_FB_HEIGHT, UTOX_SCALE(1.75), UTOX_SCALE(1.75), UTOX_SCALE(2.5), UTOX_SCALE(0.5 ));
drawlinedown(p, BM_FB_WIDTH, BM_FB_HEIGHT, UTOX_SCALE(4), UTOX_SCALE(1.75), UTOX_SCALE(2.5), UTOX_SCALE(0.5 ));
loadalpha(BM_RESUME, p, BM_FB_WIDTH, BM_FB_HEIGHT);
p += s;
drawline(p, BM_FB_WIDTH, BM_FB_HEIGHT, UTOX_SCALE(3.75), UTOX_SCALE(2.75), UTOX_SCALE(4), UTOX_SCALE(0.5 ));
drawlinedown(p, BM_FB_WIDTH, BM_FB_HEIGHT, UTOX_SCALE(1.9), UTOX_SCALE(3.25), UTOX_SCALE(2.5), UTOX_SCALE(0.5 ));
loadalpha(BM_YES, p, BM_FB_WIDTH, BM_FB_HEIGHT);
p += s;
/* the two small chat buttons... */
drawrectroundedex(p, BM_CHAT_BUTTON_WIDTH, BM_CHAT_BUTTON_HEIGHT, UTOX_SCALE(2), 13);
loadalpha(BM_CHAT_BUTTON_LEFT, p, BM_CHAT_BUTTON_WIDTH, BM_CHAT_BUTTON_HEIGHT);
p += BM_CHAT_BUTTON_WIDTH * BM_CHAT_BUTTON_HEIGHT;
drawrectroundedex(p, BM_CHAT_BUTTON_WIDTH, BM_CHAT_BUTTON_HEIGHT, UTOX_SCALE(2), 0);
loadalpha(BM_CHAT_BUTTON_RIGHT, p, BM_CHAT_BUTTON_WIDTH, BM_CHAT_BUTTON_HEIGHT);
p += BM_CHAT_BUTTON_WIDTH * BM_CHAT_BUTTON_HEIGHT;
/* Draw chat send button */
drawrectroundedex(p, BM_CHAT_SEND_WIDTH, BM_CHAT_SEND_HEIGHT, UTOX_SCALE(4 ), 14);
loadalpha(BM_CHAT_SEND, p, BM_CHAT_SEND_WIDTH, BM_CHAT_SEND_HEIGHT);
p += BM_CHAT_SEND_WIDTH * BM_CHAT_SEND_HEIGHT;
/* Draw chat send overlay */
drawnewcircle(p, BM_CHAT_SEND_OVERLAY_WIDTH, BM_CHAT_SEND_OVERLAY_HEIGHT, UTOX_SCALE(10 ), UTOX_SCALE(7 ), UTOX_SCALE(13 ));
drawtri( p, BM_CHAT_SEND_OVERLAY_WIDTH, BM_CHAT_SEND_OVERLAY_HEIGHT, UTOX_SCALE(15 ), UTOX_SCALE(9 ), UTOX_SCALE(6 ), 0);
loadalpha(BM_CHAT_SEND_OVERLAY, p, BM_CHAT_SEND_OVERLAY_WIDTH, BM_CHAT_SEND_OVERLAY_HEIGHT);
p += BM_CHAT_SEND_OVERLAY_WIDTH * BM_CHAT_SEND_OVERLAY_HEIGHT;
/* screen shot button overlay */
/* Rounded frame */
drawrectroundedsub(p, BM_CHAT_BUTTON_OVERLAY_WIDTH, BM_CHAT_BUTTON_OVERLAY_HEIGHT,
UTOX_SCALE(1 ), UTOX_SCALE(1 ),
BM_CHAT_BUTTON_OVERLAY_WIDTH - (UTOX_SCALE(4 )), BM_CHAT_BUTTON_OVERLAY_HEIGHT - (UTOX_SCALE(4 )),
UTOX_SCALE(1 ));
drawrectroundedneg(p, BM_CHAT_BUTTON_OVERLAY_WIDTH, BM_CHAT_BUTTON_OVERLAY_HEIGHT, /* width, height */
UTOX_SCALE(2 ), UTOX_SCALE(2 ), /* start x, y */
BM_CHAT_BUTTON_OVERLAY_WIDTH - (UTOX_SCALE(6 )), BM_CHAT_BUTTON_OVERLAY_HEIGHT - (UTOX_SCALE(6 )),
UTOX_SCALE(1 ));
/* camera shutter circle */
drawnewcircle(p, BM_CHAT_BUTTON_OVERLAY_WIDTH, BM_CHAT_BUTTON_OVERLAY_HEIGHT,
BM_CHAT_BUTTON_OVERLAY_WIDTH * 0.75, BM_CHAT_BUTTON_OVERLAY_HEIGHT * 0.75,
UTOX_SCALE(6 ));
drawsubcircle(p, BM_CHAT_BUTTON_OVERLAY_WIDTH, BM_CHAT_BUTTON_OVERLAY_HEIGHT,
BM_CHAT_BUTTON_OVERLAY_WIDTH * 0.75, BM_CHAT_BUTTON_OVERLAY_HEIGHT * 0.75,
UTOX_SCALE(2 ));
/* shutter lines */
svgdraw_line_neg(p, BM_CHAT_BUTTON_OVERLAY_WIDTH, BM_CHAT_BUTTON_OVERLAY_HEIGHT,
BM_CHAT_BUTTON_OVERLAY_WIDTH * 0.80, BM_CHAT_BUTTON_OVERLAY_HEIGHT * 0.65,
UTOX_SCALE(2 ), 0.1);
svgdraw_line_neg(p, BM_CHAT_BUTTON_OVERLAY_WIDTH, BM_CHAT_BUTTON_OVERLAY_HEIGHT,
BM_CHAT_BUTTON_OVERLAY_WIDTH * 0.73, BM_CHAT_BUTTON_OVERLAY_HEIGHT * 0.87,
UTOX_SCALE(2 ), 0.1);
svgdraw_line_down_neg(p, BM_CHAT_BUTTON_OVERLAY_WIDTH, BM_CHAT_BUTTON_OVERLAY_HEIGHT,
BM_CHAT_BUTTON_OVERLAY_WIDTH * 0.65, BM_CHAT_BUTTON_OVERLAY_HEIGHT * 0.70,
UTOX_SCALE(2 ), 0.1);
svgdraw_line_down_neg(p, BM_CHAT_BUTTON_OVERLAY_WIDTH, BM_CHAT_BUTTON_OVERLAY_HEIGHT,
BM_CHAT_BUTTON_OVERLAY_WIDTH * 0.85, BM_CHAT_BUTTON_OVERLAY_HEIGHT * 0.81,
UTOX_SCALE(2 ), 0.1);
loadalpha(BM_CHAT_BUTTON_OVERLAY_SCREENSHOT, p, BM_CHAT_BUTTON_OVERLAY_WIDTH, BM_CHAT_BUTTON_OVERLAY_HEIGHT);
p += BM_CHAT_BUTTON_OVERLAY_WIDTH * BM_CHAT_BUTTON_OVERLAY_HEIGHT;
if(p - svg_data != size) {
debug("SVG:\tSVG data size mismatch...\n");
}
if(!needmemory) {
free(svg_data);
svg_data = NULL;
}
return 1;
}
//========== DRAW ================= DRAW =================== DRAW ====================
void LCDST7565::drawMenu() {
uint8_t i, label_len;
this->clear();
//this->fillrect(0, 0, 128, 7, BLACK);
this->drawstring(centerString(_title), 0, _title);
invertRect(0,0,128,8);
i=0;
while ((i<N_LINES-1) & (i<_n_items)) {
this->drawstring(LEFT_MARGIN, i+1, _menu_items[_draw_index+i].label);
switch(_menu_items[_draw_index+i].type)
{
case MENU_ITEM_TYPE_CHECK:
{
uint8_t y = (i+1) * 8;
drawrect(GUI_CHECKBOX_X, y, 7, 7, BLACK);
if(_menu_items[_draw_index+i].checked)
{
drawline(GUI_CHECKBOX_X, y, GUI_CHECKBOX_X + 6, y + 6, BLACK);
drawline(GUI_CHECKBOX_X, y + 6, GUI_CHECKBOX_X + 6, y, BLACK);
}
break;
}
case MENU_ITEM_TYPE_RADIO:
{
uint8_t y = (i+1) * 8 + 4;
if(_menu_items[_draw_index+i].checked)
{
fillcircle(GUI_RADIO_X, y, 2, BLACK);
}
else
{
drawcircle(GUI_RADIO_X, y, 2, BLACK);
}
break;
}
case MENU_ITEM_TYPE_INLINE_INT:
{
char s[8];
sprintf(s, "%i", _menu_items[_draw_index+i].inlineValue);
this->drawstring(122 - strlen(s) * 6, i+1, s);
break;
}
}
i++;
}
/*// Draw arrow to indicate current item:
this->drawline(0, 11+(8*_current_line), LEFT_MARGIN-5,
11+(8*_current_line), BLACK);
this->drawline(LEFT_MARGIN-5, 8+(8*_current_line), LEFT_MARGIN-2,
11+(8*_current_line), BLACK);
this->drawline(LEFT_MARGIN-5, 14+(8*_current_line), LEFT_MARGIN-2,
11+(8*_current_line), BLACK);
this->drawline(LEFT_MARGIN-5, 14+(8*_current_line), LEFT_MARGIN-5,
8+(8*_current_line), BLACK);*/
this->drawbitmap(0, 8 * (_current_line+1), menu_arrow, 16, 8, BLACK);
// Draw up arrow if there are items above view
if (_draw_index > 0) {
this->drawline(123, 11, 125, 8, BLACK);
this->drawline(127, 11, 125, 8, BLACK);
}
// Draw down arrow if there are items below view
if ((_n_items - _draw_index) >= N_LINES) {
this->drawline(123, DOWN_ARROW_Y, 125, DOWN_ARROW_Y + 3, BLACK);
this->drawline(127, DOWN_ARROW_Y, 125, DOWN_ARROW_Y + 3, BLACK);
}
this->drawMenuButton(BUT_DOWN, 0);
this->drawMenuButton(BUT_UP, 1);
switch( _menu_items[_item_index].type )
{
case MENU_ITEM_TYPE_CHECK:
case MENU_ITEM_TYPE_RADIO:
{
this->drawMenuButton(BUT_BACK, 2);
this->drawMenuButton(BUT_SET, 3);
break;
}
case MENU_ITEM_TYPE_INLINE_INT:
{
this->drawMenuButton(BUT_LEFT, 2);
this->drawMenuButton(BUT_RIGHT, 3);
break;
}
default:
{
this->drawMenuButton(BUT_BACK, 2);
this->drawMenuButton(BUT_OK, 3);
break;
}
}
this->display();
}
_Bool svg_draw(_Bool needmemory)
{
int size, s;
void *p;
if(svg_data) {
free(svg_data);
}
size = SCROLL_WIDTH * SCROLL_WIDTH + BM_STATUSAREA_WIDTH * BM_STATUSAREA_HEIGHT + BM_ADD_WIDTH * BM_ADD_WIDTH * 4 +
BM_CONTACT_WIDTH * BM_CONTACT_WIDTH * 2 + BM_LBICON_WIDTH * BM_LBICON_HEIGHT * 3 + BM_STATUS_WIDTH * BM_STATUS_WIDTH * 4 +
BM_STATUS_NOTIFY_WIDTH * BM_STATUS_NOTIFY_WIDTH +
BM_LBUTTON_WIDTH * BM_LBUTTON_HEIGHT + BM_SBUTTON_WIDTH * BM_SBUTTON_HEIGHT + BM_FT_WIDTH * BM_FT_HEIGHT +
BM_FTM_WIDTH * BM_FT_HEIGHT + (BM_FTB_WIDTH * (BM_FTB_HEIGHT + SCALE) + BM_FTB_WIDTH * BM_FTB_HEIGHT) +
BM_FB_WIDTH * BM_FB_HEIGHT * 4;
svg_data = calloc(1, size);
if(!svg_data) {
return 0;
}
p = svg_data;
drawcircle(p, SCROLL_WIDTH);
loadalpha(BM_SCROLLHALFTOP, p, SCROLL_WIDTH, SCROLL_WIDTH / 2);
loadalpha(BM_SCROLLHALFBOT, p + SCROLL_WIDTH * SCROLL_WIDTH / 2, SCROLL_WIDTH, SCROLL_WIDTH / 2);
p += SCROLL_WIDTH * SCROLL_WIDTH;
drawrectrounded(p, BM_STATUSAREA_WIDTH, BM_STATUSAREA_HEIGHT, SCALE * 2);
loadalpha(BM_STATUSAREA, p, BM_STATUSAREA_WIDTH, BM_STATUSAREA_HEIGHT);
p += BM_STATUSAREA_WIDTH * BM_STATUSAREA_HEIGHT;
s = BM_ADD_WIDTH * BM_ADD_WIDTH;
drawcross(p, BM_ADD_WIDTH);
loadalpha(BM_ADD, p, BM_ADD_WIDTH, BM_ADD_WIDTH);
p += s;
drawgroup(p, BM_ADD_WIDTH);
loadalpha(BM_GROUPS, p, BM_ADD_WIDTH, BM_ADD_WIDTH);
p += s;
drawline(p, BM_ADD_WIDTH, BM_ADD_WIDTH, SCALE * 3, SCALE * 3, SCALE * 5, 0.75 * SCALE);
drawline(p, BM_ADD_WIDTH, BM_ADD_WIDTH, SCALE * 6, SCALE * 6, SCALE * 5, 0.75 * SCALE);
drawtri(p, BM_ADD_WIDTH, BM_ADD_WIDTH, 6 * SCALE, 0, 4 * SCALE, 0);
drawtri(p, BM_ADD_WIDTH, BM_ADD_WIDTH, 3 * SCALE, 9 * SCALE, 4 * SCALE, 1);
loadalpha(BM_TRANSFER, p, BM_ADD_WIDTH, BM_ADD_WIDTH);
p += s;
drawcross(p, BM_ADD_WIDTH);
drawxcross(p, BM_ADD_WIDTH, BM_ADD_WIDTH, BM_ADD_WIDTH);
drawnewcircle(p, BM_ADD_WIDTH, BM_ADD_WIDTH, 0.5 * BM_ADD_WIDTH, 0.5 * BM_ADD_WIDTH, 7 * SCALE);
drawsubcircle(p, BM_ADD_WIDTH, BM_ADD_WIDTH, 0.5 * BM_ADD_WIDTH, 0.5 * BM_ADD_WIDTH, 3 * SCALE);
loadalpha(BM_SETTINGS, p, BM_ADD_WIDTH, BM_ADD_WIDTH);
p += s;
s = BM_CONTACT_WIDTH * BM_CONTACT_WIDTH;
drawnewcircle(p, BM_CONTACT_WIDTH, 18 * SCALE, 10 * SCALE, 18 * SCALE, 14 * SCALE);
drawsubcircle(p, BM_CONTACT_WIDTH, BM_CONTACT_WIDTH, 10 * SCALE, 10 * SCALE, 6 * SCALE);
drawhead(p, BM_CONTACT_WIDTH, 10 * SCALE, 6 * SCALE, 8 * SCALE);
loadalpha(BM_CONTACT, p, BM_CONTACT_WIDTH, BM_CONTACT_WIDTH);
p += s;
drawgroup(p, BM_CONTACT_WIDTH);
loadalpha(BM_GROUP, p, BM_CONTACT_WIDTH, BM_CONTACT_WIDTH);
p += s;
s = BM_LBICON_WIDTH * BM_LBICON_HEIGHT;
drawlineround(p, BM_LBICON_WIDTH, BM_LBICON_HEIGHT, 5.5 * SCALE, 5 * SCALE, 1 * SCALE, 3.85 * SCALE, 6.6 * SCALE, 0);
drawlineroundempty(p, BM_LBICON_WIDTH, BM_LBICON_HEIGHT, 5.5 * SCALE, 5 * SCALE, 1 * SCALE, 2.4 * SCALE, 4.5 * SCALE);
drawsubcircle(p, BM_LBICON_WIDTH, BM_LBICON_HEIGHT, 6.0 * SCALE, 8.1 * SCALE, 2.5 * SCALE);
drawlineround(p, BM_LBICON_WIDTH, BM_LBICON_HEIGHT, 7.0 * SCALE, 5.40 * SCALE, 0.5 * SCALE, 2.2 * SCALE, 3.75 * SCALE, 1);
drawlineroundempty(p, BM_LBICON_WIDTH, BM_LBICON_HEIGHT, 7.25 * SCALE, 5.15 * SCALE, 0.75 * SCALE, 0.75 * SCALE, 1.5 * SCALE);
loadalpha(BM_FILE, p, BM_LBICON_WIDTH, BM_LBICON_HEIGHT);
p += s;
drawnewcircle(p, BM_LBICON_WIDTH, BM_LBICON_HEIGHT, SCALE, 0, 19 * SCALE);
drawsubcircle(p, BM_LBICON_WIDTH, BM_LBICON_HEIGHT, SCALE, 0, 15 * SCALE);
drawnewcircle2(p, BM_LBICON_WIDTH, BM_LBICON_HEIGHT, 9 * SCALE, 2 * SCALE, 3 * SCALE, 0);
drawnewcircle2(p, BM_LBICON_WIDTH, BM_LBICON_HEIGHT, 3 * SCALE, 8 * SCALE, 3 * SCALE, 1);
loadalpha(BM_CALL, p, BM_LBICON_WIDTH, BM_LBICON_HEIGHT);
p += s;
int x, y;
uint8_t *data = p;
for(y = 0; y != BM_LBICON_HEIGHT; y++) {
for(x = 0; x != SCALE * 4; x++) {
double d = fabs(y - 4.5 * SCALE) - 0.66 * (SCALE * 4 - x);
*data++ = pixel(d);
}
data += BM_LBICON_WIDTH - SCALE * 4;
}
drawrectroundedsub(p, BM_LBICON_WIDTH, BM_LBICON_HEIGHT, 4 * SCALE, SCALE, 7 * SCALE, 7 * SCALE, SCALE);
loadalpha(BM_VIDEO, p, BM_LBICON_WIDTH, BM_LBICON_HEIGHT);
p += s;
s = BM_STATUS_WIDTH * BM_STATUS_WIDTH;
drawcircle(p, BM_STATUS_WIDTH);
loadalpha(BM_ONLINE, p, BM_STATUS_WIDTH, BM_STATUS_WIDTH);
p += s;
drawcircle(p, BM_STATUS_WIDTH);
drawsubcircle(p, BM_STATUS_WIDTH, BM_STATUS_WIDTH / 2, 0.5 * BM_STATUS_WIDTH, 0.5 * BM_STATUS_WIDTH, 3 * SCALE);
loadalpha(BM_AWAY, p, BM_STATUS_WIDTH, BM_STATUS_WIDTH);
p += s;
drawcircle(p, BM_STATUS_WIDTH);
drawsubcircle(p, BM_STATUS_WIDTH, BM_STATUS_WIDTH / 2, 0.5 * BM_STATUS_WIDTH, 0.5 * BM_STATUS_WIDTH, 3 * SCALE);
loadalpha(BM_BUSY, p, BM_STATUS_WIDTH, BM_STATUS_WIDTH);
p += s;
drawcircle(p, BM_STATUS_WIDTH);
drawsubcircle(p, BM_STATUS_WIDTH, BM_STATUS_WIDTH, 0.5 * BM_STATUS_WIDTH, 0.5 * BM_STATUS_WIDTH, 3 * SCALE);
loadalpha(BM_OFFLINE, p, BM_STATUS_WIDTH, BM_STATUS_WIDTH);
p += s;
drawcircle(p, BM_STATUS_NOTIFY_WIDTH);
drawsubcircle(p, BM_STATUS_NOTIFY_WIDTH, BM_STATUS_NOTIFY_WIDTH, 0.5 * BM_STATUS_NOTIFY_WIDTH, 0.5 * BM_STATUS_NOTIFY_WIDTH, 5 * SCALE);
loadalpha(BM_STATUS_NOTIFY, p, BM_STATUS_NOTIFY_WIDTH, BM_STATUS_NOTIFY_WIDTH);
p += BM_STATUS_NOTIFY_WIDTH * BM_STATUS_NOTIFY_WIDTH;
drawrectrounded(p, BM_LBUTTON_WIDTH, BM_LBUTTON_HEIGHT, SCALE * 2);
loadalpha(BM_LBUTTON, p, BM_LBUTTON_WIDTH, BM_LBUTTON_HEIGHT);
p += BM_LBUTTON_WIDTH * BM_LBUTTON_HEIGHT;
drawrectrounded(p, BM_SBUTTON_WIDTH, BM_SBUTTON_HEIGHT, SCALE);
loadalpha(BM_SBUTTON, p, BM_SBUTTON_WIDTH, BM_SBUTTON_HEIGHT);
p += BM_SBUTTON_WIDTH * BM_SBUTTON_HEIGHT;
drawrectrounded(p, BM_FT_WIDTH, BM_FT_HEIGHT, SCALE * 2);
loadalpha(BM_FT, p, BM_FT_WIDTH, BM_FT_HEIGHT);
p += BM_FT_WIDTH * BM_FT_HEIGHT;
drawrectroundedex(p, BM_FTM_WIDTH, BM_FT_HEIGHT, SCALE * 2, 13);
loadalpha(BM_FTM, p, BM_FTM_WIDTH, BM_FT_HEIGHT);
p += BM_FTM_WIDTH * BM_FT_HEIGHT;
drawrectroundedex(p, BM_FTB_WIDTH, BM_FTB_HEIGHT + SCALE, SCALE * 2, 6);
loadalpha(BM_FTB1, p, BM_FTB_WIDTH, BM_FTB_HEIGHT + SCALE);
p += BM_FTB_WIDTH * (BM_FTB_HEIGHT + SCALE);
drawrectroundedex(p, BM_FTB_WIDTH, BM_FTB_HEIGHT, SCALE * 2, 10);
loadalpha(BM_FTB2, p, BM_FTB_WIDTH, BM_FTB_HEIGHT);
p += BM_FTB_WIDTH * BM_FTB_HEIGHT;
s = BM_FB_WIDTH * BM_FB_HEIGHT;
drawxcross(p, BM_FB_WIDTH, BM_FB_HEIGHT, BM_FB_HEIGHT);
loadalpha(BM_NO, p, BM_FB_WIDTH, BM_FB_HEIGHT);
p += s;
drawlinevert(p, BM_FB_WIDTH, BM_FB_HEIGHT, 0.75 * SCALE, 1.25 * SCALE);
drawlinevert(p, BM_FB_WIDTH, BM_FB_HEIGHT, 4.25 * SCALE, 1.25 * SCALE);
loadalpha(BM_PAUSE, p, BM_FB_WIDTH, BM_FB_HEIGHT);
p += s;
drawline(p, BM_FB_WIDTH, BM_FB_HEIGHT, SCALE * 1.75, SCALE * 3.5, SCALE * 2.5, 0.5 * SCALE);
drawline(p, BM_FB_WIDTH, BM_FB_HEIGHT, SCALE * 4, SCALE * 3.5, SCALE * 2.5, 0.5 * SCALE);
drawlinedown(p, BM_FB_WIDTH, BM_FB_HEIGHT, SCALE * 1.75, SCALE * 1.75, SCALE * 2.5, 0.5 * SCALE);
drawlinedown(p, BM_FB_WIDTH, BM_FB_HEIGHT, SCALE * 4, SCALE * 1.75, SCALE * 2.5, 0.5 * SCALE);
loadalpha(BM_RESUME, p, BM_FB_WIDTH, BM_FB_HEIGHT);
p += s;
drawline(p, BM_FB_WIDTH, BM_FB_HEIGHT, SCALE * 3.75, SCALE * 2.75, SCALE * 4, 0.5 * SCALE);
drawlinedown(p, BM_FB_WIDTH, BM_FB_HEIGHT, SCALE * 1.9, SCALE * 3.25, SCALE * 2.5, 0.5 * SCALE);
loadalpha(BM_YES, p, BM_FB_WIDTH, BM_FB_HEIGHT);
p += s;
if(p - svg_data != size) {
debug("something went wrong\n");
}
if(!needmemory) {
free(svg_data);
svg_data = NULL;
}
return 1;
}
