_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_THREE_BAR_WIDTH * BM_THREE_BAR_WIDTH +
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_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 +
/* 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, 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, 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 += 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, 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 += BM_ADD_WIDTH * BM_ADD_WIDTH;
/* Settings 3 line bitmap width height x y width height radius */
drawrectroundedsub(p, BM_THREE_BAR_WIDTH, BM_THREE_BAR_WIDTH, BM_THREE_BAR_WIDTH * .15, BM_THREE_BAR_WIDTH /4 - BM_THREE_BAR_WIDTH /8, BM_THREE_BAR_WIDTH * .7, (BM_THREE_BAR_WIDTH /8), 2);
drawrectroundedsub(p, BM_THREE_BAR_WIDTH, BM_THREE_BAR_WIDTH, BM_THREE_BAR_WIDTH * .15, BM_THREE_BAR_WIDTH /2 - BM_THREE_BAR_WIDTH /8, BM_THREE_BAR_WIDTH * .7, (BM_THREE_BAR_WIDTH /8), 2);
drawrectroundedsub(p, BM_THREE_BAR_WIDTH, BM_THREE_BAR_WIDTH, BM_THREE_BAR_WIDTH * .15, BM_THREE_BAR_WIDTH /1 - BM_THREE_BAR_WIDTH *3/8, BM_THREE_BAR_WIDTH * .7, (BM_THREE_BAR_WIDTH /8), 2);
loadalpha(BM_SETTINGS_THREE_BAR, p, BM_THREE_BAR_WIDTH, BM_THREE_BAR_WIDTH);
p += BM_THREE_BAR_WIDTH * BM_THREE_BAR_WIDTH;
/* Contact avatar default bitmap */
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 += 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, 5.5 * SCALE, 5 * SCALE, 1 * SCALE, 3.85 * SCALE, 6.6 * SCALE, 0);
drawlineroundempty(p, BM_FILE_WIDTH, BM_FILE_HEIGHT, 5.5 * SCALE, 5 * SCALE, 1 * SCALE, 2.4 * SCALE, 4.5 * SCALE);
drawsubcircle(p, BM_FILE_WIDTH, BM_FILE_HEIGHT, 6.0 * SCALE, 8.1 * SCALE, 2.5 * SCALE);
drawlineround(p, BM_FILE_WIDTH, BM_FILE_HEIGHT, 7.0 * SCALE, 5.40 * SCALE, 0.5 * SCALE, 2.2 * SCALE, 3.75 * SCALE, 1);
drawlineroundempty(p, BM_FILE_WIDTH, BM_FILE_HEIGHT, 7.25 * SCALE, 5.15 * SCALE, 0.75 * SCALE, 0.75 * SCALE, 1.5 * SCALE);
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, 5.5 * SCALE * 2, 5 * SCALE * 2, 1 * SCALE * 2, 3.85 * SCALE * 2, 6.6 * SCALE * 2, 0);
drawlineroundempty(p, BM_FILE_BIG_WIDTH, BM_FILE_BIG_HEIGHT, 5.5 * SCALE * 2, 5 * SCALE * 2, 1 * SCALE * 2, 2.4 * SCALE * 2, 4.5 * SCALE * 2);
drawsubcircle(p, BM_FILE_BIG_WIDTH, BM_FILE_BIG_HEIGHT, 6.0 * SCALE * 2, 8.1 * SCALE * 2, 2.5 * SCALE * 2);
drawlineround(p, BM_FILE_BIG_WIDTH, BM_FILE_BIG_HEIGHT, 7.0 * SCALE * 2, 5.40 * SCALE * 2, 0.5 * SCALE * 2, 2.2 * SCALE * 2, 3.75 * SCALE * 2, 1);
drawlineroundempty(p, BM_FILE_BIG_WIDTH, BM_FILE_BIG_HEIGHT, 7.25 * SCALE * 2, 5.15 * SCALE * 2, 0.75 * SCALE * 2, 0.75 * SCALE * 2, 1.5 * SCALE * 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, 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 += 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 != 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 += 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, 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;
/* Draw file transfer buttons */
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;
/* the two small chat buttons... */
drawrectroundedex(p, BM_CHAT_BUTTON_WIDTH, BM_CHAT_BUTTON_HEIGHT, 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, 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, 4 * SCALE, 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, 10 * SCALE, 7 * SCALE, 13 * SCALE);
drawtri( p, BM_CHAT_SEND_OVERLAY_WIDTH, BM_CHAT_SEND_OVERLAY_HEIGHT, 15 * SCALE, 9 * SCALE, 6 * SCALE, 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,
1 * SCALE, 1 * SCALE,
BM_CHAT_BUTTON_OVERLAY_WIDTH - (4 * SCALE), BM_CHAT_BUTTON_OVERLAY_HEIGHT - (4 * SCALE),
1 * SCALE);
drawrectroundedneg(p, BM_CHAT_BUTTON_OVERLAY_WIDTH, BM_CHAT_BUTTON_OVERLAY_HEIGHT, /* width, height */
2 * SCALE, 2 * SCALE, /* start x, y */
BM_CHAT_BUTTON_OVERLAY_WIDTH - (6 * SCALE), BM_CHAT_BUTTON_OVERLAY_HEIGHT - (6 * SCALE),
1 * SCALE);
/* 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,
6 * SCALE);
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,
2 * SCALE);
/* 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,
2 * SCALE, 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,
2 * SCALE, 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,
2 * SCALE, 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,
2 * SCALE, 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;
}
// earlier bug stopped us from drawing very long single-segment dashes, because
// SkPathMeasure was skipping very small delta-T values (nearlyzero). This is
// now fixes, so this giant dash should appear.
static void show_giant_dash(SkCanvas* canvas) {
SkPaint paint;
drawline(canvas, 1, 1, paint, SkIntToScalar(20 * 1000));
}
static cell AMX_NATIVE_CALL amx_drawline(AMX *amx, const cell *params)
{
// drawline(x1, y1, x2, y2, color, dots)
drawline(params[1], params[2], params[3], params[4], params[5], params[6]);
return 0;
}
void Display_sticks(void)
{
int8_t i;
int8_t offset;
int8_t temp_aileron, temp_elevator, temp_rudder;
bool CalibrateDone = false;
// Save original settings in case user aborts
temp_aileron = Config.AileronPol;
temp_elevator = Config.ElevatorPol;
temp_rudder = Config.RudderPol;
// Reset to defaults - not ideal, but it works
Config.AileronPol = NORMAL;
Config.ElevatorPol = NORMAL;
Config.RudderPol = NORMAL;
// Until exit button pressed
while((BUTTON1 != 0) && (!CalibrateDone))
{
offset = 0;
// Clear screen buffer
clear_buffer(buffer);
// Draw graphic
for (i = 0; i < 2; i++)
{
drawrect(buffer, 17 + offset, 0, 40, 40, 1); // Box
drawline(buffer, 38 + offset,20, 48 + offset, 3, 1); // Line 1
drawline(buffer, 41 + offset,21, 56 + offset, 6, 1); // Line 2
fillcircle(buffer, 38 + offset, 21, 2, 1); // Centre
fillcircle(buffer, 51 + offset, 5, 4, 1); // End
offset = 52;
}
// Print bottom text and markers
LCD_Display_Text(12, (const unsigned char*)Wingdings, 0, 57); // Left
// If uncalibrated
if (!CalibrateDone)
{
RxGetChannels();
// Display "No RX signal" if no input detected
if(RxChannel[AILERON] == 0)
{
LCD_Display_Text(135,(const unsigned char*)Verdana14,14,43); // "No RX signal"
}
// Sticks have not moved far enough
else if ((RxChannel[AILERON] > 3000) && (RxChannel[AILERON] < 4500))
{
LCD_Display_Text(136,(const unsigned char*)Verdana14,9,43); // "Hold as shown"
}
// Sticks should now be in the right position
// Reverse wrong input channels
else
{
if (RCinputs[AILERON] < 0)
{
Config.AileronPol = REVERSED;
}
if (RCinputs[ELEVATOR] < 0)
{
Config.ElevatorPol = REVERSED;
}
if (RCinputs[RUDDER] < 0)
{
Config.RudderPol = REVERSED;
}
// If all positive - done!
if ((RCinputs[AILERON] > 0) && (RCinputs[ELEVATOR] > 0) && (RCinputs[RUDDER] > 0))
{
CalibrateDone = true;
}
}
}
// Update buffer
write_buffer(buffer,1);
_delay_ms(100);
}
// Save value and return
if (CalibrateDone)
{
LCD_Display_Text(137,(const unsigned char*)Verdana14,40,43); // "Done!"
// Update buffer
write_buffer(buffer,1);
clear_buffer(buffer);
Save_Config_to_EEPROM();
}
else
{
// Restore old settings if failed
Config.AileronPol = temp_aileron;
Config.ElevatorPol = temp_elevator;
Config.RudderPol = temp_rudder;
}
}
void LCDST7565::drawValueMenu()
{
uint8_t strx;
uint8_t strline = GUI_VALSTR_LINE;
uint8_t slen = 0;
char str[19];
clear();/*
drawstring(0,0, cSynthVal.name);
char c[19];
sprintf(c, "%i%s", cSynthVal.value, cSynthVal.unit);*/
// draw title
drawstring( centerString(cSynthVal.name) , 0, cSynthVal.name);
invertRect(0,0,128,8);
// Draw value bar for floats ints
if(cSynthVal.type == VAL_TYPE_INT || cSynthVal.type == VAL_TYPE_FLOAT)
{
int fillw;
if(cSynthVal.type == VAL_TYPE_INT)
{
int val;
if(cSynthVal.min < 0)
{
val = cSynthVal.value - cSynthVal.min;
}
else
{
val = cSynthVal.value;
}
fillw = (GUI_VALBAR_WIDTH * val) / (cSynthVal.max - cSynthVal.min);
}
else
{
fillw = (int) ((GUI_VALBAR_WIDTH * cSynthVal.fvalue) / (cSynthVal.fmax - cSynthVal.fmin));
}
drawrect(GUI_VALBAR_X-1, GUI_VALBAR_Y, GUI_VALBAR_WIDTH+2, GUI_VALBAR_HEIGHT, BLACK);
fillrect(GUI_VALBAR_X, GUI_VALBAR_Y, fillw, GUI_VALBAR_HEIGHT, BLACK);
for(int x = GUI_VALBAR_X + 9; x < GUI_VALBAR_X+GUI_VALBAR_WIDTH-1; x += 10)
{
setpixel(x, GUI_VALBAR_Y-1, BLACK);
setpixel(x, GUI_VALBAR_Y + GUI_VALBAR_HEIGHT, BLACK);
}
//draw left marker
drawline(GUI_VALBAR_X-2, GUI_VALBAR_Y-2, GUI_VALBAR_X-2, GUI_VALBAR_Y + GUI_VALBAR_HEIGHT+1, BLACK);
//draw right marker
drawline(GUI_VALBAR_X + GUI_VALBAR_WIDTH, GUI_VALBAR_Y-2, GUI_VALBAR_X + GUI_VALBAR_WIDTH, GUI_VALBAR_Y + GUI_VALBAR_HEIGHT+1, BLACK);
//draw middle marker
//setpixel(GUI_VALBAR_HALF, GUI_VALBAR_Y-1,BLACK);
setpixel(GUI_VALBAR_HALF+1, GUI_VALBAR_Y-1, BLACK);
setpixel(GUI_VALBAR_HALF+1, GUI_VALBAR_Y + GUI_VALBAR_HEIGHT, BLACK);
strline = GUI_VALBAR_STR_LINE;
}
// draw value string
switch(cSynthVal.type)
{
case VAL_TYPE_MIDI_CHANNEL:
case VAL_TYPE_MIDI_CC:
case VAL_TYPE_INT:
{
sprintf(str, "%i%s", cSynthVal.value + cSynthVal.indexOffset, cSynthVal.unit);
break;
}
case VAL_TYPE_MIDI_NOTE:
{
uint8_t note,octave;
octave = cSynthVal.value / 12;
note = cSynthVal.value % 12;
switch( note )
{
case 1:
case 3:
case 6:
case 8:
case 10:
{
sprintf(str, "%c#%i (%i)", midi_note_names[note], octave, cSynthVal.value);
break;
}
default:
{
sprintf(str, "%c%i (%i)", midi_note_names[note], octave, cSynthVal.value);
break;
}
}
break;
}
case VAL_TYPE_FLOAT:
{
char fmt[9];
char dig[3];
fmt[0] = 0;
strcat(fmt,"%.");
sprintf(dig, "%i", cSynthVal.fdigits);
strcat(fmt, dig);
strcat(fmt, "f%s");
sprintf(str, fmt, cSynthVal.fvalue, cSynthVal.unit);
break;
}
}
//strx = GUI_CHARS_PER_LINE / 2 - (strlen(str) * 5) / 2 + 1;
strx = centerString(str);
drawstring(strx, strline, str);
this->drawMenuButton(BUT_DOWN, 0);
this->drawMenuButton(BUT_UP, 1);
this->drawMenuButton(BUT_BACK, 2);
this->drawMenuButton(BUT_OK, 3);
display();
}
void LCDST7565::drawMenuButton(gui_menubutton_e but, int slotIndex)
{
int x = slotIndex * GUI_BUTTON_WIDTH;
if( pressedButtonIndex == slotIndex )
{
int x2 = x + GUI_BUTTON_WIDTH -1;
this->drawline(x, 52, x, 127, BLACK);
this->drawline(x2, 52, x2, 127, BLACK);
this->drawline(x, 51, x2, 51, BLACK);
}
switch(but)
{
case BUT_OK:
{
this->drawbitmap(x, GUI_BUTTON_Y, button_ok, GUI_BUTTON_WIDTH, GUI_BUTTON_HEIGHT, BLACK);
break;
}
case BUT_BACK:
{
this->drawbitmap(x, GUI_BUTTON_Y, button_back, GUI_BUTTON_WIDTH, GUI_BUTTON_HEIGHT, BLACK);
break;
}
case BUT_MENU:
{
this->drawbitmap(x, GUI_BUTTON_Y, button_menu, GUI_BUTTON_WIDTH, GUI_BUTTON_HEIGHT, BLACK);
break;
}
case BUT_UP:
{
this->drawbitmap(x, GUI_BUTTON_Y, button_arrow_up, GUI_BUTTON_WIDTH, GUI_BUTTON_HEIGHT, BLACK);
break;
}
case BUT_DOWN:
{
this->drawbitmap(x, GUI_BUTTON_Y, button_arrow_down, GUI_BUTTON_WIDTH, GUI_BUTTON_HEIGHT, BLACK);
break;
}
case BUT_LEFT:
{
this->drawbitmap(x, GUI_BUTTON_Y, button_arrow_left, GUI_BUTTON_WIDTH, GUI_BUTTON_HEIGHT, BLACK);
break;
}
case BUT_RIGHT:
{
this->drawbitmap(x, GUI_BUTTON_Y, button_arrow_right, GUI_BUTTON_WIDTH, GUI_BUTTON_HEIGHT, BLACK);
break;
}
case BUT_SET:
{
this->drawbitmap(x, GUI_BUTTON_Y, button_set, GUI_BUTTON_WIDTH, GUI_BUTTON_HEIGHT, BLACK);
break;
}
case BUT_MIDI:
{
this->drawbitmap(x, GUI_BUTTON_Y, button_midi, GUI_BUTTON_WIDTH, GUI_BUTTON_HEIGHT, BLACK);
break;
}
case BUT_MIDI_NOT:
{
this->drawbitmap(x, GUI_BUTTON_Y, button_midi, GUI_BUTTON_WIDTH, GUI_BUTTON_HEIGHT, BLACK);
drawline(x + 3, 53, x + GUI_BUTTON_WIDTH - 4, 62, WHITE);
break;
}
case BUT_NOTE:
{
this->drawbitmap(x, GUI_BUTTON_Y, button_note, GUI_BUTTON_WIDTH, GUI_BUTTON_HEIGHT, BLACK);
break;
}
case BUT_NOTE_NOT:
{
this->drawbitmap(x, GUI_BUTTON_Y, button_note, GUI_BUTTON_WIDTH, GUI_BUTTON_HEIGHT, BLACK);
drawline(x + 3, 53, x + GUI_BUTTON_WIDTH - 4, 62, WHITE);
break;
}
}
}
//========== 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;
}
static void draw_chany_to_chany_edge (int from_node, int from_track,
int to_node, int to_track, short switch_type) {
/* Draws a connection between two y-channel segments. Passing in the track *
* numbers allows this routine to be used for both rr_graph and routing *
* drawing. */
float x1, x2, y1, y2;
int from_x, to_x, from_ylow, to_ylow, from_yhigh, to_yhigh;
from_x = rr_node[from_node].xlow;
from_ylow = rr_node[from_node].ylow;
from_yhigh = rr_node[from_node].yhigh;
to_x = rr_node[to_node].xlow;
to_ylow = rr_node[to_node].ylow;
to_yhigh = rr_node[to_node].yhigh;
/* (x1, y1) point on from_node, (x2, y2) point on to_node. */
x1 = x_clb_left[from_x] + clb_width + 1 + from_track;
x2 = x_clb_left[to_x] + clb_width + 1 + to_track;
if (to_yhigh < from_ylow) { /* From upper to lower */
y1 = y_clb_bottom[from_ylow];
y2 = y_clb_bottom[to_yhigh] + clb_width;
}
else if (to_ylow > from_yhigh) { /* From lower to upper */
y1 = y_clb_bottom[from_yhigh] + clb_width;
y2 = y_clb_bottom[to_ylow];
}
/* Segments overlap in the channel. Figure out best way to draw. Have to *
* make sure the drawing is symmetric in the from rr and to rr so the edges *
* will be drawn on top of each other for bidirectional connections. */
else if (to_ylow < from_ylow) { /* Draw from bottom edge of one to other. */
y1 = y_clb_bottom[from_ylow];
y2 = y_clb_bottom[from_ylow - 1] + clb_width;
}
else if (from_ylow < to_ylow) {
y1 = y_clb_bottom[to_ylow - 1] + clb_width;
y2 = y_clb_bottom[to_ylow];
}
else if (to_yhigh > from_yhigh) { /* Draw from top edge of one to other. */
y1 = y_clb_bottom[from_yhigh] + clb_width;
y2 = y_clb_bottom[from_yhigh + 1];
}
else if (from_yhigh > to_yhigh) {
y1 = y_clb_bottom[to_yhigh + 1];
y2 = y_clb_bottom[to_yhigh] + clb_width;
}
else { /* Complete overlap: start and end both align. Draw outside the sbox */
y1 = y_clb_bottom[from_ylow];
y2 = y_clb_bottom[from_ylow] + clb_width;
}
drawline (x1, y1, x2, y2);
if (draw_rr_toggle == DRAW_ALL_RR)
draw_rr_switch (x1, y1, x2, y2, switch_inf[switch_type].buffered);
}
static void draw_pin_to_chan_edge (int pin_node, int chan_node, int itrack,
boolean mark_conn) {
/* This routine draws an edge from the pin_node to the chan_node (CHANX or *
* CHANY). The track number of the channel is passed in itrack, rather than *
* taken from chan_node's ptc_num to allow this routine to draw global *
* routings (where the track number isn't in the rr_graph). If mark_conn is *
* TRUE, draw a box where the pin connects to the track (useful for drawing *
* the rr graph). */
t_rr_type chan_type;
int pin_x, pin_y, pin_num, chan_xlow, chan_ylow;
float x1, x2, y1, y2;
pin_x = rr_node[pin_node].xlow;
pin_y = rr_node[pin_node].ylow;
pin_num = rr_node[pin_node].ptc_num;
chan_type = rr_node[chan_node].type;
switch (chan_type) {
case CHANX:
chan_ylow = rr_node[chan_node].ylow;
if (pin_y == chan_ylow) {
get_rr_pin_draw_coords (pin_node, TOP, &x1, &y1);
y1 += pin_size; /* Don't overdraw pin number. */
}
else {
get_rr_pin_draw_coords (pin_node, BOTTOM, &x1, &y1);
y1 -= pin_size;
}
y2 = y_clb_bottom[chan_ylow] + clb_width + 1 + itrack;
x2 = x1;
break;
case CHANY:
chan_xlow = rr_node[chan_node].xlow;
if (pin_x == chan_xlow) {
get_rr_pin_draw_coords (pin_node, RIGHT, &x1, &y1);
x1 += pin_size;
}
else {
get_rr_pin_draw_coords (pin_node, LEFT, &x1, &y1);
x1 -= pin_size;
}
x2 = x_clb_left[chan_xlow] + clb_width + 1 + itrack;
y2 = y1;
break;
default:
printf ("Error in draw_pin_to_chan_edge: invalid channel node %d.\n",
chan_node);
exit (1);
}
drawline (x1, y1, x2, y2);
if (mark_conn)
draw_x (x2, y2, 0.7 * pin_size);
}
void
conv(register FILE *fp)
{
register int c, k;
int m, n, n1, m1;
char str[4096], buf[4096];
while ((c = getc(fp)) != EOF) {
switch (c) {
case '\n': /* when input is text */
case ' ':
case 0: /* occasional noise creeps in */
break;
case '{': /* push down current environment */
t_push();
break;
case '}':
t_pop();
break;
case '0': case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9':
/* two motion digits plus a character */
hmot((c-'0')*10 + getc(fp)-'0');
put1(getc(fp));
break;
case 'c': /* single ascii character */
put1(getc(fp));
break;
case 'C':
sget(str, sizeof str, fp);
put1s(str);
break;
case 't': /* straight text */
fgets(buf, sizeof(buf), fp);
t_text(buf);
break;
case 'D': /* draw function */
fgets(buf, sizeof(buf), fp);
switch (buf[0]) {
case 'l': /* draw a line */
sscanf(buf+1, "%d %d", &n, &m);
drawline(n, m, ".");
break;
case 'c': /* circle */
sscanf(buf+1, "%d", &n);
drawcirc(n);
break;
case 'e': /* ellipse */
sscanf(buf+1, "%d %d", &m, &n);
drawellip(m, n);
break;
case 'a': /* arc */
sscanf(buf+1, "%d %d %d %d", &n, &m, &n1, &m1);
drawarc(n, m, n1, m1);
break;
case '~': /* wiggly line */
drawwig(buf+1);
break;
default:
error(FATAL, "unknown drawing function %s\n", buf);
break;
}
break;
case 's':
fscanf(fp, "%d", &n);
if (n == -23) {
float f;
fscanf(fp, "%f", &f);
setsize(f);
} else
setsize(t_size(n));/* ignore fractional sizes */
break;
case 'f':
sget(str, sizeof str, fp);
setfont(t_font(str));
break;
case 'H': /* absolute horizontal motion */
/* fscanf(fp, "%d", &n); */
while ((c = getc(fp)) == ' ')
;
k = 0;
do {
k = 10 * k + c - '0';
} while (isdigit(c = getc(fp)));
ungetc(c, fp);
hgoto(k);
break;
case 'h': /* relative horizontal motion */
/* fscanf(fp, "%d", &n); */
while ((c = getc(fp)) == ' ')
;
k = 0;
do {
k = 10 * k + c - '0';
} while (isdigit(c = getc(fp)));
ungetc(c, fp);
hmot(k);
break;
case 'w': /* word space */
putc(' ', stdout);
break;
case 'V':
fscanf(fp, "%d", &n);
vgoto(n);
break;
case 'v':
fscanf(fp, "%d", &n);
vmot(n);
break;
case 'p': /* new page */
fscanf(fp, "%d", &n);
t_page(n);
break;
case 'n': /* end of line */
while (getc(fp) != '\n')
;
t_newline();
break;
case '#': /* comment */
while (getc(fp) != '\n')
;
break;
case 'x': /* device control */
devcntrl(fp);
break;
default:
error(!FATAL, "unknown input character %o %c\n", c, c);
done();
}
}
}
