void drawScreen(void) {
char *msg = "ChibiOS/GFX";
font_t font1, font2;
font1 = gdispOpenFont("UI2 Double");
font2 = gdispOpenFont("LargeNumbers");
gdispClear(White);
gdispDrawString(gdispGetWidth()-gdispGetStringWidth(msg, font1)-3, 3, msg, font1, Black);
/* colors */
gdispFillArea(0 * COLOR_SIZE + 3, 3, COLOR_SIZE, COLOR_SIZE, Black); /* Black */
gdispFillArea(1 * COLOR_SIZE + 3, 3, COLOR_SIZE, COLOR_SIZE, Red); /* Red */
gdispFillArea(2 * COLOR_SIZE + 3, 3, COLOR_SIZE, COLOR_SIZE, Yellow); /* Yellow */
gdispFillArea(3 * COLOR_SIZE + 3, 3, COLOR_SIZE, COLOR_SIZE, Green); /* Green */
gdispFillArea(4 * COLOR_SIZE + 3, 3, COLOR_SIZE, COLOR_SIZE, Blue); /* Blue */
gdispDrawBox (5 * COLOR_SIZE + 3, 3, COLOR_SIZE, COLOR_SIZE, Black); /* White */
/* pens */
gdispDrawString(OFFSET * 2, DRAW_PEN(1), "1", font2, Black);
gdispDrawString(OFFSET * 2, DRAW_PEN(2), "2", font2, Black);
gdispDrawString(OFFSET * 2, DRAW_PEN(3), "3", font2, Black);
gdispDrawString(OFFSET * 2, DRAW_PEN(4), "4", font2, Black);
gdispDrawString(OFFSET * 2, DRAW_PEN(5), "5", font2, Black);
gdispCloseFont(font1);
gdispCloseFont(font2);
}
void drawScreen(void) {
char *msg = "uGFX";
font_t font1, font2;
font1 = gdispOpenFont("DejaVuSans24*");
font2 = gdispOpenFont("DejaVuSans12*");
gdispClear(White);
gdispDrawString(gdispGetWidth()-gdispGetStringWidth(msg, font1)-3, 3, msg, font1, Black);
/* colors */
gdispFillArea(0 * COLOR_SIZE + 3, 3, COLOR_SIZE, COLOR_SIZE, Black); /* Black */
gdispFillArea(1 * COLOR_SIZE + 3, 3, COLOR_SIZE, COLOR_SIZE, Red); /* Red */
gdispFillArea(2 * COLOR_SIZE + 3, 3, COLOR_SIZE, COLOR_SIZE, Yellow); /* Yellow */
gdispFillArea(3 * COLOR_SIZE + 3, 3, COLOR_SIZE, COLOR_SIZE, Green); /* Green */
gdispFillArea(4 * COLOR_SIZE + 3, 3, COLOR_SIZE, COLOR_SIZE, Blue); /* Blue */
gdispDrawBox (5 * COLOR_SIZE + 3, 3, COLOR_SIZE, COLOR_SIZE, Black); /* White */
/* pens */
gdispFillStringBox(OFFSET * 2, DRAW_PEN(1), PEN_SIZE, PEN_SIZE, "1", font2, White, Black, justifyCenter);
gdispFillStringBox(OFFSET * 2, DRAW_PEN(2), PEN_SIZE, PEN_SIZE, "2", font2, White, Black, justifyCenter);
gdispFillStringBox(OFFSET * 2, DRAW_PEN(3), PEN_SIZE, PEN_SIZE, "3", font2, White, Black, justifyCenter);
gdispFillStringBox(OFFSET * 2, DRAW_PEN(4), PEN_SIZE, PEN_SIZE, "4", font2, White, Black, justifyCenter);
gdispFillStringBox(OFFSET * 2, DRAW_PEN(5), PEN_SIZE, PEN_SIZE, "5", font2, White, Black, justifyCenter);
gdispCloseFont(font1);
gdispCloseFont(font2);
}
void menuScreen(){
//color_t colorrange[9] = {White, Yellow, Red, Blue, Magenta, SkyBlue, Orange,Lime,Black};
// 0 1 2 3 4 5 6 7 8
// Main menu Background
gdispFillArea(433, 247, 20, 20, tetrisShapeColors[2]);
gdispFillArea(112, 247, 20, 20, tetrisShapeColors[7]);
gdispFillArea(455, 247, 20, 20, tetrisShapeColors[2]);
gdispFillArea(0, 204, 20, 20, tetrisShapeColors[3]);
gdispFillArea(23, 225, 20, 20, tetrisShapeColors[1]);
gdispFillArea(455, 224, 20, 20, tetrisShapeColors[2]);
gdispFillArea(91, 247, 20, 20, tetrisShapeColors[7]);
gdispFillArea(83, 80, 20, 20, tetrisShapeColors[4]);
gdispFillArea(432, 203, 20, 20, tetrisShapeColors[6]);
gdispFillArea(178, 247, 20, 20, tetrisShapeColors[5]);
gdispFillArea(134, 247, 20, 20, tetrisShapeColors[7]);
gdispFillArea(455, 201, 20, 20, tetrisShapeColors[2]);
gdispFillArea(22, 247, 20, 20, tetrisShapeColors[3]);
gdispFillArea(46, 248, 20, 20, tetrisShapeColors[1]);
gdispFillArea(46, 225, 20, 20, tetrisShapeColors[1]);
gdispFillArea(82, 102, 21, 20, tetrisShapeColors[4]);
gdispFillArea(70, 247, 20, 20, tetrisShapeColors[7]);
gdispFillArea(60, 102, 20, 20, tetrisShapeColors[4]);
gdispFillArea(410, 225, 20, 20, tetrisShapeColors[6]);
gdispFillArea(156, 247, 20, 20, tetrisShapeColors[5]);
gdispFillArea(134, 225, 20, 20, tetrisShapeColors[5]);
gdispFillArea(410, 247, 20, 20, tetrisShapeColors[6]);
gdispFillArea(0, 226, 20, 20, tetrisShapeColors[3]);
gdispFillArea(47, 227, 20, 20, tetrisShapeColors[1]);
gdispFillArea(60, 80, 20, 20, tetrisShapeColors[4]);
gdispFillArea(69, 225, 20, 20, tetrisShapeColors[1]);
gdispFillArea(0, 247, 20, 20, tetrisShapeColors[3]);
gdispFillArea(432, 225, 20, 20, tetrisShapeColors[6]);
gdispFillArea(157, 225, 20, 20, tetrisShapeColors[5]);
//Button
gdispFillArea(200,60,80,30,Grey);
gdispFillArea(200+3,60+3,80-6,30-6,Silver);
//text
font16 = gdispOpenFont("DejaVuSans16");
gdispDrawString(225, 66, "Play", font16, tetrisShapeColors[8]);
gdispCloseFont(font16);
//Button
gdispFillArea(200,110,96,30,Grey);
gdispFillArea(200+3,110+3,96-6,30-6,Silver);
//text
font16 = gdispOpenFont("DejaVuSans16");
gdispDrawString(205, 116, "Dark Mode", font16, tetrisShapeColors[8]);
gdispCloseFont(font16);
//Button
gdispFillArea(200,160,126,30,Grey);
gdispFillArea(200+3,160+3,126-6,30-6,Silver);
//text
font16 = gdispOpenFont("DejaVuSans16");
gdispDrawString(205, 166, "Random Mode", font16, tetrisShapeColors[8]);
gdispCloseFont(font16);
}
void printNextBrickWindow() {
char* str;
int i,j;
font16 = gdispOpenFont("DejaVuSans16");
gdispDrawString(360, 100, "Next", font16, tetrisShapeColors[8]);
gdispCloseFont(font16);
//draw block
//For every piece in the next block needs to be changed to nextPiece
for (i = 0; i < nextPiece->size; i++) {
for (j = 0; j < nextPiece->size; j++) {
//If this isn't a blank char then print it
if (nextPiece->graphic[i][j] != ' ') {
// mvprintw(currentPiece->y + i, currentPiece->x + j, "%c", currentPiece->graphic[i][j]);
//padding
gdispFillArea(360+(j*BLOCK_SIZE),130+(i*(BLOCK_SIZE)),BLOCK_SIZE-2, BLOCK_SIZE-2, tetrisShapeColors[0]);
//shape
gdispFillArea(361+(j*BLOCK_SIZE),131+(i*(BLOCK_SIZE)),BLOCK_SIZE-2, BLOCK_SIZE-2, tetrisShapeColors[nextPiece->blockID]);
}
}
}
}
int main(void) {
coord_t width, height;
font_t font1, font2, font3, font4;
const char *msg;
halInit();
chSysInit();
/* Initialize and clear the display */
gdispInit();
gdispClear(Black);
// Get the screen size
width = gdispGetWidth();
height = gdispGetHeight();
// Get the fonts we want to use
font1 = gdispOpenFont("UI2");
font2 = gdispOpenFont("UI2 Double");
font3 = gdispOpenFont("UI2 Narrow");
font4 = gdispOpenFont("LargeNumbers");
// Display large numbers on the right (measuring the string)
msg = "123456";
gdispDrawString(width-gdispGetStringWidth(msg, font4)-3, 3, msg, font4, Green);
// Display the font name under it.
msg = gdispGetFontName(font4);
gdispDrawString(width-gdispGetStringWidth(msg, font1)-3, 20, msg, font1, Green);
// Demonstrate our other fonts
gdispDrawString(10, 10, "Writing with Font 'UI2'", font1, Yellow);
gdispFillString(10, 35, "Writing with Font 'UI2 Double'", font2, Red, White);
gdispDrawStringBox(0, 50, width, 40, "Writing with Font 'UI2 Narrow'", font3, Red, justifyCenter);
gdispFillStringBox(0, 90, width, 40, "Filled Centered", font3, Pink, Gray, justifyCenter);
// Clean up the fonts
gdispCloseFont(font1);
gdispCloseFont(font2);
gdispCloseFont(font3);
gdispCloseFont(font4);
// Wait forever
while(TRUE) {
chThdSleepMilliseconds(500);
}
}
void printScoreWindow() {
char* str;
font16 = gdispOpenFont("DejaVuSans16");
gdispDrawString(360, 20, "Score", font16, tetrisShapeColors[8]);
// gdispDrawLine(365, 40, 380, 20, Purple);
gdispFillArea(365, 35, 35, 1, Purple);
//draw current score
sprintf(str,"%d",Score);
gdispDrawString(378, 42, str, font16, Purple);
gdispCloseFont(font16);
}
int main(void)
{
GEventMouse ev;
#if !JG10_SHOW_SPLASH
font_t font;
#endif
gfxInit();
ginputGetMouse(0);
jg10Init();
#if JG10_SHOW_SPLASH
jg10ShowSplash();
#else
font = gdispOpenFont("DejaVuSans16_aa");
gdispDrawString((gdispGetWidth()/2)-(gdispGetStringWidth("Touch to start!", font)/2), gdispGetHeight()/2, "Touch to start!", font, White);
gdispCloseFont(font);
#endif
while (TRUE) {
ginputGetMouseStatus(0, &ev);
if (ev.buttons & GINPUT_MOUSE_BTN_LEFT) {
while (ev.buttons & GINPUT_MOUSE_BTN_LEFT) { // Wait until release
ginputGetMouseStatus(0, &ev);
}
#if !JG10_SHOW_SPLASH
font = gdispOpenFont("DejaVuSans16");
gdispFillArea((gdispGetWidth()/2)-(gdispGetStringWidth("Touch to start!", font)/2), gdispGetHeight()/2, gdispGetWidth()/2, 17, Black);
gdispCloseFont(font);
#endif
jg10Start();
}
}
}
bool_t ginputCalibrateMouse(uint16_t instance) {
#if !GINPUT_MOUSE_NEED_CALIBRATION
(void) instance;
return FALSE;
#else
const coord_t height = gdispGetHeight();
const coord_t width = gdispGetWidth();
const MousePoint cross[] = {{(width / 4), (height / 4)},
{(width - (width / 4)) , (height / 4)},
{(width - (width / 4)) , (height - (height / 4))},
{(width / 2), (height / 2)}}; /* Check point */
MousePoint points[GINPUT_MOUSE_CALIBRATION_POINTS];
const MousePoint *pc;
MousePoint *pt;
int32_t px, py;
unsigned i, j;
font_t font1, font2;
#if GINPUT_MOUSE_MAX_CALIBRATION_ERROR >= 0
unsigned err;
#endif
if (instance || (MouseConfig.flags & FLG_IN_CAL))
return FALSE;
font1 = gdispOpenFont(GINPUT_MOUSE_CALIBRATION_FONT);
font2 = gdispOpenFont(GINPUT_MOUSE_CALIBRATION_FONT2);
MouseConfig.flags |= FLG_IN_CAL;
gtimerStop(&MouseTimer);
MouseConfig.flags &= ~(FLG_CAL_OK|FLG_CAL_SAVED);
#if GDISP_NEED_CONTROL
gdispSetOrientation(GDISP_ROTATE_0);
#endif
#if GDISP_NEED_CLIP
gdispSetClip(0, 0, width, height);
#endif
#if GINPUT_MOUSE_MAX_CALIBRATION_ERROR >= 0
while(1) {
#endif
gdispClear(Blue);
gdispFillStringBox(0, 5, width, 30, GINPUT_MOUSE_CALIBRATION_TEXT, font1, White, Blue, justifyCenter);
for(i = 0, pt = points, pc = cross; i < GINPUT_MOUSE_CALIBRATION_POINTS; i++, pt++, pc++) {
_tsDrawCross(pc);
do {
/* Wait for the mouse to be pressed */
while(get_raw_reading(&MouseConfig.t), !(MouseConfig.t.buttons & GINPUT_MOUSE_BTN_LEFT))
chThdSleepMilliseconds(20);
/* Average all the samples while the mouse is down */
for(px = py = 0, j = 0;
chThdSleepMilliseconds(20), /* Settling time between readings */
get_raw_reading(&MouseConfig.t),
(MouseConfig.t.buttons & GINPUT_MOUSE_BTN_LEFT);
j++) {
px += MouseConfig.t.x;
py += MouseConfig.t.y;
}
} while(!j);
pt->x = px / j;
pt->y = py / j;
_tsClearCross(pc);
if (i >= 1 && pt->x == (pt-1)->x && pt->y == (pt-1)->y) {
gdispFillStringBox(0, 35, width, 40, GINPUT_MOUSE_CALIBRATION_SAME_TEXT, font2, Red, Yellow, justifyCenter);
chThdSleepMilliseconds(5000);
gdispFillArea(0, 35, width, 40, Blue);
}
}
/* Apply 3 point calibration algorithm */
_tsDo3PointCalibration(cross, points, &MouseConfig.caldata);
/* Verification of correctness of calibration (optional) :
* See if the 4th point (Middle of the screen) coincides with the calibrated
* result. If point is within +/- Squareroot(ERROR) pixel margin, then successful calibration
* Else, start from the beginning.
*/
#if GINPUT_MOUSE_MAX_CALIBRATION_ERROR >= 0
/* Transform the co-ordinates */
MouseConfig.t.x = points[3].x;
MouseConfig.t.y = points[3].y;
_tsTransform(&MouseConfig.t, &MouseConfig.caldata);
/* Calculate the delta */
err = (MouseConfig.t.x - cross[3].x) * (MouseConfig.t.x - cross[3].x) +
(MouseConfig.t.y - cross[3].y) * (MouseConfig.t.y - cross[3].y);
if (err <= GINPUT_MOUSE_MAX_CALIBRATION_ERROR * GINPUT_MOUSE_MAX_CALIBRATION_ERROR)
break;
gdispFillStringBox(0, 35, width, 40, GINPUT_MOUSE_CALIBRATION_ERROR_TEXT, font2, Red, Yellow, justifyCenter);
chThdSleepMilliseconds(5000);
}
#endif
// Restart everything
gdispCloseFont(font1);
gdispCloseFont(font2);
MouseConfig.flags |= FLG_CAL_OK;
MouseConfig.last_buttons = 0;
get_calibrated_reading(&MouseConfig.t);
MouseConfig.flags &= ~FLG_IN_CAL;
if ((MouseConfig.flags & FLG_INIT_DONE))
gtimerStart(&MouseTimer, MousePoll, 0, TRUE, GINPUT_MOUSE_POLL_PERIOD);
// Save the calibration data (if possible)
if (MouseConfig.fnsavecal) {
MouseConfig.fnsavecal(instance, (const uint8_t *)&MouseConfig.caldata, sizeof(MouseConfig.caldata));
MouseConfig.flags |= FLG_CAL_SAVED;
}
return TRUE;
#endif
}
static uint32_t CalibrateMouse(GMouse *m) {
coord_t w, h;
point cross[4]; // The locations of the test points on the display
point points[4]; // The x, y readings obtained from the mouse for each test point
uint32_t err;
#if GDISP_NEED_TEXT
font_t font1, font2;
#endif
#if GDISP_NEED_TEXT
font1 = gdispOpenFont(CALIBRATION_FONT);
if (!font1) font1 = gdispOpenFont("*");
font2 = gdispOpenFont(CALIBRATION_FONT2);
if (!font2) font2 = gdispOpenFont("*");
#endif
err = 0;
w = gdispGGetWidth(m->display);
h = gdispGGetHeight(m->display);
#if GDISP_NEED_CLIP
gdispGSetClip(m->display, 0, 0, w, h);
#endif
// Ensure we get minimaly processed readings for the calibration
m->flags |= GMOUSE_FLG_IN_CAL;
// Set up our calibration locations
if ((gmvmt(m)->d.flags & GMOUSE_VFLG_CAL_EXTREMES)) {
cross[0].x = 0; cross[0].y = 0;
cross[1].x = w-1; cross[1].y = 0;
cross[2].x = w-1; cross[2].y = h-1;
cross[3].x = w/2; cross[3].y = h/2;
} else {
cross[0].x = w/4; cross[0].y = h/4;
cross[1].x = w-w/4; cross[1].y = h/4;
cross[2].x = w-w/4; cross[2].y = h-h/4;
cross[3].x = w/2; cross[3].y = h/2;
}
// Set up the calibration display
gdispGClear(m->display, Blue);
#if GDISP_NEED_TEXT
gdispGFillStringBox(m->display,
0, CALIBRATION_TITLE_Y, w, CALIBRATION_TITLE_HEIGHT,
CALIBRATION_TITLE, font1, CALIBRATION_TITLE_COLOR, CALIBRATION_TITLE_BACKGROUND,
justifyCenter);
#endif
// Calculate the calibration
{
unsigned i, maxpoints;
maxpoints = (gmvmt(m)->d.flags & GMOUSE_VFLG_CAL_TEST) ? 4 : 3;
// Loop through the calibration points
for(i = 0; i < maxpoints; i++) {
int32_t px, py;
unsigned j;
// Draw the current calibration point
CalibrationCrossDraw(m, &cross[i]);
// Get a valid "point pressed" average reading
do {
// Wait for the mouse to be pressed
while(!(m->r.buttons & GINPUT_MOUSE_BTN_LEFT))
gfxSleepMilliseconds(CALIBRATION_POLL_PERIOD);
// Sum samples taken every CALIBRATION_POLL_PERIOD milliseconds while the mouse is down
px = py = j = 0;
while((m->r.buttons & GINPUT_MOUSE_BTN_LEFT)) {
// Limit sampling period to prevent overflow
if (j < CALIBRATION_MAXPRESS_PERIOD/CALIBRATION_POLL_PERIOD) {
px += m->r.x;
py += m->r.y;
j++;
}
gfxSleepMilliseconds(CALIBRATION_POLL_PERIOD);
}
// Ignore presses less than CALIBRATION_MAXPRESS_PERIOD milliseconds
} while(j < CALIBRATION_MINPRESS_PERIOD/CALIBRATION_POLL_PERIOD);
points[i].x = px / j;
points[i].y = py / j;
// Clear the current calibration point
CalibrationCrossClear(m, &cross[i]);
}
}
// Apply 3 point calibration algorithm
CalibrationCalculate(m, cross, points);
/* Verification of correctness of calibration (optional) :
* See if the 4th point (Middle of the screen) coincides with the calibrated
* result. If point is within +/- Squareroot(ERROR) pixel margin, then successful calibration
* Else return the error.
*/
if ((gmvmt(m)->d.flags & GMOUSE_VFLG_CAL_TEST)) {
const GMouseJitter *pj;
// Are we in pen or finger mode
pj = (m->flags & GMOUSE_FLG_FINGERMODE) ? &gmvmt(m)->finger_jitter : &gmvmt(m)->pen_jitter;
// Transform the co-ordinates
CalibrationTransform((GMouseReading *)&points[3], &m->caldata);
// Do we need to rotate the reading to match the display
#if GDISP_NEED_CONTROL
if (!(gmvmt(m)->d.flags & GMOUSE_VFLG_SELFROTATION)) {
coord_t t;
switch(gdispGGetOrientation(m->display)) {
case GDISP_ROTATE_0:
break;
case GDISP_ROTATE_90:
t = points[3].x;
points[3].x = w - 1 - points[3].y;
points[3].y = t;
break;
case GDISP_ROTATE_180:
points[3].x = w - 1 - points[3].x;
points[3].y = h - 1 - points[3].y;
break;
case GDISP_ROTATE_270:
t = points[3].y;
points[3].y = h - 1 - points[3].x;
points[3].x = t;
break;
default:
break;
}
}
#endif
// Is this accurate enough?
err = (points[3].x - cross[3].x) * (points[3].x - cross[3].x) + (points[3].y - cross[3].y) * (points[3].y - cross[3].y);
if (err > (uint32_t)pj->calibrate * (uint32_t)pj->calibrate) {
#if GDISP_NEED_TEXT
// No - Display error and return
gdispGFillStringBox(m->display,
0, CALIBRATION_ERROR_Y, w, CALIBRATION_ERROR_HEIGHT,
CALIBRATION_ERROR_TEXT, font2, CALIBRATION_ERROR_COLOR, CALIBRATION_ERROR_BACKGROUND,
justifyCenter);
gfxSleepMilliseconds(CALIBRATION_ERROR_DELAY);
#endif
} else
err = 0;
}
// We are done calibrating
#if GDISP_NEED_TEXT
gdispCloseFont(font1);
gdispCloseFont(font2);
#endif
m->flags &= ~GMOUSE_FLG_IN_CAL;
m->flags |= GMOUSE_FLG_CLIP;
// Save the calibration data (if possible)
if (!err) {
m->flags |= GMOUSE_FLG_CALIBRATE;
#if GINPUT_TOUCH_USER_CALIBRATION_SAVE
SaveMouseCalibration(gdriverGetDriverInstanceNumber((GDriver *)m), &m->caldata, sizeof(GMouseCalibration));
#endif
if (gmvmt(m)->calsave)
gmvmt(m)->calsave(m, &m->caldata, sizeof(GMouseCalibration));
}
// Force an initial reading
m->r.buttons = 0;
GetMouseReading(m);
// Clear the screen using the GWIN default background color
#if GFX_USE_GWIN
gdispGClear(m->display, gwinGetDefaultBgColor());
#else
gdispGClear(m->display, GDISP_STARTUP_COLOR);
#endif
return err;
}
static msg_t notepadThread(void *param) {
GEventMouse *pem;
GEventGWinButton *peb;
GHandle ghc;
(void)param;
/* Get the display dimensions */
swidth = gdispGetWidth();
sheight = gdispGetHeight();
font = gdispOpenFont("UI2");
/* Initialize the mouse */
geventListenerInit(&gl);
ginputGetMouse(0);
initButtons();
/* Configure the GIF decoder with the toolbar Icon images */
gdispImageSetMemoryReader(&toolbarImageFilmstrip, toolbarIcons);
gdispImageOpen(&toolbarImageFilmstrip);
/* Set clip to the entire screen */
gdispSetClip(0, 0, swidth, sheight);
/* Clear the screen with the window background
* Also, draw the title bars */
gdispClear(nCurColorScheme.winBgColor);
gdispDrawBox(0, 0, swidth, sheight, nCurColorScheme.titleBarColor);
gdispFillArea(0, 0, swidth, NPAD_TITLEBAR_HEIGHT, nCurColorScheme.titleBarColor);
gdispDrawStringBox(NPAD_TITLETEXT_START_X,
NPAD_TITLETEXT_START_Y,
swidth,
NPAD_TITLEBAR_HEIGHT,
NPAD_TITLETEXT_STR,
font,
nCurColorScheme.titleTextColor,
justifyLeft);
/* Create the drawing window, draw its border */
gdispDrawBox(NPAD_DRAWING_AREA_START_X - 1,
NPAD_DRAWING_AREA_START_Y - 1,
NPAD_DRAWING_AREA_WIDTH + 2,
NPAD_DRAWING_AREA_HEIGHT + 2,
nCurColorScheme.drawingWinBorder);
nDrawingArea = gwinCreateWindow(NULL,
NPAD_DRAWING_AREA_START_X,
NPAD_DRAWING_AREA_START_Y,
NPAD_DRAWING_AREA_WIDTH,
NPAD_DRAWING_AREA_HEIGHT);
/* Create the bottom status bar console */
ghc = gwinCreateConsole(NULL,
NPAD_STATUSBAR_START_X,
NPAD_STATUSBAR_START_Y,
NPAD_STATUSBAR_WIDTH,
NPAD_STATUSBAR_HEIGHT,
font);
gdispImageDraw(&toolbarImageFilmstrip,
NPAD_STATUSBAR_ICON_START_X,
NPAD_STATUSBAR_ICON_START_Y,
NPAD_ICON_WIDTH,
NPAD_ICON_HEIGHT,
NPAD_ICON_START(12),
0);
gwinSetBgColor(ghc, nCurColorScheme.winBgColor);
gwinSetColor(ghc, Black);
gstatusConsole = gwinGetConsoleStream(ghc);
/* draw the buttons */
gwinSetColor(nDrawingArea, Black);
gwinSetBgColor(nDrawingArea, White);
gwinClear(nDrawingArea);
gwinClear(ghc);
drawButtons();
drawVButtons();
chprintf(gstatusConsole, "Welcome to ChibiOS/GFX Notepad demo.");
ncoreSpawnDrawThread(nDrawingArea, gstatusConsole);
while(TRUE) {
pem = (GEventMouse *) geventEventWait(&gl, TIME_INFINITE);
/* button pressed... */
if (pem->type == GEVENT_GWIN_BUTTON) {
peb = (GEventGWinButton *)pem;
if (peb->button == H(btnNew)) {
// Reset all the settings
selColorIndex = 0;
selPenWidth = 0;
ncoreSetMode(NCORE_MODE_DRAW);
gwinSetColor(nDrawingArea, Black);
gwinSetBgColor(nDrawingArea, White);
// Refresh the buttons
drawButtons();
drawVButtons();
gwinClear(nDrawingArea);
chprintf(gstatusConsole, "\nScreen Cleared.");
}
else if (peb->button == H(btnOpen)) {
chprintf(gstatusConsole, "\nFile Open not implemented.");
}
else if (peb->button == H(btnSave)) {
chprintf(gstatusConsole, "\nFile Save not implemented.");
}
else if (peb->button == H(btnPencil)) {
ncoreSetMode(NCORE_MODE_DRAW);
drawVButtons();
chprintf(gstatusConsole, "\nPencil Tool Selected.");
}
else if (peb->button == H(btnEraser)) {
ncoreSetMode(NCORE_MODE_ERASE);
drawVButtons();
chprintf(gstatusConsole, "\nEraser Tool Selected.");
}
else if (peb->button == H(btnFill)) {
ncoreSetMode(NCORE_MODE_FILL);
drawVButtons();
chprintf(gstatusConsole, "\nFill Tool Selected.");
}
else if (peb->button == H(btnClose)) {
break;
}
}
}
gwinDestroyWindow(ghc);
// No need to destroy the buttons as they are statically allocated
gdispCloseFont(font);
ncoreTerminateDrawThread();
gdispImageClose(&toolbarImageFilmstrip);
return 0;
}
static DECLARE_THREAD_FUNCTION(visualizerThread, arg) {
(void)arg;
GListener event_listener;
geventListenerInit(&event_listener);
geventAttachSource(&event_listener, (GSourceHandle)¤t_status, 0);
visualizer_keyboard_status_t initial_status = {
.default_layer = 0xFFFFFFFF,
.layer = 0xFFFFFFFF,
.mods = 0xFF,
.leds = 0xFFFFFFFF,
.suspended = false,
};
visualizer_state_t state = {
.status = initial_status,
.current_lcd_color = 0,
#ifdef LCD_ENABLE
.font_fixed5x8 = gdispOpenFont("fixed_5x8"),
.font_dejavusansbold12 = gdispOpenFont("DejaVuSansBold12")
#endif
};
initialize_user_visualizer(&state);
state.prev_lcd_color = state.current_lcd_color;
#ifdef LCD_BACKLIGHT_ENABLE
lcd_backlight_color(
LCD_HUE(state.current_lcd_color),
LCD_SAT(state.current_lcd_color),
LCD_INT(state.current_lcd_color));
#endif
systemticks_t sleep_time = TIME_INFINITE;
systemticks_t current_time = gfxSystemTicks();
while(true) {
systemticks_t new_time = gfxSystemTicks();
systemticks_t delta = new_time - current_time;
current_time = new_time;
bool enabled = visualizer_enabled;
if (!same_status(&state.status, ¤t_status)) {
if (visualizer_enabled) {
if (current_status.suspended) {
stop_all_keyframe_animations();
visualizer_enabled = false;
state.status = current_status;
user_visualizer_suspend(&state);
}
else {
state.status = current_status;
update_user_visualizer_state(&state);
}
state.prev_lcd_color = state.current_lcd_color;
}
}
if (!enabled && state.status.suspended && current_status.suspended == false) {
// Setting the status to the initial status will force an update
// when the visualizer is enabled again
state.status = initial_status;
state.status.suspended = false;
stop_all_keyframe_animations();
user_visualizer_resume(&state);
state.prev_lcd_color = state.current_lcd_color;
}
sleep_time = TIME_INFINITE;
for (int i=0;i<MAX_SIMULTANEOUS_ANIMATIONS;i++) {
if (animations[i]) {
update_keyframe_animation(animations[i], &state, delta, &sleep_time);
}
}
#ifdef LED_ENABLE
gdispGFlush(LED_DISPLAY);
#endif
#ifdef EMULATOR
draw_emulator();
#endif
// The animation can enable the visualizer
// And we might need to update the state when that happens
// so don't sleep
if (enabled != visualizer_enabled) {
sleep_time = 0;
}
systemticks_t after_update = gfxSystemTicks();
unsigned update_delta = after_update - current_time;
if (sleep_time != TIME_INFINITE) {
if (sleep_time > update_delta) {
sleep_time -= update_delta;
}
else {
sleep_time = 0;
}
}
dprintf("Update took %d, last delta %d, sleep_time %d\n", update_delta, delta, sleep_time);
#ifdef PROTOCOL_CHIBIOS
// The gEventWait function really takes milliseconds, even if the documentation says ticks.
// Unfortunately there's no generic ugfx conversion from system time to milliseconds,
// so let's do it in a platform dependent way.
// On windows the system ticks is the same as milliseconds anyway
if (sleep_time != TIME_INFINITE) {
sleep_time = ST2MS(sleep_time);
}
#endif
geventEventWait(&event_listener, sleep_time);
}
#ifdef LCD_ENABLE
gdispCloseFont(state.font_fixed5x8);
gdispCloseFont(state.font_dejavusansbold12);
#endif
return 0;
}
void visualizer_init(void) {
gfxInit();
#ifdef LCD_BACKLIGHT_ENABLE
lcd_backlight_init();
#endif
#ifdef SERIAL_LINK_ENABLE
add_remote_objects(remote_objects, sizeof(remote_objects) / sizeof(remote_object_t*) );
#endif
#ifdef LCD_ENABLE
LCD_DISPLAY = get_lcd_display();
#endif
#ifdef LED_ENABLE
LED_DISPLAY = get_led_display();
#endif
// We are using a low priority thread, the idea is to have it run only
// when the main thread is sleeping during the matrix scanning
gfxThreadCreate(visualizerThreadStack, sizeof(visualizerThreadStack),
VISUALIZER_THREAD_PRIORITY, visualizerThread, NULL);
}
void update_status(bool changed) {
if (changed) {
GSourceListener* listener = geventGetSourceListener((GSourceHandle)¤t_status, NULL);
if (listener) {
geventSendEvent(listener);
}
}
#ifdef SERIAL_LINK_ENABLE
static systime_t last_update = 0;
systime_t current_update = chVTGetSystemTimeX();
systime_t delta = current_update - last_update;
if (changed || delta > MS2ST(10)) {
last_update = current_update;
visualizer_keyboard_status_t* r = begin_write_current_status();
*r = current_status;
end_write_current_status();
}
#endif
}
uint8_t visualizer_get_mods() {
uint8_t mods = get_mods();
#ifndef NO_ACTION_ONESHOT
if (!has_oneshot_mods_timed_out()) {
mods |= get_oneshot_mods();
}
#endif
return mods;
}
void visualizer_update(uint32_t default_state, uint32_t state, uint8_t mods, uint32_t leds) {
// Note that there's a small race condition here, the thread could read
// a state where one of these are set but not the other. But this should
// not really matter as it will be fixed during the next loop step.
// Alternatively a mutex could be used instead of the volatile variables
bool changed = false;
#ifdef SERIAL_LINK_ENABLE
if (is_serial_link_connected ()) {
visualizer_keyboard_status_t* new_status = read_current_status();
if (new_status) {
if (!same_status(¤t_status, new_status)) {
changed = true;
current_status = *new_status;
}
}
}
else {
#else
{
#endif
visualizer_keyboard_status_t new_status = {
.layer = state,
.default_layer = default_state,
.mods = mods,
.leds = leds,
.suspended = current_status.suspended,
};
if (!same_status(¤t_status, &new_status)) {
changed = true;
current_status = new_status;
}
}
update_status(changed);
}
void visualizer_suspend(void) {
current_status.suspended = true;
update_status(true);
}
void visualizer_resume(void) {
current_status.suspended = false;
update_status(true);
}
