// 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);
			}
		}
}
Exemple #2
0
void run_game(nstate *state)
{
	while(state->state == STATE_RUNNING) {
		GrGetNextEventTimeout(&state->event, timeout_delay(state));
		handle_event(state);
		if(state->state == STATE_PAUSED) do_pause(state);
		if(state->state == STATE_RUNNING) do_update(state);
	}
}
Exemple #3
0
int
main(int ac, char **av)
{
    GR_EVENT event;
    GR_GC_ID gc;
    GR_WINDOW_ID pmap;
    GR_WINDOW_ID window;
    GR_WINDOW_INFO info;

    if (GrOpen() < 0) {
	fprintf(stderr, "cannot open graphics\n");
	exit(1);
    }

    window = nxCreateAppWindow(&ac, &av, args);
    gc = GrNewGC();
    GrSetGCForeground(gc, GrGetSysColor(GR_COLOR_WINDOW));
    GrSetGCBackground(gc, GrGetSysColor(GR_COLOR_WINDOWTEXT));

    GrSelectEvents(window, GR_EVENT_MASK_EXPOSURE |
		   GR_EVENT_MASK_UPDATE | GR_EVENT_MASK_CLOSE_REQ);

    GrGetWindowInfo(window, &info);
    pmap = resize(info.width, info.height, 0);

    GrMapWindow(window);

    while (1) {
	GrGetNextEventTimeout(&event, 500L);

	switch (event.type) {
	case GR_EVENT_TYPE_EXPOSURE:
	case GR_EVENT_TYPE_TIMEOUT:
	    draw_clock(0, 0, width, height, pmap, gc, window);
	    break;

	case GR_EVENT_TYPE_CLOSE_REQ:
	    GrClose();
	    exit(0);

	case GR_EVENT_TYPE_UPDATE:
	    switch (event.update.utype) {
	    case GR_UPDATE_SIZE:
		pmap = resize(event.update.width, event.update.height, pmap);
		break;
	    }
	}
    }
    return 0;
}
Exemple #4
0
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);

	}
}
Exemple #5
0
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();		
	}
}
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
}
Exemple #7
0
void
show_jpeg(int client, char *file, int show_time)
{
    GR_EVENT        event;          /* current event */
    GR_IMAGE_ID     id = 0;
    GR_SIZE         w = -1;
    GR_SIZE         h = -1;
    GR_IMAGE_INFO   info;
    GR_WINDOW_ID    w1;             /* id for large window */
    GR_GC_ID        gc1;            /* graphics context for text */
    GR_SCREEN_INFO  si;

    int time_left;
    bool ever_exposed = false;

#if !defined(HAVE_JPEG_SUPPORT) && !defined(HAVE_BMP_SUPPORT) && !defined(HAVE_GIF_SUPPORT)
    printf("Sorry, no image support compiled in\n");
    exit(1);        
#endif

    GrGetScreenInfo(&si);
    printf("Loading image: %s\n", file);
    if (access(file, F_OK) < 0) {
        fdprintf(client, "Can't access \"%s\": %s\n", file, strerror(errno));
        return;
    }
    id = GrLoadImageFromFile(file, 0);
    if (id) {
        GrGetImageInfo(id, &info);
    } else {
        // File exists, so why the error?
        int fd, len;
        char buf[64];
        fdprintf(client, "Can't load %s\n", file);
        if ((fd = open(file, O_RDONLY)) >= 0) {
            len = read(fd, buf, 64);
            if (len != 64) {
                diag_printf("Short read? len = %d\n", len);
            } else {
                diag_dump_buf(buf, len);
            }
            close(fd);
        } else {
            diag_printf("Can't oopen \"%s\": %s\n",  file, strerror(errno));
        }
        return;
    }

    w = info.width;
    h = info.height;
    if ((si.rows < info.height) || (si.cols < info.width)) {
        // Preserve aspect ratio
        if (si.cols < info.width) {
            w = si.cols;
            h = (si.cols * info.height) / info.width;
        }
        if (si.rows < h) {
            w = (si.rows * w) / h;
            h = si.rows;
        }
    }
    printf("Create window - orig %dx%d => %dx%d\n", info.width, info.height, w, h);
    fdprintf(client, "<INFO> Display \"%s\" - orig %dx%d => %dx%d\n", file, info.width, info.height, w, h);
    w1 = GrNewWindow(GR_ROOT_WINDOW_ID, 10, 10, w, h, 4, BLACK, WHITE);
    GrSelectEvents(w1, GR_EVENT_MASK_CLOSE_REQ|GR_EVENT_MASK_EXPOSURE);
    GrMapWindow(w1);
    gc1 = GrNewGC();
    GrSetGCForeground(gc1, WHITE);

#define TO_MS 50
    time_left = show_time * 1000;
    while (time_left > 0) {
        GrGetNextEventTimeout(&event, TO_MS);  // milliseconds
        switch(event.type) {
        case GR_EVENT_TYPE_CLOSE_REQ:
            GrDestroyWindow(w1);
            GrFreeImage(id);
            return;
            /* no return*/
        case GR_EVENT_TYPE_EXPOSURE:
            /*GrDrawImageFromFile(w1, gc1, 0, 0, w, h, argv[1],0);*/
            GrDrawImageToFit(w1, gc1, 0, 0, w, h, id);
            ever_exposed = true;
            break;
        default:
        case GR_EVENT_TYPE_NONE:
        case GR_EVENT_TYPE_TIMEOUT:
            time_left -= TO_MS;
            if ((time_left < 0) && !ever_exposed) {
                // Things get real cranky if we delete the window too fast!
                time_left = TO_MS;
            }
            break;
        }
    }    
    GrUnmapWindow(w1);
    GrDestroyWindow(w1);
    GrDestroyGC(gc1);
    GrFreeImage(id);
}
int
main(int ac, char **av)
{
	GR_EVENT	event;		/* current event */
	GR_BITMAP	bitmap1fg[7];	/* bitmaps for first cursor */
	GR_BITMAP	bitmap1bg[7];

	if (GrOpen() < 0) {
		fprintf(stderr, "cannot open graphics\n");
		exit(1);
	}
	
	/* create window*/
	w1 = GrNewWindowEx(
		GR_WM_PROPS_NOAUTOMOVE|GR_WM_PROPS_BORDER|GR_WM_PROPS_CAPTION|
		GR_WM_PROPS_CLOSEBOX, "nxclock", GR_ROOT_WINDOW_ID, 
		10, 10, CWIDTH, CHEIGHT, GrGetSysColor(GR_COLOR_WINDOW));
		
	GrSelectEvents(w1, GR_EVENT_MASK_EXPOSURE | GR_EVENT_MASK_CLOSE_REQ);

	gc1 = GrNewGC();
	gc2 = GrNewGC();

	GrSetGCForeground(gc1, GrGetSysColor(GR_COLOR_WINDOW));
	GrSetGCBackground(gc1, GrGetSysColor(GR_COLOR_WINDOWTEXT));
	GrSetGCForeground(gc2, GrGetSysColor(GR_COLOR_WINDOWTEXT));
	GrSetGCBackground(gc2, GrGetSysColor(GR_COLOR_WINDOW));

	bitmap1bg[0] = MASK(_,_,X,X,X,_,_);
	bitmap1bg[1] = MASK(_,X,X,X,X,X,_);
	bitmap1bg[2] = MASK(X,X,X,X,X,X,X);
	bitmap1bg[3] = MASK(X,X,X,X,X,X,X);
	bitmap1bg[4] = MASK(X,X,X,X,X,X,X);
	bitmap1bg[5] = MASK(_,X,X,X,X,X,_);
	bitmap1bg[6] = MASK(_,_,X,X,X,_,_);

	bitmap1fg[0] = MASK(_,_,_,X,_,_,_);
	bitmap1fg[1] = MASK(_,X,_,X,_,X,_);
	bitmap1fg[2] = MASK(_,_,_,X,_,_,_);
	bitmap1fg[3] = MASK(X,_,_,X,X,_,X);
	bitmap1fg[4] = MASK(_,_,_,_,_,_,_);
	bitmap1fg[5] = MASK(_,X,_,_,_,X,_);
	bitmap1fg[6] = MASK(_,_,_,X,_,_,_);

	GrSetCursor(w1, 7, 7, 3, 3, WHITE, BLACK, bitmap1fg, bitmap1bg);
	GrMapWindow(w1);

	while (1) {
		GrGetNextEventTimeout(&event, 500L);

		switch (event.type) {
			case GR_EVENT_TYPE_EXPOSURE:
				do_exposure(&event.exposure);
				break;

			case GR_EVENT_TYPE_CLOSE_REQ:
				GrClose();
				exit(0);

			case GR_EVENT_TYPE_TIMEOUT:
				do_clock();
				break;
		}
	}
}
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);
}
Exemple #10
0
int
main(int argc, char **argv)
{
	GR_WINDOW_ID main_wid;
	GR_TIMEOUT timeout;
	int width, height;

	if (argc != 2)
		return (-1);

	if (GrOpen() == -1)
		return (-1);

	font = GrCreateFontEx(argv[1], 12, 12, 0);
	if (!font)
		printf("Unable to load %s\n", argv[1]);

	GrGetFontInfo(font, &finfo);

	printf("font_id = %d\n", font);
	printf("First char = %d, last char = %d\n", finfo.firstchar, finfo.lastchar);
	printf("Max width = %d, max height = %d\n", finfo.maxwidth, finfo.height);
	printf("baseline = ascent = %d, descent = %d\n", finfo.baseline, finfo.descent);
	printf("max ascent = %d, max descent = %d\n", finfo.maxascent, finfo.maxdescent);
	printf("linespacing = %d, fixed = %s\n", finfo.linespacing, finfo.fixed? "yes": "no");

//	finfo.firstchar = 0;	/* force display of undefined chars, test with jiskan24.pcf.gz*/

	/* determine window metrics*/
	width = (finfo.maxwidth + spacer) * line_width + 2 * border - spacer;
	if (width > 640) {
		line_width /= 2;
		lines *= 2;
		width = (finfo.maxwidth + 2) * line_width + 2 * border - spacer;
    }
	height = lines * (finfo.height + spacer) + 2 * border - spacer;
	chars_to_show = lines * line_width;

	/* create the main application window*/
	main_wid = GrNewWindowEx(GR_WM_PROPS_APPWINDOW, "pcfdemo",
			GR_ROOT_WINDOW_ID, 0, 0, width, height, BLACK);
	GrSelectEvents(main_wid, GR_EVENT_MASK_EXPOSURE|GR_EVENT_MASK_CLOSE_REQ);
	GrMapWindow(main_wid);

	if (finfo.lastchar >= chars_to_show)
		timeout = 8 * 1000;
    else timeout = 0;

	while (1) {
		GR_EVENT event;
		GrGetNextEventTimeout(&event, timeout);

		if (event.type == GR_EVENT_TYPE_TIMEOUT) {
			first_char += chars_to_show;
            draw_string(main_wid);
		}
		if (event.type == GR_EVENT_TYPE_EXPOSURE)
			draw_string(main_wid);
		if(event.type == GR_EVENT_TYPE_CLOSE_REQ) {
			GrClose();
			exit(0);
	   }
	}
}
Exemple #11
0
int main(int argc, char *argv[])
{
	GR_CHAR *typelist, *p;
	GR_WINDOW_ID sid, wid;
	GR_EVENT event;
	int n = 0, mimetype = -1;

	if(GrOpen() < 0) {
		fprintf(stderr, "Couldn't connect to Nano-X server\n");
		return 1;
	}

	sid = GrGetSelectionOwner(&typelist);
	if(!sid) {
		fprintf(stderr, "Clipboard is empty\n");
		return 2;
	}

	if(!typelist) {
		fprintf(stderr, "GrGetSelectionOwner() returned an empty "
				"type list for window %d\n", sid);
		return 3;
	}

	fprintf(stderr, "Window %d owns the selection\n", sid);
	fprintf(stderr, "It claims to be able to supply data in the following "
			"types:\n%s\n", typelist);

	p = strtok(typelist, " ");
	do {
		if(!strncmp("text/plain", p, 10)) {
			mimetype = n;
			break;
		}
		n++;
	} while((p = strtok(NULL, " ")));

	if(mimetype == -1) {
		fprintf(stderr, "Type text/plain is not available\n");
		return 4;
	}

	free(typelist);

	fprintf(stderr, "Type text/plain is available- requesting data\n");

	wid = GrNewWindow(GR_ROOT_WINDOW_ID, 0, 0, 1, 1, 0, 0, 0);
	if(!wid) {
		fprintf(stderr, "Couldn't get a window\n");
		return 5;
	}

	GrSelectEvents(wid, GR_EVENT_MASK_CLIENT_DATA);

	GrRequestClientData(wid, sid, 0, mimetype);

	while(1) {
		GrGetNextEventTimeout(&event, 4000);
		switch(event.type) {
			case GR_EVENT_TYPE_CLIENT_DATA:
				if(got_client_data(&event))
					return 0;
				break;
			case GR_EVENT_TYPE_TIMEOUT:
				fprintf(stderr, "Timed out waiting for data\n");
				return 6;
			default:
				break;
		}
	}

	return 0;
}