int
XEventsQueued(Display * display, int mode)
{
int ret;
GR_EVENT temp;
FUNC_ENTER;
ret = GrQueueLength();
/* check hack for local saved event*/
if (saved)
return ret+1;
if (!ret && mode != QueuedAlready) {
if (mode == QueuedAfterFlush)
GrFlush();
if (GrPeekEvent(&temp))
ret = 1;
}
if (ret)
DPRINTF("Returning %d events ready\n", ret);
return ret;
}
static void
GrPeekEventWrapper(void *r)
{
GR_EVENT evt;
GR_CHAR ret;
GR_EVENT_CLIENT_DATA *cde;
ret = GrPeekEvent(&evt);
GsWriteType(current_fd,GrNumPeekEvent);
GsWrite(current_fd, &evt, sizeof(evt));
if(evt.type == GR_EVENT_TYPE_CLIENT_DATA) {
cde = (GR_EVENT_CLIENT_DATA *)&evt;
if(cde->data) {
GsWrite(current_fd, cde->data, cde->datalen);
free(cde->data);
} cde->datalen = 0;
}
GsWrite(current_fd, &ret, sizeof(GR_CHAR));
/* EXPERIMENTAL CODE for GTK+ select wait*/
if (ret == 0) {
/* tell main loop to call Finish routine on event*/
curclient->waiting_for_event = TRUE;
}
}
// check for events & delete the event queue
static void check_event() {
if (GrPeekEvent(&break_event)) {
GrGetNextEventTimeout(&break_event, 1000);
if (break_event.type != GR_EVENT_TYPE_TIMEOUT) {
pz_event_handler(&break_event);
// delete the rest of the event queue
while ( break_event.type != GR_EVENT_TYPE_NONE )
GrGetNextEventTimeout(&break_event, 0);
}
}
}
void generate_tone()
{
int nsamples;
GR_EVENT event;
int freq = 0;
// struct audio_buf_info info;
// char buf[20];
while(!generator_paused) {
if(generator_freq != freq) {
freq = generator_freq;
nsamples = make_wave_buffer(generator_freq);
//add wave types here - tbd
}
// we need to use ioctl to get available space and ensure we dont write too much to improve response
// times while changing freq/notes. to be done
// ioctl(dspz.dsp, SNDCTL_DSP_GETOSPACE, &info);
// sprintf(buf, "f:%d, s/f: %d", info.fragstotal, info.fragsize);
// sprintf(buf, "afs: %d, ab: %d", info.fragments, info.bytes);
// generator_draw_text(buf);
dsp_write( &dspz, wave_buffer, sizeof(short)*nsamples); // dont write block
if(GrPeekEvent(&event)) {
repeat:
GrGetNextEventTimeout(&event, 1000);
if (event.type != GR_EVENT_TYPE_TIMEOUT) {
pz_event_handler(&event);
if (GrPeekEvent(&event))
goto repeat;
}
}
}
if (generator_quit_app) // menu button in the middle of a play
generator_button_menu();//get out of the app
// better way to get out of the event handler - tbd
}
static void
GrPeekEventWrapper(void *r)
{
GR_EVENT evt;
GR_CHAR ret;
GR_EVENT_CLIENT_DATA *cde;
ret = GrPeekEvent(&evt);
GsWriteType(current_fd,GrNumPeekEvent);
GsWrite(current_fd, &evt, sizeof(evt));
if(evt.type == GR_EVENT_TYPE_CLIENT_DATA) {
cde = (GR_EVENT_CLIENT_DATA *)&evt;
if(cde->data) {
GsWrite(current_fd, cde->data, cde->datalen);
free(cde->data);
} cde->datalen = 0;
}
GsWrite(current_fd, &ret, sizeof(GR_CHAR));
}
static void video_check_messages()
{
GR_EVENT event;
int evtcap = 200;
video_vol_delta = 0;
while (GrPeekEvent(&event) && evtcap--) {
GrGetNextEventTimeout(&event, 500);
if (event.type != GR_EVENT_TYPE_TIMEOUT) {
pz_event_handler(&event);
} else {
break;
}
}
if (video_vol_delta != 0)
{
audio_adjustVolume(video_vol_delta);
}
}
static void mp3_event_handler()
{
GR_EVENT event;
int evtcap = 200;
vol_delta = 0;
while (GrPeekEvent(&event) && evtcap--)
{
GrGetNextEventTimeout(&event, 1000);
if (event.type != GR_EVENT_TYPE_TIMEOUT) {
pz_event_handler(&event);
} else {
break;
}
}
if (vol_delta != 0) {
mp3_refresh_state();
}
}
/// forward events from system queue to application queue
virtual void forwardSystemEvents( bool waitForEvent )
{
if ( _stopFlag )
waitForEvent = false;
GR_EVENT event;
for(;;)
{
//main_win->unsetLastNavigationDirection();
if ( waitForEvent ) {
GrGetNextEvent(&event);
} else {
if (!GrPeekEvent(&event))
break;
GrCheckNextEvent( &event );
}
waitForEvent = false;
switch(event.type)
{
case GR_EVENT_TYPE_ERROR:
CRLog::debug("GR_EVENT_TYPE_ERROR");
break;
case GR_EVENT_TYPE_CLOSE_REQ:
CRLog::debug("GR_EVENT_TYPE_CLOSE_REQ");
break;
case GR_EVENT_TYPE_EXPOSURE:
CRLog::debug("GR_EVENT_TYPE_EXPOSURE");
postEvent( new CRGUIUpdateEvent(true) );
/*
m_images->printImage("logo",0,0);
GrSetFontSize(m_state->fontid,32);
GrText(m_state->wid,m_state->gc,240,690,(char *)"Hello!\n",-1,GR_TFASCII|GR_TFTOP);
GrText(m_state->wid,m_state->gc,100,720,(char *)"This is only an example",-1,\
GR_TFASCII|GR_TFTOP);
*/
//postLeds( true );
//update(true);
if ( firstDocUpdate ) {
//main_win->getDocView()->swapToCache();
firstDocUpdate = false;
}
//postLeds( false );
break;
case GR_EVENT_TYPE_BUTTON_DOWN:
{
CRLog::debug("GR_EVENT_TYPE_BUTTON_DOWN");
/*
char buf[128]={0};
GrClearArea(m_state->wid,10,770,400,28,0);
GrSetFontSize(m_state->fontid,24);
sprintf(buf,"mouse down: x=%d y=%d",event.mouse.x,event.mouse.y);
GrText(m_state->wid,m_state->gc,10,770,(char *)buf,-1,GR_TFASCII|GR_TFTOP);
GrPartialPrint(m_state->wid,10,770,400,28);
*/
}
break;
case GR_EVENT_TYPE_BUTTON_UP:
{
CRLog::debug("GR_EVENT_TYPE_BUTTON_UP");
/*
char buf[128]={0};
GrClearArea(m_state->wid,10,770,400,28,0);
GrSetFontSize(m_state->fontid,24);
sprintf(buf,"mouse up: x=%d y=%d",event.mouse.x,event.mouse.y);
GrText(m_state->wid,m_state->gc,10,770,(char *)buf,-1,GR_TFASCII|GR_TFTOP);
GrPartialPrint(m_state->wid,10,770,400,28);
*/
}
break;
case GR_EVENT_TYPE_MOUSE_POSITION:
{
CRLog::debug("GR_EVENT_TYPE_MOUSE_POSITION");
/*
char buf[128]={0};
GrClearArea(m_state->wid,10,770,400,28,0);
GrSetFontSize(m_state->fontid,24);
sprintf(buf,"mouse move: x=%d y=%d",event.mouse.x,event.mouse.y);
GrText(m_state->wid,m_state->gc,10,770,(char *)buf,-1,GR_TFASCII|GR_TFTOP);
GrPartialPrint(m_state->wid,10,770,400,28);
*/
}
break;
case GR_EVENT_TYPE_KEY_DOWN:
//case GR_EVENT_TYPE_KEY_UP:
CRLog::debug("GR_EVENT_TYPE_KEY_DOWN %d", (int)event.keystroke.ch );
{
static int convert_table[] = {
KEY_0, '0', 0,
KEY_1, '1', 0,
KEY_2, '2', 0,
KEY_3, '3', 0,
KEY_4, '4', 0,
KEY_5, '5', 0,
KEY_6, '6', 0,
KEY_7, '7', 0,
KEY_8, '8', 0,
KEY_9, '9', 0,
LONG_KEY_0, '0', KEY_FLAG_LONG_PRESS,
LONG_KEY_1, '1', KEY_FLAG_LONG_PRESS,
LONG_KEY_2, '2', KEY_FLAG_LONG_PRESS,
LONG_KEY_3, '3', KEY_FLAG_LONG_PRESS,
LONG_KEY_4, '4', KEY_FLAG_LONG_PRESS,
LONG_KEY_5, '5', KEY_FLAG_LONG_PRESS,
LONG_KEY_6, '6', KEY_FLAG_LONG_PRESS,
LONG_KEY_7, '7', KEY_FLAG_LONG_PRESS,
LONG_KEY_8, '8', KEY_FLAG_LONG_PRESS,
LONG_KEY_9, '9', KEY_FLAG_LONG_PRESS,
KEY_CANCEL, XK_Escape, 0,
KEY_OK, XK_Return, 0,
KEY_DOWN, XK_Right, 0,
KEY_UP, XK_Left, 0,
KEY_CURSOR_OK, XK_KP_Enter, 0,
KEY_CURSOR_DOWN, XK_Next, 0,
KEY_CURSOR_UP, XK_Prior, 0,
//KEY_CURSOR_OK, XK_Return, 0,
//KEY_CURSOR_DOWN, XK_Up, 0,
//KEY_CURSOR_UP, XK_Down, 0,
LONG_KEY_CANCEL, XK_Escape, KEY_FLAG_LONG_PRESS,
LONG_KEY_OK, XK_Return, KEY_FLAG_LONG_PRESS,
LONG_KEY_DOWN, XK_Right, KEY_FLAG_LONG_PRESS,
LONG_KEY_UP, XK_Left, KEY_FLAG_LONG_PRESS,
LONG_KEY_CURSOR_OK, XK_KP_Enter, KEY_FLAG_LONG_PRESS,
LONG_KEY_CURSOR_DOWN, XK_Next, KEY_FLAG_LONG_PRESS,
LONG_KEY_CURSOR_UP, XK_Prior, KEY_FLAG_LONG_PRESS,
KEY_SHORTCUT_VOLUME_UP, XK_KP_Add, 0,
KEY_SHORTCUT_VOLUME_DOWN, XK_KP_Subtract, 0,
LONG_SHORTCUT_KEY_VOLUMN_UP, XK_KP_Add, KEY_FLAG_LONG_PRESS,
LONG_SHORTCUT_KEY_VOLUMN_DOWN, XK_KP_Subtract, KEY_FLAG_LONG_PRESS,
0, 0, 0 // end marker
};
int code = 0;
int flags = 0;
int keyId = event.keystroke.ch;
for ( int i=0; convert_table[i]; i+=3 ) {
if ( keyId==convert_table[i] ) {
code = convert_table[i+1];
flags = convert_table[i+2];
CRLog::debug( "OnKeyPressed( %d (%04x) ) - converted to %04x, %d", keyId, keyId, code, flags );
}
}
if ( !code ) {
CRLog::debug( "Unknown key code in OnKeyPressed() : %d (%04x)", keyId, keyId );
break;
}
postEvent( new CRGUIKeyDownEvent(code, flags) );
if ( CRJinkeWindowManager::instance->getWindowCount()==0 ) {
_stopFlag = true;
// QUIT
CRLog::trace("windowCount==0, quitting");
}
}
break;
case GR_EVENT_TYPE_FDINPUT:
CRLog::debug( "GR_EVENT_TYPE_FDINPUT" );
break;
default:
CRLog::debug( "unknown event %d", (int)event.type );
break;
}
}
}
int main(int argc, char **argv) {
int serialFd;
int outFd;
GR_SCREEN_INFO info;
GR_WINDOW_ID calWindow;
GR_EVENT event;
/* Open up the graphics */
if (GrOpen() == -1) {
fprintf(stderr, "Error! Unable to open the graphics engine\n");
return(-1);
}
/* Now open the serial port */
serialFd = calInitSerial("/dev/ttyS1");
if (serialFd == -1) {
fprintf(stderr, "Error! Unable to open the touchscreen device\n");
return(-1);
}
GrGetScreenInfo(&info);
/* Decide which points we are going to touch */
dataPoints[0].scrX = 10;
dataPoints[0].scrY = 10;
dataPoints[1].scrX = 10;
dataPoints[1].scrY = info.rows - 10;
dataPoints[2].scrX = info.cols - 10;
dataPoints[2].scrY = info.rows - 10;
dataPoints[3].scrX = info.cols - 10;
dataPoints[3].scrY = 10;
/* Now, create a window that spans the entire size of the screen */
calWindow = GrNewWindow(GR_ROOT_WINDOW_ID, 0, 0, info.cols, info.rows, 0, BGCOLOR, FGCOLOR);
GrSelectEvents(calWindow, GR_EVENT_MASK_EXPOSURE);
GrMapWindow(calWindow);
/* Wait for exposure */
while(GrPeekEvent(&event) != GR_EVENT_TYPE_EXPOSURE);
/* Ok, now that we have been exposed, draw the instructions */
drawText(calWindow, instructions, 4);
if (!doPoints(calWindow, serialFd)) {
double scrXDelta, rawXDelta;
double scrYDelta, rawYDelta;
double deltaX, deltaY;
scrXDelta = (double) dataPoints[2].scrX - dataPoints[0].scrX;
rawXDelta = (double) dataPoints[2].rawX - dataPoints[0].rawX;
scrYDelta = (double) dataPoints[1].scrY - dataPoints[0].scrY;
rawYDelta = (double) dataPoints[1].rawY - dataPoints[0].rawY;
/* We can now extrapolate and discover the extreme edges of the screen */
/* First, the low values */
deltaX = abs( (rawXDelta / scrXDelta) * ((double) dataPoints[0].scrX));
deltaY = abs( (rawYDelta / scrYDelta) * ((double) dataPoints[0].scrY));
/*
deltaX = abs((double) dataPoints[0].scrX * rawXDelta) / scrXDelta);
deltaY = abs((double) (dataPoints[0].scrY * rawYDelta) / scrYDelta);
*/
/* Print out the raw values, accounting for possible inversion */
if (dataPoints[0].rawX > dataPoints[2].rawX) {
printf("%d ", (int) (dataPoints[0].rawX + deltaX));
printf("%d ", (int) (dataPoints[2].rawX - deltaX));
}
else {
printf("%d ", (int) (dataPoints[0].rawX - deltaX));
printf("%d ", (int) (dataPoints[2].rawX + deltaX));
}
if (dataPoints[0].rawY >dataPoints[1].rawY) {
printf("%d ", (int) (dataPoints[0].rawY + deltaY));
printf("%d\n", (int) (dataPoints[1].rawY - deltaY));
}
else {
printf("%d ", (int) (dataPoints[0].rawY - deltaY));
printf("%d\n", (int) (dataPoints[1].rawY + deltaY));
}
}
else {
fprintf(stderr, "Error - Unable to read the touchscreen\n");
}
/* Close everything down */
calCloseSerial(serialFd);
GrClose();
/* Byebye! */
return(0);
}
int
main(int ac, char **av)
{
int ax;
char *arg;
RoachMap *rp;
int rx;
float angle;
GR_EVENT ev;
int nVis;
int needCalc;
GR_SCREEN_INFO sinfo;
/*
Process command line options.
*/
for (ax=1; ax<ac; ax++) {
arg = av[ax];
if (strcmp(arg, "-rc") == 0) {
roachColor = atoi(av[++ax]);
}
else if (strcmp(arg, "-speed") == 0) {
roachSpeed = atof(av[++ax]);
}
else if (strcmp(arg, "-roaches") == 0) {
maxRoaches = strtol(av[++ax], (char **)NULL, 0);
}
else {
Usage();
}
}
srand((int)time((long *)NULL));
/*
Catch some signals so we can erase any visible roaches.
*/
signal(SIGKILL, SigHandler);
signal(SIGINT, SigHandler);
signal(SIGTERM, SigHandler);
signal(SIGHUP, SigHandler);
if (GrOpen() < 0) {
fprintf(stderr, "can't open graphics\n");
exit(1);
}
GrGetScreenInfo(&sinfo);
display_width = sinfo.cols;
display_height = sinfo.rows;
/*
Create roach pixmaps at several orientations.
*/
for (ax=0; ax<360; ax+=ROACH_ANGLE) {
rx = ax / ROACH_ANGLE;
angle = rx * 0.261799387799;
rp = &roachPix[rx];
rp->pixmap = GrNewPixmapFromData(rp->width, rp->height, WHITE, BLACK,
rp->roachBits, GR_BMDATA_BYTEREVERSE|GR_BMDATA_BYTESWAP);
rp->sine = sin(angle);
rp->cosine = cos(angle);
}
roaches = (Roach *)malloc(sizeof(Roach) * maxRoaches);
gc = GrNewGC();
while (curRoaches < maxRoaches)
AddRoach();
GrSelectEvents(GR_ROOT_WINDOW_ID, GR_EVENT_MASK_EXPOSURE | GR_EVENT_MASK_CHLD_UPDATE);
needCalc = 1;
while (!done) {
if (GrPeekEvent(&ev))
GrGetNextEvent(&ev);
else {
if (needCalc) {
needCalc = CalcRootVisible();
}
nVis = MarkHiddenRoaches();
if (nVis) {
ev.type = SCAMPER_EVENT;
}
else {
DrawRoaches();
eventBlock = GR_TRUE;
GrGetNextEvent(&ev);
eventBlock = GR_FALSE;
}
}
switch (ev.type) {
case SCAMPER_EVENT:
for (rx=0; rx<curRoaches; rx++) {
if (!roaches[rx].hidden)
MoveRoach(rx);
}
DrawRoaches();
GrDelay(100);
break;
case GR_EVENT_TYPE_EXPOSURE:
case GR_EVENT_TYPE_CHLD_UPDATE:
needCalc = 1;
break;
}
}
CoverRoot();
GrClose();
return 0;
}
