_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(); } } }