// creates a new MandelPod window
void new_mandel_window(void)
{
// get the graphics context
mandel_gc = pz_get_gc(1);
// create the main window
mandel_wid = pz_new_window (0, 21,
screen_info.cols, screen_info.rows - (HEADER_TOPLINE+1),
draw_header, handle_event);
#ifdef MANDELPOD_STATUS
// create the status window
status_wid = pz_new_window (22, 4, 12, 12, draw_idle_status, handle_event);
#endif
// get screen info
GrGetWindowInfo(mandel_wid, &wi);
// select the event types
GrSelectEvents (mandel_wid, GR_EVENT_MASK_EXPOSURE | GR_EVENT_MASK_KEY_DOWN | GR_EVENT_MASK_KEY_UP | GR_EVENT_MASK_TIMER);
// display the window
GrMapWindow (mandel_wid);
#ifdef MANDELPOD_STATUS
GrMapWindow (status_wid);
#endif
// create the timer for the busy status animation
mandel_timer_id = GrCreateTimer (mandel_wid, 250);
// start main app
init_values();
create_status();
draw_header();
calculate_mandel();
}
void new_invaders_window()
{
invaders_gc = pz_get_gc(1);
GrSetGCUseBackground(invaders_gc, GR_TRUE);
GrSetGCBackground(invaders_gc, GR_RGB(255,255,255));
GrSetGCForeground(invaders_gc, GR_RGB(0,0,0));
invaders_score_pix = GrNewPixmap(screen_info.cols, 13, 0);
invaders_wid = pz_new_window(0,
HEADER_TOPLINE + 1,
screen_info.cols,
screen_info.rows - HEADER_TOPLINE - 1,
invaders_do_draw,
invaders_handle_event);
GrSelectEvents(invaders_wid, GR_EVENT_MASK_TIMER |
GR_EVENT_MASK_EXPOSURE | GR_EVENT_MASK_KEY_UP |
GR_EVENT_MASK_KEY_DOWN);
score = 0;
level = 0;
aliens_rows = (screen_info.rows - 40) / 20;
game_status = GAME_STATUS_PLAY;
invaders_create_board(level);
invaders_timer_id = GrCreateTimer(invaders_wid, 50);
GrMapWindow(invaders_wid);
draw_first();
}
/* initialize the window */
void new_lights_window(void)
{
/* Init randomizer */
srand(time(NULL));
lights_gc = pz_get_gc (1);
GrSetGCUseBackground(lights_gc, GR_FALSE);
GrSetGCForeground(lights_gc, GR_RGB(0,0,0));
lights_height = (lights_screen_info.rows - (HEADER_TOPLINE + 1));
lights_wid = pz_new_window( 0, HEADER_TOPLINE + 1,
screen_info.cols, lights_height,
lights_do_draw, lights_handle_event );
lights_bufwid = GrNewPixmap( lights_screen_info.cols,
lights_height, NULL );
GrSelectEvents( lights_wid, GR_EVENT_MASK_TIMER
| GR_EVENT_MASK_EXPOSURE
| GR_EVENT_MASK_KEY_UP
| GR_EVENT_MASK_KEY_DOWN );
lights_timer = GrCreateTimer( lights_wid, 300 );
GrMapWindow( lights_wid );
/* intialize game state */
lights_new_game();
}
void new_message_common_window(char *message)
{
GR_SIZE width, height, base;
int i, maxwidth;
if (msg_wid) {
msg_destroy_msg();
}
msg_gc = pz_get_gc(1);
GrSetGCUseBackground(msg_gc, GR_FALSE);
GrSetGCForeground(msg_gc, appearance_get_color( CS_MESSAGEFG ));
msg_build_msg(message);
maxwidth = 0;
for(i=linenum; i; i--) {
GrGetGCTextSize(msg_gc, msglines[i-1], -1, GR_TFASCII, &width,
&height, &base);
if(width > maxwidth)
maxwidth = width;
}
msg_wid = pz_new_window((screen_info.cols - (maxwidth + 10)) >> 1,
(screen_info.rows - (((height + 3) * linenum) + 10)) >> 1,
maxwidth + 10, ((height + 3) * linenum) + 10,
msg_do_draw, msg_do_keystroke);
GrSelectEvents(msg_wid, GR_EVENT_MASK_EXPOSURE| GR_EVENT_MASK_KEY_UP|
GR_EVENT_MASK_KEY_DOWN| GR_EVENT_MASK_TIMER);
GrMapWindow(msg_wid);
/* window will auto-close after 6 seconds */
msg_timer = GrCreateTimer(msg_wid, 6000);
}
void new_cube_window( void )
{
if (screen_info.cols==220) {
photo = 1;
if (!z_off) z_off = 400;
} else if (screen_info.cols==138) {
if (!z_off) z_off = 800;
} else {
if (!z_off) z_off = 600;
}
cube_gc = pz_get_gc(1);
GrSetGCUseBackground(cube_gc, GR_FALSE);
GrSetGCForeground(cube_gc, BLACK);
cube_wid = pz_new_window(0, HEADER_TOPLINE + 1,
screen_info.cols, screen_info.rows - (HEADER_TOPLINE + 1),
cube_do_draw, cube_handle_event);
GrSelectEvents( cube_wid, GR_EVENT_MASK_TIMER|
GR_EVENT_MASK_EXPOSURE|GR_EVENT_MASK_KEY_UP|GR_EVENT_MASK_KEY_DOWN);
cube_timer = GrCreateTimer( cube_wid, 100 );
GrMapWindow( cube_wid );
x_off = screen_info.cols/2;
y_off = (screen_info.rows - (HEADER_TOPLINE + 1))/2;
temp_pixmap = GrNewPixmap(screen_info.cols,
(screen_info.rows - (HEADER_TOPLINE + 1)),
NULL);
cube_init();
}
void new_ipobble_window()
{
ipobble_gc = pz_get_gc(1);
GrSetGCUseBackground(ipobble_gc, GR_TRUE);
GrSetGCForeground(ipobble_gc, BLACK);
GrSetGCBackground(ipobble_gc, WHITE);
ipobble_wid = pz_new_window(0, HEADER_TOPLINE + 1,
screen_info.cols,
screen_info.rows - HEADER_TOPLINE - 1,
ipobble_do_draw, ipobble_handle_event);
GrSelectEvents(ipobble_wid, GR_EVENT_MASK_TIMER |
GR_EVENT_MASK_EXPOSURE | GR_EVENT_MASK_KEY_UP |
GR_EVENT_MASK_KEY_DOWN);
if( screen_info.bpp > 2) {
ipodc=1;
}
score = 0;
level = 0;
game_status = GAME_STATUS_PLAY;
ipobble_create_board(level);
ipobble_timer_id = GrCreateTimer(ipobble_wid, DELTA_TIME);
GrMapWindow(ipobble_wid);
draw_first();
}
void start_blink_timer(nxeyes_state *state)
{
int time;
if(state->eyes_closed) time = BLINK_CLOSED_TIME;
else time = (rand() % (BLINK_MAX_OPEN_TIME - BLINK_MIN_OPEN_TIME)) +
BLINK_MIN_OPEN_TIME;
state->tid = GrCreateTimer(state->wid, time); /*, GR_FALSE); */
}
static void
GrCreateTimerWrapper(void *r)
{
nxCreateTimerReq *req = r;
GR_TIMER_ID timerid;
timerid = GrCreateTimer(req->wid, req->period);
GsWriteType(current_fd, GrNumCreateTimer);
GsWrite(current_fd, &timerid, sizeof (timerid));
}
// Resets the game.
static void reset()
{
if (running == 1)
GrDestroyTimer( timer_id );
reset_chasm_queue(&head, &middle, &tail);
if(new_chasm_queue((wi.width - chasmWidth) / 2, wi.height / 2, &head, &middle, &tail) == -1)
{
pz_error("Error making queue.");
pz_close_window (tunnel_wid);
return;
}
score = 0;
running = 0;
ball.radius = ballRadius;
ball.x = wi.width / 2;
timer_id = GrCreateTimer(tunnel_wid, timerSpeed);
advance_and_check();
}
void
mvpw_set_timer(mvp_widget_t *widget, void (*callback)(mvp_widget_t*),
uint32_t timeout)
{
if (widget->callback_timer) {
widget->event_mask &= ~GR_EVENT_MASK_TIMER;
GrSelectEvents(widget->wid, widget->event_mask);
GrDestroyTimer(widget->tid);
}
widget->callback_timer = callback;
if (callback) {
widget->event_mask |= GR_EVENT_MASK_TIMER;
GrSelectEvents(widget->wid, widget->event_mask);
widget->tid = GrCreateTimer(widget->wid, timeout);
}
}
/* checks the selected item for timer worthy features */
void menu_handle_timer(menu_st *menulist, int force)
{
item_st *item;
item = &menulist->items[menulist->sel];
/* is a submenu item or is wider than the screen */
if((SUB_MENU_HEADER & item->op || item->text_width > menulist->w -
(8 * 2) || ARROW_MENU & item->op || EXECUTE_MENU &
item->op || CFLASH & item->op) && !force) {
if(!menulist->timer)
menulist->timer =
GrCreateTimer(menulist->menu_wid, 150);
menulist->timer_step = 0;
}
/* the timer needs destroying */
else if(menulist->timer) {
GrDestroyTimer(menulist->timer);
menulist->timer = 0;
menulist->timer_step = 0;
}
}
void new_poddraw_window( void )
{
poddraw_alloc_buffer();
poddraw_gc = pz_get_gc(1);
GrSetGCUseBackground(poddraw_gc, GR_FALSE);
GrSetGCForeground(poddraw_gc, BLACK);
poddraw_wid = pz_new_window(0, HEADER_TOPLINE + 1,
screen_info.cols, screen_info.rows - (HEADER_TOPLINE + 1),
poddraw_do_draw, poddraw_handle_event);
GrSelectEvents( poddraw_wid, GR_EVENT_MASK_TIMER|
GR_EVENT_MASK_EXPOSURE|GR_EVENT_MASK_KEY_UP|GR_EVENT_MASK_KEY_DOWN);
poddraw_timer = GrCreateTimer( poddraw_wid, 100 );
GrMapWindow( poddraw_wid );
poddraw_color = 0;
poddraw_x = screen_info.cols/2;
poddraw_y = (screen_info.rows - (HEADER_TOPLINE + 1))/2;
poddraw_cls();
}
void new_keyman_window( void )
{
keyman_gc = GrNewGC();
GrSetGCUseBackground(keyman_gc, GR_FALSE);
GrSetGCForeground(keyman_gc, WHITE);
GrGetScreenInfo(&screen_info);
yomipict_pixmap=GrNewPixmap(384,128,NULL);
mainmenu_pixmap=GrNewPixmap(160,128,NULL);
shu_pixmap=GrNewPixmap(16,16,NULL);
dialogall_pixmap=GrNewPixmap(96,80,NULL);
dialog_pixmap=GrNewPixmap(96,80,NULL);
keyman_wid = pz_new_window(0, 0,
screen_info.cols, screen_info.rows,
keyman_do_draw, keyman_handle_event);
if (!(kmimage_id=GrLoadImageFromFile(pathimage,0))){
GAMEN=NODATA;
}
else {
GAMEN=MENU;
GrDrawImageToFit(yomipict_pixmap,keyman_gc,0,0,384,128,kmimage_id);
makedialog();
}
GrSelectEvents( keyman_wid, GR_EVENT_MASK_TIMER|
GR_EVENT_MASK_EXPOSURE|GR_EVENT_MASK_KEY_UP|GR_EVENT_MASK_KEY_DOWN);
keyman_timer = GrCreateTimer( keyman_wid, 90 );
GrMapWindow( keyman_wid );
pz_draw_header( "KeyMan" );
}
void handle_screensaver_event(lstate *state)
{
GR_EVENT_SCREENSAVER *event = &state->event.screensaver;
if(event->activate != GR_TRUE) {
if(state->ssrotatetimer > 0)
GrDestroyTimer(state->ssrotatetimer);
return;
}
if(!state->ssitems) {
GrError("Got screensaver activate event with no "
"screensavers defined\n");
return;
}
activate_screensaver(state);
if(state->rotatess) {
state->ssrotatetimer = GrCreateTimer(state->main_window,
state->rotatess * 1000 /*, GR_TRUE*/);
} else state->ssrotatetimer = -1;
}
void new_credits_window( void )
{
credits_gc = pz_get_gc(1);
GrSetGCUseBackground(credits_gc, GR_FALSE);
GrSetGCBackground(credits_gc, BLACK);
credits_wid = pz_new_window(0, 0/*HEADER_TOPLINE + 1*/, screen_info.cols,
screen_info.rows /*- (HEADER_TOPLINE + 1)*/,
credits_do_draw, credits_handle_event);
GrSelectEvents( credits_wid, GR_EVENT_MASK_TIMER|
GR_EVENT_MASK_EXPOSURE|GR_EVENT_MASK_KEY_UP|GR_EVENT_MASK_KEY_DOWN);
credits_init();
credits_newtext();
credits_timer = GrCreateTimer(credits_wid, 20);
GrMapWindow(credits_wid);
credits_clear_screen(0);
}
void new_chopper_window(void)
{
int i,g;
i=0;
chopGC = pz_get_gc(1); /* Get the graphics context */
GrGetScreenInfo(&screen_info); /* Get screen info */
/* Open the window: */
chopWindow = pz_new_window (0,
21,
screen_info.cols,
screen_info.rows - 21, /* Height of screen - header */
chopDrawScene,
chopHandleEvent);
chopBuffer = GrNewPixmap(screen_info.cols,
(screen_info.rows - (HEADER_TOPLINE + 1)),
NULL);
iScreenX = screen_info.cols;
iScreenY = screen_info.rows - 21;
/* Select the types of events you need for your window: */
GrSelectEvents (chopWindow,
GR_EVENT_MASK_KEY_DOWN
| GR_EVENT_MASK_TIMER | GR_EVENT_MASK_KEY_UP);
/* Display the window: */
GrMapWindow (chopWindow);
/* Create the timer used for animating your application: */
chopTimer = GrCreateTimer (chopWindow,
75); /* Timer interval, millisecs */
/*chopDrawScene();*/
iRotorOffset = 0;
//chopAddBlock(100,100,20,20);
iPlayerPosX = 60;
iPlayerPosY = iScreenY * 0.2;
iLastBlockPlacedPosX = 0;
iGravityTimerCountdown = 2;
iPlayerAlive = 1;
chopCounter = 0;
while(i < NUMBER_OF_BLOCKS)
{
mBlocks[i].bIsActive = 0;
i++;
}
g = iScreenY - 10;
chopClearTerrain(&mGround);
i=0;
while(i < MAX_TERRAIN_NODES) //we could add less, probably.
{
chopAddTerrainNode(&mGround,i * 30,g - iR(0,20));
i++;
}
if(chopUpdateTerrainRecycling(&mGround)==1)
chopCopyTerrain(&mGround,&mRoof,0,-( iScreenY * 0.75)); //mirror the sky if we've changed the ground
iLevelMode = iR(1,2);
iPlayerSpeedX = 4;
iPlayerSpeedY = 0;
if(iLevelMode == LEVEL_MODE_NORMAL)
iPlayerSpeedX*=2; //make it a bit more exciting, cause it's easy terrain...
//printf("level mode: %d",iLevelMode);
bWaitingToStart = 1;
}
static int browser_do_keystroke(GR_EVENT * event)
{
int ret = 0;
switch(event->type) {
case GR_EVENT_TYPE_TIMER:
if(((GR_EVENT_TIMER *)event)->tid == browser_key_timer) {
GrDestroyTimer(browser_key_timer);
browser_key_timer = 0;
menu_handle_timer(browser_menu, 1);
browser_action(browser_menu->items[browser_menu->sel].orig_pos);
browser_do_draw();
}
else
menu_draw_timer(browser_menu);
break;
case GR_EVENT_TYPE_KEY_DOWN:
switch (event->keystroke.ch) {
case '\r':
case '\n':
if(browser_menu->parent == NULL)
browser_key_timer = GrCreateTimer(browser_wid,
500);
else {
menu_handle_timer(browser_menu, 1);
browser_menu = menu_handle_item(browser_menu,
browser_menu->sel);
if(browser_menu_overlay) {
browser_menu = browser_menu_overlay;
browser_menu_overlay = 0;
}
browser_do_draw();
}
break;
case 'm':
case 'q':
browser_menu = menu_destroy(browser_menu);
ret |= KEY_CLICK;
if(browser_menu != NULL) {
browser_do_draw();
break;
}
browser_exit();
GrDestroyGC(browser_gc);
pz_close_window(browser_wid);
break;
case 'r':
if (menu_shift_selected(browser_menu, 1)) {
menu_draw(browser_menu);
ret |= KEY_CLICK;
}
break;
case 'l':
if (menu_shift_selected(browser_menu, -1)) {
menu_draw(browser_menu);
ret |= KEY_CLICK;
}
break;
default:
ret |= KEY_UNUSED;
}
break;
case GR_EVENT_TYPE_KEY_UP:
switch (event->keystroke.ch) {
case '\r':
case '\n':
if(browser_key_timer) {
GrDestroyTimer(browser_key_timer);
browser_key_timer = 0;
menu_handle_timer(browser_menu, 1);
browser_selection_activated(browser_menu->items[browser_menu->sel].orig_pos);
browser_do_draw();
}
break;
}
break;
default:
ret |= EVENT_UNUSED;
break;
}
return ret;
}
int new_snake_window(int argc, char **argv)
{
GR_SCREEN_INFO si;
fin = 0;
snake_count = 0;
game_speed = start_speed;
GrGetScreenInfo(&si); /* Get screen info */
srand(time(0));
game_state = SNAKE_START;
/* Make the window */
/*swindow = GrNewWindowEx(WM_PROPS, "nxsnake", GR_ROOT_WINDOW_ID,
10, 10, WWIDTH, WHEIGHT, BLACK);*/
swindow = pz_new_window (0,HEADER_TOPLINE+1,si.cols,si.rows-HEADER_TOPLINE-1,
do_draw,nxsnake_handle_event);
GrSelectEvents(swindow, GR_EVENT_MASK_EXPOSURE |
GR_EVENT_MASK_KEY_DOWN|GR_EVENT_MASK_TIMER);
nxsnake_timer = GrCreateTimer( swindow, 5 );
offscreen = pz_new_window (0,HEADER_TOPLINE+1,si.cols,si.rows-HEADER_TOPLINE-1,
do_draw,nxsnake_handle_event);
//offscreen = GrNewPixmap(WWIDTH, WHEIGHT, 0);
do_draw();
GrMapWindow(swindow);
GrMapWindow(offscreen);
/* Draw the instructions into the buffer */
draw_string( (char *) welcome, 1);
while(fin != 1)
{
GR_EVENT event;
/* We start at 130ms, but it goes down every */
/* time a nibble is eaten */
/* If they get this far, then they rock! */
if (game_speed < 5) game_speed = 5;
GrGetNextEventTimeout(&event, game_speed);
switch(event.type)
{
case GR_EVENT_TYPE_EXPOSURE:
case GR_EVENT_TYPE_KEY_DOWN:
nxsnake_handle_event(&event);
break;
case GR_EVENT_TYPE_TIMER:
handle_idle();
break;
}
}
return(1);
}
/* Initialise the game and return the state structure or NULL on failure: */
nbstate *init(int argc, char *argv[])
{
GR_PROP *prop;
nbstate *state;
GR_SCREEN_INFO si;
GR_BITMAP cursor = 0;
GR_WM_PROPERTIES props;
/* Try to connect to the Nano-X server: */
if(GrOpen() < 1) {
fprintf(stderr, "Couldn't connect to Nano-X server\n");
return NULL;
}
/* Check that the server was built with alpha blending support
* (necessary for the alpha blended sprites and special effects): */
GrGetScreenInfo(&si);
if(!si.alphablend) {
fprintf(stderr, "Error: Nano-X server was built without alpha "
"blending support\nSet ALPHABLENDING = 1 in "
"include/device.h, rebuild, and try again.\n");
return NULL;
}
/* Allocate the state structure and initialise it with defaults: */
if(!(state = malloc(sizeof(nbstate)))) return NULL;
setup_default_state(state);
/* Try to parse the command line arguments: */
if(parse_cmd_args(state, argc, argv)) {
free(state);
return NULL;
}
/* Try to load the game file: */
if(load_game_file(state)) {
free(state);
return NULL;
}
/* Load the high score file: */
load_hiscore(state);
/* Calculate the canvas size: */
state->canvaswidth = state->width * state->brickwidth;
state->canvasheight = state->scores.h + state->ball.s->h +
(2 * BALLS_BORDER) +
(state->height * state->brickheight) +
3 * state->brickheight + state->batheight;
/* Place the bat in the centre of the window: */
state->batx = state->canvaswidth / 2;
/* Create various pixmaps and alpha channels: */
state->scores.p = GrNewPixmap(state->canvaswidth, state->scores.h,
NULL);
state->scores.a = GrNewAlpha(state->canvaswidth, state->scores.h);
state->canvas = GrNewPixmap(state->canvaswidth, state->canvasheight,
NULL);
/* The new and old canvasses are only used when screen fading is
* enabled: */
if(state->faderate) {
state->newcanvas = GrNewPixmap(state->canvaswidth,
state->canvasheight, NULL);
state->oldcanvas = GrNewPixmap(state->canvaswidth,
state->canvasheight, NULL);
}
state->brickalpha = GrNewAlpha(state->brickwidth, state->brickheight);
/* Start off with the canvas completely black: */
GrSetGCForeground(state->gc, GR_COLOR_BLACK);
GrFillRect(state->canvas, state->gc, 0, 0, state->canvaswidth,
state->canvasheight);
/* If there is a window manager running, place the window off the
* screen and let the window manager move it where it wants (avoids
* flicker if we were to draw the window on screen before the window
* manager moved it somewhere else): */
if(GrGetWindowProperty(GR_ROOT_WINDOW_ID, "WINDOW_MANAGER", &prop)) {
free(prop);
state->winx = GR_OFF_SCREEN;
}
/* Create the output window: */
state->wid = GrNewWindow(GR_ROOT_WINDOW_ID, state->winx, 0,
state->canvaswidth, state->canvasheight, 0, 0, 0);
/* Set the window title: */
props.flags = GR_WM_FLAGS_TITLE;
props.title = "NanoBreaker";
GrSetWMProperties(state->wid, &props);
/* Make the cursor over the output window be invisible: */
GrSetCursor(state->wid, 1, 1, 1, 1, 0, 0, &cursor, &cursor);
/* Select the events we want to receive for the output window: */
GrSelectEvents(state->wid, GR_EVENT_MASK_CLOSE_REQ |
GR_EVENT_MASK_EXPOSURE |
GR_EVENT_MASK_BUTTON_DOWN |
GR_EVENT_MASK_KEY_DOWN |
GR_EVENT_MASK_KEY_UP |
GR_EVENT_MASK_UPDATE |
GR_EVENT_MASK_TIMER);
/* Select for mouse position events on the root window so we can move
* the bat even when the pointer strays outside the window (which it
* often does because the cursor is invisible you don't know exactly
* where it is): */
GrSelectEvents(GR_ROOT_WINDOW_ID, GR_EVENT_MASK_MOUSE_POSITION);
/* Map the output window (make it visible): */
GrMapWindow(state->wid);
/* Create the one second periodic timer that is used to decrement the
* power-up and power-down timers: */
state->tid = GrCreateTimer(state->wid, 1000, GR_TRUE);
/* Reset the game: */
reset_game(state);
return state; /* Return the newly allocated state structure. */
}
int main(int argc, char *argv[])
{
GR_EVENT event;
GR_PROP *data;
GR_SERIALNO count = 0;
GR_WINDOW_ID wid, serverid;
if(GrOpen() < 0) {
fprintf(stderr, "Couldn't connect to Nano-X server\n");
return 1;
}
wid = GrNewWindow(GR_ROOT_WINDOW_ID, 0, 0, 1, 1, 0, 0, 0);
if(!wid) {
fprintf(stderr, "Couldn't get a window\n");
GrClose();
return 1;
}
GrSelectEvents(wid, GR_EVENT_MASK_CLIENT_DATA | GR_EVENT_MASK_TIMER);
if(GrGetWindowProperty(GR_ROOT_WINDOW_ID, "demo_ipc_server", &data)
!= sizeof(serverid)) {
if(!data) {
fprintf(stderr, "Couldn't find server ID\n");
GrClose();
return 1;
} else {
fprintf(stderr, "Server ID property is wrong size\n");
free(data);
GrClose();
return 1;
}
}
memcpy(&serverid, data, sizeof(serverid));
free(data);
printf("Found server at window %d\n", serverid);
GrCreateTimer(wid, 1000, GR_TRUE);
while(1) {
GrGetNextEvent(&event);
switch(event.type) {
case GR_EVENT_TYPE_TIMER:
send_ping(wid, serverid, count++);
break;
case GR_EVENT_TYPE_CLIENT_DATA:
handle_packet(&event);
break;
default:
fprintf(stderr, "Got unknown event %d\n",
event.type);
break;
}
}
GrClose();
return 0;
}
