void event_loop(void)
{
GP_Event ev;
for (;;) {
GP_BackendWaitEvent(win, &ev);
switch (ev.type) {
case GP_EV_KEY:
if (ev.code != GP_EV_KEY_DOWN)
continue;
switch (ev.val.key.key) {
case GP_KEY_SPACE:
if (font)
font_flag = (font_flag + 1) % 5;
else
font_flag = (font_flag + 1) % 4;
redraw_screen();
GP_BackendFlip(win);
break;
case GP_KEY_UP:
tracking++;
redraw_screen();
GP_BackendFlip(win);
break;
case GP_KEY_DOWN:
tracking--;
redraw_screen();
GP_BackendFlip(win);
break;
case GP_KEY_B:
font_h++;
if (font_path) {
GP_FontFaceFree(font);
font = GP_FontFaceLoad(font_path, 0, font_h);
redraw_screen();
GP_BackendFlip(win);
}
break;
case GP_KEY_S:
font_h--;
if (font_path) {
GP_FontFaceFree(font);
font = GP_FontFaceLoad(font_path, 0, font_h);
redraw_screen();
GP_BackendFlip(win);
}
break;
case GP_KEY_ESC:
GP_BackendExit(win);
exit(0);
break;
}
}
}
}
int main(int argc, char *argv[])
{
const char *backend_opts = "X11";
if (argc > 1)
font = GP_FontFaceLoad(argv[1], 0, 20);
print_instructions();
win = GP_BackendInit(backend_opts, "Font Align Test");
if (win == NULL) {
fprintf(stderr, "Failed to initalize backend '%s'\n",
backend_opts);
return 1;
}
black_pixel = GP_RGBToContextPixel(0x00, 0x00, 0x00, win->context);
red_pixel = GP_RGBToContextPixel(0xff, 0x00, 0x00, win->context);
blue_pixel = GP_RGBToContextPixel(0x00, 0x00, 0xff, win->context);
green_pixel = GP_RGBToContextPixel(0x00, 0xff, 0x00, win->context);
yellow_pixel = GP_RGBToContextPixel(0xff, 0xff, 0x00, win->context);
white_pixel = GP_RGBToContextPixel(0xff, 0xff, 0xff, win->context);
darkgray_pixel = GP_RGBToContextPixel(0x7f, 0x7f, 0x7f, win->context);
redraw_screen();
GP_BackendFlip(win);
event_loop();
return 0;
}
int main(void)
{
const char *backend_opts = "X11";
win = GP_BackendInit(backend_opts, "Random Shape Test", stderr);
if (win == NULL) {
fprintf(stderr, "Failed to initalize backend '%s'\n",
backend_opts);
return 1;
}
white = GP_ColorToContextPixel(GP_COL_WHITE, win->context);
black = GP_ColorToContextPixel(GP_COL_BLACK, win->context);
for (;;) {
GP_BackendPoll(win);
event_loop();
usleep(20000);
if (pause_flag)
continue;
redraw_screen();
GP_BackendFlip(win);
}
}
int main(int argc, char *argv[])
{
const char *backend_opts = "X11";
print_instructions();
if (argc > 1) {
font_path = argv[1];
fprintf(stderr, "\nLoading font '%s'\n", argv[1]);
font = GP_FontFaceLoad(argv[1], 0, font_h);
}
win = GP_BackendInit(backend_opts, "Font Test");
if (win == NULL) {
fprintf(stderr, "Failed to initalize backend '%s'\n",
backend_opts);
return 1;
}
white_pixel = GP_RGBToContextPixel(0xff, 0xff, 0xff, win->context);
gray_pixel = GP_RGBToContextPixel(0xbe, 0xbe, 0xbe, win->context);
dark_gray_pixel = GP_RGBToContextPixel(0x7f, 0x7f, 0x7f, win->context);
black_pixel = GP_RGBToContextPixel(0x00, 0x00, 0x00, win->context);
red_pixel = GP_RGBToContextPixel(0xff, 0x00, 0x00, win->context);
blue_pixel = GP_RGBToContextPixel(0x00, 0x00, 0xff, win->context);
redraw_screen();
GP_BackendFlip(win);
event_loop();
return 0;
}
int main(void)
{
GP_Backend *win_1, *win_2;
win_1 = GP_BackendX11Init(NULL, 0, 0, 300, 300, "win 1", 0);
win_2 = GP_BackendX11Init(NULL, 0, 0, 300, 300, "win 2", 0);
if (win_1 == NULL || win_2 == NULL) {
GP_BackendExit(win_1);
GP_BackendExit(win_2);
return 1;
}
/* Update the backend screen */
redraw(win_1->context);
redraw(win_2->context);
GP_BackendFlip(win_1);
GP_BackendFlip(win_2);
for (;;) {
/*
* Wait for backend event.
*
* Either window is fine as they share connection.
*/
GP_Backend *b = win_1 ? win_1 : win_2;
if (b == NULL)
return 0;
GP_BackendWait(b);
if (ev_loop(win_1, "win 1"))
win_1 = NULL;
if (ev_loop(win_2, "win 2"))
win_2 = NULL;
}
GP_BackendExit(win_1);
GP_BackendExit(win_2);
return 0;
}
static void warp_down(int lines)
{
while (lines-- > 0)
if (first_line->next != NULL)
first_line = first_line->next;
redraw_screen();
GP_BackendFlip(backend);
}
static void warp_up(int lines)
{
while (lines-- > 0)
if (first_line->prev != NULL)
first_line = first_line->prev;
redraw_screen();
GP_BackendFlip(backend);
}
static void redraw(GP_Backend *backend)
{
GP_Context *context = backend->context;
/* Now draw some testing patters */
black_pixel = GP_RGBToContextPixel(0x00, 0x00, 0x00, context);
white_pixel = GP_RGBToContextPixel(0xff, 0xff, 0xff, context);
red_pixel = GP_RGBToContextPixel(0xff, 0x00, 0x00, context);
blue_pixel = GP_RGBToContextPixel(0x00, 0x00, 0xff, context);
green_pixel = GP_RGBToContextPixel(0x00, 0xff, 0x00, context);
GP_Fill(context, white_pixel);
unsigned int i, j;
for (i = 0; i < 40; i++) {
GP_HLineXYW(context, 0, i, i, black_pixel);
GP_HLineXYW(context, 1, i + 40, i, black_pixel);
GP_HLineXYW(context, 2, i + 80, i, black_pixel);
GP_HLineXYW(context, 3, i + 120, i, black_pixel);
GP_HLineXYW(context, 4, i + 160, i, black_pixel);
GP_HLineXYW(context, 5, i + 200, i, black_pixel);
GP_HLineXYW(context, 6, i + 240, i, black_pixel);
GP_HLineXYW(context, 7, i + 280, i, black_pixel);
}
for (i = 0; i < 256; i++) {
for (j = 0; j < 256; j++) {
uint8_t val = 1.00 * sqrt(i*i + j*j)/sqrt(2) + 0.5;
GP_Pixel pix = GP_RGBToContextPixel(i, j, val, context);
GP_PutPixel(context, i + 60, j + 10, pix);
}
}
GP_Text(context, NULL, 60, 270, GP_VALIGN_BELOW|GP_ALIGN_RIGHT,
black_pixel, white_pixel, "Lorem Ipsum dolor sit...");
GP_Text(context, NULL, 60, 290, GP_VALIGN_BELOW|GP_ALIGN_RIGHT,
red_pixel, white_pixel, "Lorem Ipsum dolor sit...");
GP_Text(context, NULL, 60, 310, GP_VALIGN_BELOW|GP_ALIGN_RIGHT,
green_pixel, white_pixel, "Lorem Ipsum dolor sit...");
GP_Text(context, NULL, 60, 330, GP_VALIGN_BELOW|GP_ALIGN_RIGHT,
blue_pixel, white_pixel, "Lorem Ipsum dolor sit...");
/* Update the backend screen */
GP_BackendFlip(backend);
}
static void redraw(GP_Backend *self)
{
GP_Context *context = self->context;
GP_Pixel white_pixel, black_pixel;
black_pixel = GP_RGBToContextPixel(0x00, 0x00, 0x00, context);
white_pixel = GP_RGBToContextPixel(0xff, 0xff, 0xff, context);
GP_Fill(context, black_pixel);
GP_Line(context, 0, 0, context->w - 1, context->h - 1, white_pixel);
GP_Line(context, 0, context->h - 1, context->w - 1, 0, white_pixel);
/* Update the backend screen */
GP_BackendFlip(self);
}
static void draw_event(GP_Event *ev)
{
static GP_Size size = 0;
if (ev->type != GP_EV_KEY)
return;
int align = GP_ALIGN_RIGHT|GP_VALIGN_BOTTOM;
GP_TextClear(win, NULL, 20, 20, align, black, size);
size = GP_Print(win, NULL, 20, 20, align,
white, black, "Key=%s",
GP_EventKeyName(ev->val.key.key));
GP_BackendFlip(backend);
}
static int ev_loop(struct GP_Backend *backend, const char *name)
{
GP_Event ev;
if (backend == NULL)
return 0;
while (GP_BackendGetEvent(backend, &ev)) {
printf("-------------------------- %s\n", name);
GP_EventDump(&ev);
switch (ev.type) {
case GP_EV_KEY:
switch (ev.val.val) {
case GP_KEY_ESC:
case GP_KEY_Q:
GP_BackendExit(backend);
return 1;
break;
}
break;
case GP_EV_SYS:
switch (ev.code) {
case GP_EV_SYS_RESIZE:
GP_BackendResizeAck(backend);
redraw(backend->context);
GP_BackendFlip(backend);
break;
case GP_EV_SYS_QUIT:
GP_BackendExit(backend);
return 1;
break;
}
break;
}
printf("-----------------------------\n");
}
return 0;
}
int main(int argc, char *argv[])
{
const char *backend_opts = "X11";
int opt;
while ((opt = getopt(argc, argv, "b:h")) != -1) {
switch (opt) {
case 'b':
backend_opts = optarg;
break;
case 'h':
GP_BackendInit(NULL, NULL, stderr);
return 0;
break;
default:
fprintf(stderr, "Invalid paramter '%c'\n", opt);
return 1;
}
}
backend = GP_BackendInit(backend_opts, "Input Test", stderr);
if (backend == NULL) {
fprintf(stderr, "Failed to initalize backend '%s'\n",
backend_opts);
return 1;
}
win = backend->context;
red = GP_ColorToContextPixel(GP_COL_RED, win);
green = GP_ColorToContextPixel(GP_COL_GREEN, win);
white = GP_ColorToContextPixel(GP_COL_WHITE, win);
black = GP_ColorToContextPixel(GP_COL_BLACK, win);
GP_Fill(win, black);
GP_BackendFlip(backend);
for (;;) {
GP_BackendWait(backend);
event_loop();
}
}
int main(int argc, char *argv[])
{
const char *backend_opts = "X11";
if (argc == 1) {
fprintf(stderr, "No file specified\n");
return 1;
}
if (argc > 2)
font = GP_FontFaceLoad(argv[2], 0, 16);
if (!read_file_head(argv[1]))
return 1;
backend = GP_BackendInit(backend_opts, "File View");
if (backend == NULL) {
fprintf(stderr, "Failed to initalize backend '%s'\n",
backend_opts);
return 1;
}
win = backend->context;
white_pixel = GP_RGBToContextPixel(0xff, 0xff, 0xff, win);
gray_pixel = GP_RGBToContextPixel(0xbe, 0xbe, 0xbe, win);
dark_gray_pixel = GP_RGBToContextPixel(0x7f, 0x7f, 0x7f, win);
black_pixel = GP_RGBToContextPixel(0x00, 0x00, 0x00, win);
red_pixel = GP_RGBToContextPixel(0xff, 0x00, 0x00, win);
blue_pixel = GP_RGBToContextPixel(0x00, 0x00, 0xff, win);
redraw_screen();
GP_BackendFlip(backend);
event_loop();
return 0;
}
static int redraw_help(GP_Backend *backend, unsigned int loff, GP_Coord xoff)
{
GP_Context *c = backend->context;
GP_Pixel black = GP_ColorToContextPixel(GP_COL_BLACK, c);
GP_Pixel white = GP_ColorToContextPixel(GP_COL_WHITE, c);
int i;
GP_Fill(c, black);
for (i = loff; i < keys_help_len; i++) {
GP_Coord h = 2 + (i - loff) * 15;
if (h + 2 >= (GP_Coord)c->h)
goto out;
GP_Print(c, NULL, 20 + 10 * xoff, h, GP_ALIGN_RIGHT|GP_VALIGN_BOTTOM,
white, black, "%s", keys_help[i]);
}
out:
GP_BackendFlip(backend);
return i;
}
int main(int argc, char *argv[])
{
const char *backend_opts = "X11";
print_instructions();
GP_SetDebugLevel(10);
if (argc > 1) {
font_path = argv[1];
fprintf(stderr, "\nLoading font '%s'\n", argv[1]);
font = GP_FontFaceLoad(argv[1], 0, font_h);
}
win = GP_BackendInit(backend_opts, "Font Test", stderr);
if (win == NULL) {
fprintf(stderr, "Failed to initalize backend '%s'\n",
backend_opts);
return 1;
}
white_pixel = GP_ColorToContextPixel(GP_COL_WHITE, win->context);
gray_pixel = GP_ColorToContextPixel(GP_COL_GRAY_LIGHT, win->context);
dark_gray_pixel = GP_ColorToContextPixel(GP_COL_GRAY_DARK, win->context);
black_pixel = GP_ColorToContextPixel(GP_COL_BLACK, win->context);
red_pixel = GP_ColorToContextPixel(GP_COL_RED, win->context);
blue_pixel = GP_ColorToContextPixel(GP_COL_BLUE, win->context);
redraw_screen();
GP_BackendFlip(win);
event_loop();
return 0;
}
int main(int argc, char *argv[])
{
const char *backend_opts = "X11";
int opt;
int pause_flag = 0;
while ((opt = getopt(argc, argv, "b:Ii:Ps:r:")) != -1) {
switch (opt) {
case 'b':
backend_opts = optarg;
break;
default:
fprintf(stderr, "Invalid paramter '%c'\n", opt);
}
}
// GP_SetDebugLevel(10);
signal(SIGINT, sighandler);
signal(SIGSEGV, sighandler);
signal(SIGBUS, sighandler);
signal(SIGABRT, sighandler);
init_backend(backend_opts);
context = backend->context;
black_pixel = GP_ColorToContextPixel(GP_COL_BLACK, context);
white_pixel = GP_ColorToContextPixel(GP_COL_WHITE, context);
GP_Fill(context, black_pixel);
GP_BackendFlip(backend);
struct space *space;
space = space_create(160, 10<<8, 10<<8, (context->w - 10)<<8, (context->h - 10)<<8);
for (;;) {
if (backend->Poll)
GP_BackendPoll(backend);
usleep(1000);
/* Read and parse events */
GP_Event ev;
while (GP_BackendGetEvent(backend, &ev)) {
GP_EventDump(&ev);
switch (ev.type) {
case GP_EV_KEY:
if (ev.code != GP_EV_KEY_DOWN)
continue;
switch (ev.val.key.key) {
case GP_KEY_ESC:
case GP_KEY_ENTER:
case GP_KEY_Q:
GP_BackendExit(backend);
return 0;
break;
case GP_KEY_P:
pause_flag = !pause_flag;
break;
case GP_KEY_G:
space->gay = 1;
break;
case GP_KEY_T:
space->gay = 0;
break;
}
break;
}
}
if (!pause_flag) {
space_time_tick(space, 1);
space_draw_particles(context, space);
GP_BackendFlip(backend);
}
}
GP_BackendExit(backend);
return 0;
}
static void event_loop(void)
{
GP_Event ev;
for (;;) {
GP_BackendWaitEvent(win, &ev);
switch (ev.type) {
case GP_EV_KEY:
if (ev.code != GP_EV_KEY_DOWN)
continue;
switch (ev.val.key.key) {
case GP_KEY_X:
win->context->x_swap = !win->context->x_swap;
break;
case GP_KEY_Y:
win->context->y_swap = !win->context->y_swap;
break;
case GP_KEY_R:
win->context->axes_swap = !win->context->axes_swap;
GP_SWAP(X, Y);
break;
case GP_KEY_SPACE:
font_flag++;
if (font) {
if (font_flag > 5)
font_flag = 0;
} else {
if (font_flag > 4)
font_flag = 0;
}
break;
case GP_KEY_UP:
style.pixel_xspace++;
style.pixel_yspace++;
break;
case GP_KEY_DOWN:
style.pixel_xspace--;
style.pixel_yspace--;
break;
case GP_KEY_RIGHT:
style.pixel_xmul++;
style.pixel_ymul++;
break;
case GP_KEY_LEFT:
style.pixel_xmul--;
style.pixel_ymul--;
break;
case GP_KEY_ESC:
GP_BackendExit(win);
exit(0);
break;
}
break;
case GP_EV_SYS:
switch(ev.code) {
case GP_EV_SYS_QUIT:
GP_BackendExit(win);
exit(0);
break;
case GP_EV_SYS_RESIZE:
GP_BackendResizeAck(win);
X = win->context->w;
Y = win->context->h;
break;
}
break;
}
redraw_screen();
GP_BackendFlip(win);
}
}
static void event_loop(void)
{
for (;;) {
GP_BackendWait(backend);
while (GP_BackendEventsQueued(backend)) {
GP_Event ev;
GP_BackendGetEvent(backend, &ev);
GP_EventDump(&ev);
switch (ev.type) {
case GP_EV_KEY:
draw_event(&ev);
switch (ev.val.key.key) {
case GP_KEY_ESC:
GP_BackendExit(backend);
exit(0);
break;
case GP_BTN_LEFT:
GP_HLineXXY(win, ev.cursor_x - 3,
ev.cursor_x + 3,
ev.cursor_y, red);
GP_VLineXYY(win, ev.cursor_x,
ev.cursor_y - 3,
ev.cursor_y + 3, red);
GP_BackendFlip(backend);
break;
default:
break;
}
break;
case GP_EV_REL:
switch (ev.code) {
static int size = 0;
case GP_EV_REL_POS:
if (GP_EventGetKey(&ev, GP_BTN_LEFT)) {
GP_PutPixel(win, ev.cursor_x,
ev.cursor_y, green);
}
int align = GP_ALIGN_RIGHT|GP_VALIGN_BOTTOM;
GP_TextClear(win, NULL, 20, 40, align,
black, size);
size = GP_Print(win, NULL, 20, 40, align,
white, black, "X=%3u Y=%3u dX=%3i dY=%3i",
ev.cursor_x, ev.cursor_y,
ev.val.rel.rx, ev.val.rel.ry);
GP_BackendFlip(backend);
break;
}
break;
case GP_EV_SYS:
switch (ev.code) {
case GP_EV_SYS_RESIZE:
GP_BackendResizeAck(backend);
break;
case GP_EV_SYS_QUIT:
GP_BackendExit(backend);
exit(0);
break;
}
break;
}
}
}
}
void event_loop(void)
{
GP_Event ev;
for (;;) {
GP_BackendWaitEvent(backend, &ev);
switch (ev.type) {
case GP_EV_KEY:
if (ev.code != GP_EV_KEY_DOWN)
continue;
switch (ev.val.key.key) {
case GP_KEY_SPACE:
if (font)
font_flag = (font_flag + 1) % 6;
else
font_flag = (font_flag + 1) % 5;
redraw_screen();
GP_BackendFlip(backend);
break;
case GP_KEY_RIGHT:
tracking++;
redraw_screen();
GP_BackendFlip(backend);
break;
case GP_KEY_LEFT:
tracking--;
redraw_screen();
GP_BackendFlip(backend);
break;
case GP_KEY_UP:
warp_up(1);
break;
case GP_KEY_DOWN:
warp_down(1);
break;
case GP_KEY_DOT:
space++;
redraw_screen();
GP_BackendFlip(backend);
break;
case GP_KEY_COMMA:
space--;
redraw_screen();
GP_BackendFlip(backend);
break;
case GP_KEY_RIGHT_BRACE:
mul++;
redraw_screen();
GP_BackendFlip(backend);
break;
case GP_KEY_LEFT_BRACE:
if (mul > 0)
mul--;
redraw_screen();
GP_BackendFlip(backend);
break;
case GP_KEY_PAGE_UP:
warp_up(30);
break;
case GP_KEY_PAGE_DOWN:
warp_down(30);
break;
case GP_KEY_ESC:
GP_BackendExit(backend);
exit(0);
break;
}
break;
case GP_EV_SYS:
switch(ev.code) {
case GP_EV_SYS_QUIT:
GP_BackendExit(backend);
exit(0);
break;
case GP_EV_SYS_RESIZE:
GP_BackendResizeAck(backend);
redraw_screen();
GP_BackendFlip(backend);
break;
}
break;
}
}
}
void clear_screen(void)
{
GP_Fill(win->context, black);
GP_BackendFlip(win);
}
