void do_event_loop(lstate *state) { do { GrGetNextEvent(&state->event); handle_event(state); } while(state->event.type != GR_EVENT_TYPE_CLOSE_REQ); }
int main(int argc, char **argv) { int COLS, ROWS; if (GrOpen() < 0) { GrError("Cannot open graphics\n"); return 1; } COLS = 350; ROWS = 300; g_main = GrNewWindowEx(GR_WM_PROPS_APPWINDOW, "dashdemo", GR_ROOT_WINDOW_ID, 100, 50, COLS - 120, ROWS - 60, BLUE); GrSelectEvents(g_main, GR_EVENT_MASK_EXPOSURE|GR_EVENT_MASK_CLOSE_REQ); GrMapWindow(g_main); while (1) { GR_EVENT event; GrGetNextEvent(&event); switch (event.type) { case GR_EVENT_TYPE_EXPOSURE: draw_screen(); break; case GR_EVENT_TYPE_CLOSE_REQ: GrClose(); return 0; } } }
static void checkevent(void) { GR_EVENT event; GrGetNextEvent(&event); switch (event.type) { case GR_EVENT_TYPE_EXPOSURE: doexposure(&event.exposure); break; case GR_EVENT_TYPE_BUTTON_DOWN: dobuttondown(&event.button); break; case GR_EVENT_TYPE_BUTTON_UP: dobuttonup(&event.button); break; case GR_EVENT_TYPE_MOUSE_POSITION: doposition(&event.mouse); break; case GR_EVENT_TYPE_KEY_DOWN: dokeydown(&event.keystroke); break; case GR_EVENT_TYPE_CLOSE_REQ: GrClose(); exit(0); } }
void do_pause(nstate *state) { draw_pause_continue_button(state); while(state->state == STATE_PAUSED) { GrGetNextEvent(&state->event); handle_event(state); } draw_pause_continue_button(state); }
void GrMainLoop(GR_FNCALLBACKEVENT fncb) { GR_EVENT event; for(;;) { GrGetNextEvent(&event); fncb(&event); } }
void wait_for_start(nstate *state) { draw_pause_continue_button(state); while(state->state == STATE_STOPPED) { GrGetNextEvent(&state->event); handle_event(state); } if(state->state == STATE_NEWGAME) state->state = STATE_RUNNING; draw_pause_continue_button(state); calculate_timeout(state); }
int start(int argc, char **argv) { GR_EVENT event; nxeyes_state *state; if(GrOpen() < 0) { printf("Couldn't connect to Nano-X server\n"); return 1; } if(!(state = init())) { printf("Couldn't allocate state structure\n"); return 1; } while(!state->quit) { GrGetNextEvent(&event); switch(event.type) { case GR_EVENT_TYPE_CLOSE_REQ: state->quit = 1; break; case GR_EVENT_TYPE_MOUSE_POSITION: position_event(&event.mouse, state); break; case GR_EVENT_TYPE_BUTTON_UP: case GR_EVENT_TYPE_BUTTON_DOWN: button_event(&event.button, state); break; case GR_EVENT_TYPE_EXPOSURE: draw_eyes(state, 1); break; #if MW_FEATURE_TIMERS case GR_EVENT_TYPE_TIMER: timer_event(&event.timer, state); break; #endif default: break; } if(state->mouse_moved) { draw_eyes(state, 0); state->mouse_moved = 0; } } GrClose(); free(state); return 0; }
/* * Return next event in queue, or if none, flush output and wait for * events. */ int XNextEvent(Display * dpy, XEvent * event) { GR_EVENT ev; FUNC_ENTER; if (saved) { *event = saved_event; saved = 0; } else { GrGetNextEvent(&ev); translateNXEvent(dpy, &ev, event); } FUNC_EXIT; return 1; }
int main(int argc, char **argv) { int COLS, ROWS; if (GrOpen() == -1) exit(1); COLS = 480; ROWS = 300; load_pixmap(); g_main = GrNewWindowEx(GR_WM_PROPS_APPWINDOW, "tsdemo", GR_ROOT_WINDOW_ID, 100, 50, COLS - 120, ROWS - 60, GRAY); GrSelectEvents(g_main, GR_EVENT_MASK_EXPOSURE | GR_EVENT_MASK_CLOSE_REQ); GrMapWindow(g_main); while (1) { GR_EVENT event; GrGetNextEvent(&event); switch (event.type) { case GR_EVENT_TYPE_EXPOSURE: g_x = 5; draw_set("GR_FILL_STIPPLE", GR_FILL_STIPPLE); draw_set("GR_FILL_OPAQUE_STIPPLE", GR_FILL_OPAQUE_STIPPLE); draw_set("GR_FILL_TILE", GR_FILL_TILE); break; case GR_EVENT_TYPE_CLOSE_REQ: GrClose(); exit(0); } } }
int main(int argc, char **argv) { GR_WINDOW_ID wid; GR_GC_ID gc[NUMGCS]; GR_EVENT event; if(GrOpen() < 0) { fprintf(stderr, "Couldn't connect to the Nano-X server\n"); return 1; } wid = GrNewWindowEx(GR_WM_PROPS_APPWINDOW, "rgndemo", GR_ROOT_WINDOW_ID, 0, 0, WINDOW_WIDTH, WINDOW_HEIGHT, GR_COLOR_GRAY80); GrSelectEvents(wid, GR_EVENT_MASK_CLOSE_REQ | GR_EVENT_MASK_EXPOSURE); gc[0] = setup_single_rect_region(); gc[1] = setup_multi_rect_region(); gc[2] = setup_simple_poly_region(); gc[3] = setup_bitmap_region(); gc[4] = setup_complex_poly_region(); GrMapWindow(wid); while(1) { GrGetNextEvent(&event); switch(event.type) { case GR_EVENT_TYPE_EXPOSURE: redraw(wid, gc); break; case GR_EVENT_TYPE_CLOSE_REQ: GrClose(); return 0; default: break; } } }
int main(void) { GR_WINDOW_ID wid; GR_GC_ID gc; GR_EVENT event; if(GrOpen() < 0) { fprintf(stderr, "Couldn't connect to the Nano-X server\n"); return 1; } wid = GrNewWindow(GR_ROOT_WINDOW_ID, 0, 0, BITMAPWIDTH, BITMAPHEIGHT, 0, GR_COLOR_WHITE, 0); GrSelectEvents(wid, GR_EVENT_MASK_CLOSE_REQ | GR_EVENT_MASK_EXPOSURE); gc = GrNewGC(); GrSetGCForeground(gc, GR_COLOR_BLACK); GrSetGCBackground(gc, GR_COLOR_WHITE); GrMapWindow(wid); while(1) { GrGetNextEvent(&event); switch(event.type) { case GR_EVENT_TYPE_EXPOSURE: redraw(wid, gc); break; case GR_EVENT_TYPE_CLOSE_REQ: GrClose(); return 0; default: break; } } }
int main(int argc,char **argv) { GR_EVENT event; /* current event */ GR_BITMAP bitmap1fg[7]; /* bitmaps for first cursor */ GR_BITMAP bitmap1bg[7]; GR_BITMAP bitmap2fg[7]; /* bitmaps for second cursor */ GR_BITMAP bitmap2bg[7]; if (GrOpen() < 0) { fprintf(stderr, "cannot open graphics\n"); exit(1); } GrGetScreenInfo(&si); w1 = GrNewWindow(GR_ROOT_WINDOW_ID, 100, 50, si.cols - 120, si.rows - 60, 1, BROWN, WHITE); w2 = GrNewWindow(GR_ROOT_WINDOW_ID, 6, 6, W2_WIDTH, W2_HEIGHT, 2, GREEN, WHITE); w3 = GrNewWindow(GR_ROOT_WINDOW_ID, 250, 30, 80, 100, 1, LTGRAY, GREEN); w4 = GrNewWindow(GR_ROOT_WINDOW_ID, 350, 20, 200, 150, 5, BLACK, WHITE); w5 = GrNewWindow(GR_ROOT_WINDOW_ID, 11, 143, 209, 100, 1, BLUE, GREEN); p1 = GrNewPixmap(200,200,0); GrSelectEvents(w1, GR_EVENT_MASK_BUTTON_DOWN | GR_EVENT_MASK_KEY_DOWN | GR_EVENT_MASK_EXPOSURE | GR_EVENT_MASK_FOCUS_IN | GR_EVENT_MASK_FOCUS_OUT | GR_EVENT_MASK_CLOSE_REQ); GrSelectEvents(w2, GR_EVENT_MASK_BUTTON_UP | GR_EVENT_MASK_CLOSE_REQ); GrSelectEvents(w3, GR_EVENT_MASK_BUTTON_DOWN | GR_EVENT_MASK_MOUSE_MOTION | GR_EVENT_MASK_CLOSE_REQ); GrSelectEvents(w4, GR_EVENT_MASK_BUTTON_DOWN | GR_EVENT_MASK_BUTTON_UP | GR_EVENT_MASK_MOUSE_POSITION | GR_EVENT_MASK_KEY_DOWN | GR_EVENT_MASK_CLOSE_REQ); GrSelectEvents(w5, GR_EVENT_MASK_MOUSE_ENTER | GR_EVENT_MASK_MOUSE_EXIT | GR_EVENT_MASK_CLOSE_REQ); GrSelectEvents(GR_ROOT_WINDOW_ID, GR_EVENT_MASK_BUTTON_DOWN | GR_EVENT_MASK_CLOSE_REQ); GrMapWindow(w1); GrMapWindow(w2); GrMapWindow(w3); GrMapWindow(w4); GrMapWindow(w5); gc1 = GrNewGC(); gc2 = GrNewGC(); gc3 = GrNewGC(); gc4 = GrNewGC(); GrSetGCForeground(gc1, RED); GrSetGCBackground(gc1, BROWN); GrSetGCForeground(gc2, MAGENTA); GrSetGCMode(gc4, GR_MODE_XOR); bitmap1fg[0] = MASK(_,_,_,X,_,_,_); bitmap1fg[1] = MASK(_,_,_,X,_,_,_); bitmap1fg[2] = MASK(_,_,_,X,_,_,_); bitmap1fg[3] = MASK(X,X,X,X,X,X,X); bitmap1fg[4] = MASK(_,_,_,X,_,_,_); bitmap1fg[5] = MASK(_,_,_,X,_,_,_); bitmap1fg[6] = MASK(_,_,_,X,_,_,_); bitmap1bg[0] = MASK(_,_,X,X,X,_,_); bitmap1bg[1] = MASK(_,_,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,_,_); bitmap1bg[6] = MASK(_,_,X,X,X,_,_); bitmap2fg[0] = MASK(_,_,X,X,X,_,_); bitmap2fg[1] = MASK(_,X,_,_,_,X,_); bitmap2fg[2] = MASK(X,_,_,_,_,_,X); bitmap2fg[3] = MASK(X,_,_,_,_,_,X); bitmap2fg[4] = MASK(_,X,_,_,_,X,_); bitmap2fg[5] = MASK(_,_,X,X,X,_,_); bitmap2bg[0] = MASK(_,_,X,X,X,_,_); bitmap2bg[1] = MASK(_,X,X,X,X,X,_); bitmap2bg[2] = MASK(X,X,X,X,X,X,X); bitmap2bg[3] = MASK(X,X,X,X,X,X,X); bitmap2bg[4] = MASK(_,X,X,X,X,X,_); bitmap2bg[5] = MASK(_,_,X,X,X,_,_); GrSetCursor(w1, 7, 7, 3, 3, WHITE, BLACK, bitmap1fg, bitmap1bg); GrSetCursor(w2, 7, 6, 3, 3, WHITE, BLACK, bitmap2fg, bitmap2bg); GrRect(GR_ROOT_WINDOW_ID, gc1, 0, 0, si.cols, si.rows); while (1) { GrGetNextEvent(&event); switch (event.type) { case GR_EVENT_TYPE_BUTTON_DOWN: do_buttondown(&event.button); break; case GR_EVENT_TYPE_BUTTON_UP: do_buttonup(&event.button); break; case GR_EVENT_TYPE_MOUSE_POSITION: case GR_EVENT_TYPE_MOUSE_MOTION: do_motion(&event.mouse); break; case GR_EVENT_TYPE_KEY_DOWN: do_keystroke(&event.keystroke); break; case GR_EVENT_TYPE_EXPOSURE: do_exposure(&event.exposure); break; case GR_EVENT_TYPE_FOCUS_IN: do_focusin(&event.general); break; case GR_EVENT_TYPE_FOCUS_OUT: do_focusout(&event.general); break; case GR_EVENT_TYPE_MOUSE_ENTER: do_enter(&event.general); break; case GR_EVENT_TYPE_MOUSE_EXIT: do_exit(&event.general); break; case GR_EVENT_TYPE_CLOSE_REQ: GrClose(); exit(0); case GR_EVENT_TYPE_NONE: do_idle(); break; } } }
int main() { int fd = open(bri_name, O_WRONLY); if ( fd < 0) { perror(bri_name); return 1; } char buff[10]; int notquit = 1, val= read_val(bri_name), max = read_val("/sys/class/backlight/s3c/max_brightness"); if ( max <= 0) return 1; GR_WINDOW_ID wid; /* window id */ GR_GC_ID gc; /* graphics context id */ GR_EVENT event; /* current event */ GR_SCREEN_INFO si; /* screen information */ if (GrOpen() < 0) { fprintf(stderr, "Cannot open graphics\n"); return 1; } GrGetScreenInfo(&si); printf("R=%d C=%d\n", si.rows, si.cols); wid = GrNewWindow(GR_ROOT_WINDOW_ID, 50, 50, max, HEIGHT, 1, BLACK, WHITE); GR_WM_PROPERTIES props; props.title = "Nx Light"; props.flags = GR_WM_FLAGS_TITLE; GrSetWMProperties( wid, &props); GrSelectEvents(wid, GR_EVENT_MASK_CLOSE_REQ | GR_EVENT_MASK_EXPOSURE | GR_EVENT_MASK_MOUSE_MOTION | GR_EVENT_MASK_BUTTON_UP | GR_EVENT_MASK_BUTTON_DOWN ); GrMapWindow(wid); gc = GrNewGC(); while (notquit) { GrGetNextEvent(&event); switch (event.type) { case GR_EVENT_TYPE_MOUSE_MOTION: if ( !((GR_EVENT_MOUSE *)&event)->buttons ) break; if ( (event.mouse.x > 0) && (event.mouse.x < max)) { snprintf(buff, 9, "%d\n", val = event.mouse.x); write( fd, buff, strlen(buff)); } GrSetGCForeground(gc, WHITE); GrFillRect(wid, gc, 0, 0, val, HEIGHT); GrSetGCForeground(gc, BLACK); GrFillRect(wid, gc, val, 0, max+1, HEIGHT); break; case GR_EVENT_TYPE_EXPOSURE: if (event.exposure.wid == wid) GrSetGCForeground(gc, WHITE); GrFillRect(wid, gc, 0, 0, val, HEIGHT); GrSetGCForeground(gc, BLACK); GrFillRect(wid, gc, val, 0, max+1, HEIGHT); break; case GR_EVENT_TYPE_CLOSE_REQ: notquit = 0; } } close(fd); return 0; }
int main(int argc,char **argv) { GR_COORD x; GR_COORD y; GR_SIZE width; GR_SIZE height; GR_COORD rightx; /* x coordinate for right half stuff */ GR_BOOL setsize; /* TRUE if size of board is set */ GR_BOOL setmines; /* TRUE if number of mines is set */ GR_SIZE newsize = 10; /* desired size of board */ GR_COUNT newmines = 25; /* desired number of mines */ GR_WM_PROPERTIES props; setmines = GR_FALSE; setsize = GR_FALSE; argc--; argv++; while ((argc > 0) && (**argv == '-')) { switch (argv[0][1]) { case 'm': if (argc <= 0) { fprintf(stderr, "Missing mine count\n"); exit(1); } argc--; argv++; newmines = atoi(*argv); setmines = GR_TRUE; break; case 's': if (argc <= 0) { fprintf(stderr, "Missing size\n"); exit(1); } argc--; argv++; newsize = atoi(*argv); setsize = GR_TRUE; break; default: fprintf(stderr, "Unknown option \"-%c\"\n", argv[0][1]); exit(1); } argc--; argv++; } if (argc > 0) savefile = *argv; srand(time(0)); readgame(savefile); if (setsize) { if ((newsize < MINSIZE) || (newsize > MAXSIZE)) { fprintf(stderr, "Illegal board size\n"); exit(1); } if (newsize != size) { if (steps && playing) { fprintf(stderr, "Cannot change size while game is in progress\n"); exit(1); } playing = GR_FALSE; size = newsize; if (!playing) mines = (size * size * MINEPERCENT) / 100; } } if (setmines) { if ((newmines <= 0) || ((newmines > (size * size) / 2))) { fprintf(stderr, "Illegal number of mines\n"); exit(1); } if (newmines != mines) { if (steps && playing) { fprintf(stderr, "Cannot change mines while game is in progress\n"); exit(1); } playing = GR_FALSE; mines = newmines; } } findindex(); /* * Parameters of the game have been verified. * Now open the graphics and play the game. */ if (GrOpen() < 0) { fprintf(stderr, "Cannot open graphics\n"); exit(1); } GrReqShmCmds(655360); /* Test by Morten Rolland for shm support */ GrGetScreenInfo(&si); GrGetFontInfo(0, &fi); charheight = fi.height; /* * Create the main window which will contain all the others. */ #if 0 COLS = si.cols - 40; #else COLS = si.cols; #endif ROWS = si.rows - 80; mainwid = GrNewWindow(GR_ROOT_WINDOW_ID, 0, 0, COLS, ROWS, 0, BLACK, WHITE); /* set title */ props.flags = GR_WM_FLAGS_TITLE | GR_WM_FLAGS_PROPS; props.props = GR_WM_PROPS_APPFRAME | GR_WM_PROPS_CAPTION; props.title = "Land Mine"; GrSetWMProperties(mainwid, &props); /* * Create the board window which lies at the left side. * Make the board square, and as large as possible while still * leaving room to the right side for statistics and buttons. */ width = COLS - RIGHTSIDE - (si.xdpcm * RIGHTGAP / 10) - BOARDBORDER * 2; height = (((long) width) * si.ydpcm) / si.xdpcm; if (height > ROWS /* - y * 2*/) { height = ROWS - BOARDBORDER * 2; width = (((long) height) * si.xdpcm) / si.ydpcm; } xp = width / size; yp = height / size; width = xp * size - 1; height = yp * size - 1; x = BOARDBORDER; y = (ROWS - height) / 2; rightx = x + width + (si.xdpcm * RIGHTGAP / 10); boardwid = GrNewWindow(mainwid, x, y, width, height, BOARDBORDER, BLUE, WHITE); /* * Create the buttons. */ x = rightx; y = (si.ydpcm * BOARDGAP / 10); quitwid = GrNewWindow(mainwid, x, y, BUTTONWIDTH, BUTTONHEIGHT, 1, RED, WHITE); y += (si.ydpcm * BUTTONGAP / 10); savewid = GrNewWindow(mainwid, x, y, BUTTONWIDTH, BUTTONHEIGHT, 1, GREEN, WHITE); y += (si.ydpcm * BUTTONGAP / 10); newgamewid = GrNewWindow(mainwid, x, y, BUTTONWIDTH, BUTTONHEIGHT, 1, GREEN, WHITE); /* * Create the statistics window. */ x = rightx; y += (si.ydpcm * STATUSGAP / 10); width = COLS - x; height = ROWS - y; statwid = GrNewWindow(mainwid, x, y, width, height, 0, 0, 0); statwidth = width; statheight = height; /* * Create the GC for drawing the board. */ boardgc = GrNewGC(); cleargc = GrNewGC(); delaygc = GrNewGC(); redgc = GrNewGC(); greengc = GrNewGC(); statgc = GrNewGC(); blackgc = GrNewGC(); buttongc = GrNewGC(); xorgc = GrNewGC(); GrSetGCBackground(boardgc, BLUE); GrSetGCForeground(cleargc, BLUE); GrSetGCForeground(redgc, RED); GrSetGCForeground(greengc, GREEN); GrSetGCForeground(statgc, GRAY); GrSetGCForeground(delaygc, BLACK); GrSetGCForeground(blackgc, BLACK); GrSetGCMode(delaygc, GR_MODE_XOR); GrSetGCMode(xorgc, GR_MODE_XOR); GrSetGCUseBackground(boardgc, GR_FALSE); GrSetGCUseBackground(buttongc, GR_FALSE); GrSelectEvents(mainwid, GR_EVENT_MASK_CLOSE_REQ); GrSelectEvents(boardwid, GR_EVENT_MASK_EXPOSURE | GR_EVENT_MASK_BUTTON_DOWN | GR_EVENT_MASK_KEY_DOWN); GrSelectEvents(statwid, GR_EVENT_MASK_EXPOSURE); GrSelectEvents(quitwid, GR_EVENT_MASK_EXPOSURE | GR_EVENT_MASK_BUTTON_DOWN); GrSelectEvents(newgamewid, GR_EVENT_MASK_EXPOSURE | GR_EVENT_MASK_BUTTON_DOWN); GrSelectEvents(savewid, GR_EVENT_MASK_EXPOSURE | GR_EVENT_MASK_BUTTON_DOWN); setcursor(); GrMapWindow(mainwid); GrMapWindow(boardwid); GrMapWindow(statwid); GrMapWindow(quitwid); GrMapWindow(savewid); GrMapWindow(newgamewid); if (!playing) newgame(); while (GR_TRUE) { GR_EVENT event; GrGetNextEvent(&event); handleevent(&event); } }
/// 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[]) { 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; }
int main(int argc, char *argv[]){ if ( GrOpen() < 0){ //error("Couldn't connect to Nano-X server!\n"); fprintf ( stderr, "Couldn't connect to Nano-X server!\n"); exit(-1); } lgsmh = lgsm_init(LGSMD_DEVICE_GSMD); if (!lgsmh) { fprintf(stderr, "Can't connect to gsmd\n"); exit(1); } //pin_init(lgsmh, pin); event_init(lgsmh); int gsm_fd = lgsm_fd(lgsmh); lgsm_register_handler(lgsmh, GSMD_MSG_VOICECALL, call_msghandler); dialer_window = GrNewWindow(GR_ROOT_WINDOW_ID, 0, 120, 176, 180, 0, MWNOCOLOR, 0); GrSelectEvents(dialer_window, GR_EVENT_MASK_BUTTON_DOWN ); int rc; char buf[STDIN_BUF_SIZE+1]; while ( 1 ){ fd_set readset; FD_SET(0, &readset); FD_SET(gsm_fd, &readset); rc = select(gsm_fd+1, &readset, NULL, NULL, NULL); if (rc <= 0) break; if (FD_ISSET(gsm_fd, &readset)) { /* we've received something on the gsmd socket, pass it * on to the library */ rc = read(gsm_fd, buf, sizeof(buf)); if (rc <= 0) { printf("ERROR reading from gsm_fd\n"); break; } rc = lgsm_handle_packet(lgsmh, buf, rc); } GrGetNextEvent(&event); switch(event.type) { case GR_EVENT_TYPE_KEY_DOWN: printf ( "!got keyboard event, event.keystroke.ch = %i\n", event.keystroke.ch ); int k; switch(event.keystroke.ch) { case Key_Green: printf("Answer\n"); lgsm_voice_in_accept(lgsmh); break; case Key_Red: printf("Hangup\n"); lgsm_voice_hangup(lgsmh); break; default: break; } break; case GR_EVENT_TYPE_CLOSE_REQ: case GR_EVENT_TYPE_SCREENSAVER: case GR_EVENT_TYPE_TIMER: case GR_EVENT_TYPE_NONE: break; default: fprintf(stderr, "Got unknown event type %d\n", event.type); break; } } }
int main(int argc, char **argv) { FILE *file; GR_EVENT event; GR_WINDOW_ID window; if (GrOpen() < 0) { fprintf(stderr, "cannot open graphics\n"); exit(1); } window = GrNewWindowEx(GR_WM_PROPS_APPWINDOW, "ftdemo", GR_ROOT_WINDOW_ID, 50,50, MAXW,MAXH, WHITE); GrMapWindow(window); gid = GrNewGC (); GrSelectEvents(window, GR_EVENT_MASK_KEY_DOWN | GR_EVENT_MASK_CLOSE_REQ | GR_EVENT_MASK_EXPOSURE); if ((file = fopen("/demo/ftdemo.txt", "r")) == NULL) { printf("Can't open text file\n"); return (-1); } n = 0; if(fgets(buffer, 128, file) != NULL) { for (n = 0; n < 128 && buffer[n]; n++) { if (buffer[n] == '\n') break; } } fclose(file); fontid = GrCreateFontEx(FONTNAME, 20, 20, NULL); fontid2 = GrCreateFontEx(FONTNAME, 36, 36, NULL); Render(window); while (1) { GrGetNextEvent(&event); switch (event.type) { case GR_EVENT_TYPE_KEY_DOWN: switch(event.keystroke.ch) { case 171: /* + */ case '+': case '=': angle += 100; /* Increase 10 degrees */ angle %= 3600; break; case 173: /* - */ case '-': case '_': angle -= 100; /* Decrease 10 degrees */ angle %= 3600; break; case 'a': aa = !aa; break; case 'b': bold = !bold; break; case 'k': kerning = !kerning; break; case 'l': state = (state == GR_TFBOTTOM)?GR_TFBASELINE: (state == GR_TFBASELINE)?GR_TFTOP:GR_TFBOTTOM; break; case 'u': underline = underline? GR_FALSE: GR_TRUE; break; default: continue; /* Unknown keystroke */ } Render(window); break; case GR_EVENT_TYPE_EXPOSURE: Render(window); break; case GR_EVENT_TYPE_CLOSE_REQ: GrClose(); exit(0); } } return 0; }
int main(int ac,char **av) { GR_WINDOW_ID w, w2; GR_GC_ID gc; GR_EVENT event; GR_WM_PROPERTIES props; if (GrOpen() < 0) { printf("Can't open graphics\n"); exit(1); } /* pass errors through main loop*/ GrSetErrorHandler(NULL); #define WIDTH 320 #define HEIGHT 240 w = GrNewWindow(GR_ROOT_WINDOW_ID, 20, 20, WIDTH, HEIGHT, 0, GREEN, BLACK); w2 = GrNewWindow(w, 20, 20, 40, 40, 0, WHITE, BLACK); props.flags = GR_WM_FLAGS_PROPS | GR_WM_FLAGS_TITLE; props.props = GR_WM_PROPS_NOBACKGROUND; props.title = "Nano-X Demo2"; GrSetWMProperties(w, &props); gc = GrNewGC(); GrSelectEvents(w, GR_EVENT_MASK_EXPOSURE | GR_EVENT_MASK_CLOSE_REQ | GR_EVENT_MASK_BUTTON_DOWN | GR_EVENT_MASK_KEY_DOWN | GR_EVENT_MASK_KEY_UP); GrMapWindow(w); GrSetFocus(w); /* serious bug here: when wm running, w2 is mapped anyway!!*/ /*GrMapWindow(w2);*/ for (;;) { /*GR_EVENT_KEYSTROKE *kev;*/ GrGetNextEvent(&event); switch (event.type) { case GR_EVENT_TYPE_EXPOSURE: GrSetGCForeground(gc,GrGetSysColor(GR_COLOR_APPWINDOW)); GrFillRect(w, gc, event.exposure.x, event.exposure.y, event.exposure.width, event.exposure.height); GrSetGCForeground(gc, GrGetSysColor(GR_COLOR_APPTEXT)); GrSetGCUseBackground(gc, GR_FALSE); GrText(w, gc, 10, 30, "Hello World", -1, GR_TFASCII); GrRect(w, gc, 5, 5, 300, 60); break; case GR_EVENT_TYPE_CLOSE_REQ: GrClose(); exit(0); break; case GR_EVENT_TYPE_ERROR: printf("\7demo2: Error (%s) ", event.error.name); printf(nxErrorStrings[event.error.code],event.error.id); break; #if 0 case GR_EVENT_TYPE_BUTTON_DOWN: /* test server error on bad syscall*/ GrMapWindow(w2); GrMoveWindow(GR_ROOT_WINDOW_ID, 0, 0); { GR_SCREEN_INFO sinfo; GrGetScreenInfo(&sinfo); } break; #endif #if 0 case GR_EVENT_TYPE_KEY_DOWN: kev = (GR_EVENT_KEYSTROKE *)&event; printf("DOWN %d (%04x) %04x\n", kev->ch, kev->ch, kev->modifiers); break; case GR_EVENT_TYPE_KEY_UP: kev = (GR_EVENT_KEYSTROKE *)&event; printf("UP %d (%04x) %04x\n", kev->ch, kev->ch, kev->modifiers); break; #endif } } GrClose(); return 0; }
int main(int argc,char **argv) { GR_EVENT event; /* current event */ struct app_info * act; int width, height; #ifdef USE_WEIRD_POINTER GR_BITMAP bitmap1fg[7]; /* bitmaps for first cursor */ GR_BITMAP bitmap1bg[7]; #endif for(act = Apps; act->app_id[0] != '\0'; act++, num_apps++); if (GrOpen() < 0) { GrError("cannot open graphics\n"); return 1; } GrGetScreenInfo(&si); signal(SIGCHLD, &reaper); gc = GrNewGC(); bgc = GrNewGC(); GrSetGCForeground(bgc, GRAY); GrSetGCFont(gc, GrCreateFontEx(GR_FONT_SYSTEM_FIXED, 0, 0, NULL)); GrGetGCTextSize(gc, "A", 1, GR_TFASCII, &fwidth, &fheight, &fbase); width = fwidth * 8 + 4; height = (fheight) * num_apps + 4; w1 = GrNewWindow(GR_ROOT_WINDOW_ID, 5, 5, width, height, 1, WHITE, BLACK); GrSelectEvents(w1, GR_EVENT_MASK_EXPOSURE | GR_EVENT_MASK_BUTTON_DOWN | GR_EVENT_MASK_CLOSE_REQ); GrSelectEvents(GR_ROOT_WINDOW_ID, GR_EVENT_MASK_EXPOSURE | GR_EVENT_MASK_CHLD_UPDATE); GrMapWindow(w1); #ifdef USE_WEIRD_POINTER bitmap1bg[0] = MASK(_,_,X,X,X,_,_); bitmap1bg[1] = MASK(_,X,X,X,X,X,_); bitmap1bg[2] = MASK(_,X,X,X,X,X,_); bitmap1bg[3] = MASK(_,X,X,X,X,X,_); bitmap1bg[4] = MASK(_,X,X,X,X,X,_); bitmap1bg[5] = MASK(_,X,X,X,X,X,_); bitmap1bg[6] = MASK(X,X,X,X,X,X,X); bitmap1fg[0] = MASK(_,_,_,_,_,_,_); bitmap1fg[1] = MASK(_,_,_,X,_,_,_); bitmap1fg[2] = MASK(_,_,X,X,X,_,_); bitmap1fg[3] = MASK(_,_,X,X,X,_,_); bitmap1fg[4] = MASK(_,_,X,X,X,_,_); bitmap1fg[5] = MASK(_,_,X,X,X,_,_); bitmap1fg[6] = MASK(_,X,X,X,X,X,_); GrSetCursor(w1, 7, 7, 3, 3, WHITE, BLACK, bitmap1fg, bitmap1bg); #endif GrFillRect(GR_ROOT_WINDOW_ID, bgc, 0, 0, si.cols, si.rows); GrSetGCForeground(gc, BLACK); GrSetGCBackground(gc, WHITE); while (1) { GrGetNextEvent(&event); switch (event.type) { case GR_EVENT_TYPE_EXPOSURE: do_exposure(&event.exposure); break; case GR_EVENT_TYPE_BUTTON_DOWN: do_buttondown(&event.button); break; case GR_EVENT_TYPE_BUTTON_UP: do_buttonup(&event.button); break; case GR_EVENT_TYPE_UPDATE: do_update(&event.update); break; case GR_EVENT_TYPE_MOUSE_POSITION: do_mouse(&event.mouse); break; case GR_EVENT_TYPE_CLOSE_REQ: GrClose(); return 0; } } }
int main(int argc,char **argv) { int t; GR_IMAGE_ID image_id; GR_WINDOW_ID window_id; GR_GC_ID gc_id; GR_SIZE w = -1; GR_SIZE h = -1; GR_EVENT event; GR_SCREEN_INFO sinfo; GR_IMAGE_INFO info; char title[256]; if (argc < 2) { GrError("Usage: nxview [-p] [-s] <image file>\n"); return 1; } t = 1; while ( t < argc ) { if ( !strcmp("-p",argv[t])) { pflag = 1; ++t; continue; } if ( !strcmp("-s",argv[t])) { sflag = 1; ++t; continue; } break; } if (GrOpen() < 0) { GrError("cannot open graphics\n"); return 1; } if (!(image_id = GrLoadImageFromFile(argv[t], 0))) { GrError("Can't load image file: %s\n", argv[t]); return 1; } if(sflag) { /* stretch to half screen size*/ GrGetScreenInfo(&sinfo); w = sinfo.cols/2; h = sinfo.rows/2; } else { GrGetImageInfo(image_id, &info); w = info.width; h = info.height; } sprintf(title, "nxview %s", argv[t]); window_id = GrNewWindowEx(GR_WM_PROPS_APPWINDOW, title, GR_ROOT_WINDOW_ID, 0, 0, w, h, GRAY); GrSelectEvents(window_id, GR_EVENT_MASK_CLOSE_REQ|GR_EVENT_MASK_EXPOSURE); GrMapWindow(window_id); gc_id = GrNewGC(); while (1) { GrGetNextEvent(&event); switch(event.type) { case GR_EVENT_TYPE_CLOSE_REQ: GrDestroyWindow(window_id); GrDestroyGC(gc_id); GrFreeImage(image_id); GrClose(); return 0; /* no return*/ case GR_EVENT_TYPE_EXPOSURE: if (pflag) { int x, y; GR_WINDOW_INFO wi; GrGetWindowInfo(window_id, &wi); for (x=0; x<wi.width; x+=CX*2) for (y=0; y<wi.height; y+=CY) { if (y & CY) GrFillRect(window_id, gc_id, x, y, CX, CY); else GrFillRect(window_id, gc_id, x+CX, y, CX, CY); } } GrDrawImageToFit(window_id, gc_id, 0,0, w,h, image_id); break; } } return 0; }
int main(int argc, char *argv[]) #endif { GR_EVENT event; GR_WM_PROPERTIES props; win window; if(GrOpen() < 0) { fprintf(stderr, "Couldn't connect to Nano-X server!\n"); exit(1); } /* pass errors through main loop, don't exit*/ GrSetErrorHandler(NULL); GrGetScreenInfo(&si); /* add root window*/ window.wid = GR_ROOT_WINDOW_ID; window.pid = GR_ROOT_WINDOW_ID; window.type = WINDOW_TYPE_ROOT; window.clientid = 1; window.sizing = GR_FALSE; window.active = 0; window.data = NULL; add_window(&window); GrSelectEvents(GR_ROOT_WINDOW_ID, GR_EVENT_MASK_CHLD_UPDATE); /* Set new root window background color*/ props.flags = GR_WM_FLAGS_BACKGROUND; props.background = GrGetSysColor(GR_COLOR_DESKTOP); GrSetWMProperties(GR_ROOT_WINDOW_ID, &props); while(1) { GrGetNextEvent(&event); switch(event.type) { case GR_EVENT_TYPE_ERROR: printf("nanowm: error %d\n", event.error.code); break; case GR_EVENT_TYPE_EXPOSURE: do_exposure(&event.exposure); break; case GR_EVENT_TYPE_BUTTON_DOWN: do_button_down(&event.button); break; case GR_EVENT_TYPE_BUTTON_UP: do_button_up(&event.button); break; case GR_EVENT_TYPE_MOUSE_ENTER: do_mouse_enter(&event.general); break; case GR_EVENT_TYPE_MOUSE_EXIT: do_mouse_exit(&event.general); break; case GR_EVENT_TYPE_MOUSE_POSITION: do_mouse_moved(&event.mouse); break; case GR_EVENT_TYPE_KEY_DOWN: do_key_down(&event.keystroke); break; case GR_EVENT_TYPE_KEY_UP: do_key_up(&event.keystroke); break; case GR_EVENT_TYPE_FOCUS_IN: do_focus_in(&event.general); break; case GR_EVENT_TYPE_CHLD_UPDATE: do_update(&event.update); break; default: fprintf(stderr, "Got unexpected event %d\n", event.type); break; } } GrClose(); }
int main(int ac,char **av) { GR_WINDOW_ID w; GR_GC_ID gc; GR_FONT_ID font; GR_WINDOW_INFO wi; if (GrOpen() < 0) { GrError("Can't open graphics\n"); return 1; } //w = GrNewWindowEx(GR_WM_PROPS_APPWINDOW|GR_WM_PROPS_NOBACKGROUND, "Nano-X Demo2", //GR_ROOT_WINDOW_ID, 20, 20, 320, 240, BLACK); w = GrNewWindowEx(GR_WM_PROPS_BORDER|GR_WM_PROPS_NOBACKGROUND, "Nano-X Demo2", GR_ROOT_WINDOW_ID, 20, 20, 320, 240, BLACK); gc = GrNewGC(); //font = GrCreateFontEx("lubI24.pcf", 0, 0, NULL); font = GrCreateFontEx("helvB12.pcf.gz", 0, 0, NULL); GrSetGCFont(gc, font); GrSelectEvents(w, GR_EVENT_MASK_EXPOSURE | GR_EVENT_MASK_CLOSE_REQ | GR_EVENT_MASK_BUTTON_DOWN | GR_EVENT_MASK_KEY_DOWN | GR_EVENT_MASK_KEY_UP); GrMapWindow(w); GrSetFocus(w); // pass errors through main loop GrSetErrorHandler(NULL); for (;;) { GR_EVENT event; GrGetNextEvent(&event); switch (event.type) { case GR_EVENT_TYPE_EXPOSURE: GrSetGCForeground(gc,GrGetSysColor(GR_COLOR_APPWINDOW)); GrFillRect(w, gc, event.exposure.x, event.exposure.y, event.exposure.width, event.exposure.height); GrSetGCForeground(gc, GrGetSysColor(GR_COLOR_APPTEXT)); GrSetGCUseBackground(gc, GR_FALSE); GrText(w, gc, 10, 30, "Hello World", -1, GR_TFASCII); GrRect(w, gc, 5, 5, 300, 60); GrGetWindowInfo(w, &wi); GrError("Exposure:wi.width:%d,wi.height:%d,wi.x:%d,wi.y:%d,wi.parent:%d\n",wi.width,wi.height,wi.x,wi.y,wi.parent); break; case GR_EVENT_TYPE_BUTTON_DOWN: // FIXME unmap window is broken GrUnmapWindow(w); GrFlush(); GrMapWindow(w); //uncomment to test server error on bad syscall //GrMoveWindow(GR_ROOT_WINDOW_ID, 0, 0); GrGetWindowInfo(w, &wi); GrError("Button: wi.width:%d,wi.height:%d,wi.x:%d,wi.y:%d,wi.parent:%d\n",wi.width,wi.height,wi.x,wi.y,wi.parent); break; case GR_EVENT_TYPE_ERROR: GrError("demo2: Error (%s) ", event.error.name); GrError(nxErrorStrings[event.error.code], event.error.id); break; case GR_EVENT_TYPE_CLOSE_REQ: GrClose(); return 0; } } 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; }
int main(int argc, char ** argv) { GR_BITMAP bitmap1fg[7]; /* mouse cursor */ GR_BITMAP bitmap1bg[7]; if (GrOpen() < 0) { fprintf(stderr, "cannot open graphics\n"); exit(1); } GrGetScreenInfo(&si); w1 = GrNewWindow(GR_ROOT_WINDOW_ID, 50, 30, si.cols - 120, si.rows - 60, 1, WHITE, LTBLUE); GrSelectEvents(w1, GR_EVENT_MASK_BUTTON_DOWN | GR_EVENT_MASK_KEY_DOWN | GR_EVENT_MASK_EXPOSURE | GR_EVENT_MASK_FOCUS_IN | GR_EVENT_MASK_FOCUS_OUT | GR_EVENT_MASK_CLOSE_REQ); GrMapWindow(w1); gc1 = GrNewGC(); gc3 = GrNewGC(); GrSetGCForeground(gc1, GRAY); GrSetGCBackground(gc1, LTBLUE); GrSetGCFont(gc1, GrCreateFont(GR_FONT_SYSTEM_FIXED, 0, NULL)); /*GrSetGCFont(gc1, GrCreateFont(GR_FONT_OEM_FIXED, 0, NULL));*/ GrSetGCForeground(gc3, WHITE); GrSetGCBackground(gc3, BLACK); bitmap1fg[0] = MASK(_,_,X,_,X,_,_); bitmap1fg[1] = MASK(_,_,_,X,_,_,_); bitmap1fg[2] = MASK(_,_,_,X,_,_,_); bitmap1fg[3] = MASK(_,_,_,X,_,_,_); bitmap1fg[4] = MASK(_,_,_,X,_,_,_); bitmap1fg[5] = MASK(_,_,_,X,_,_,_); bitmap1fg[6] = MASK(_,_,X,_,X,_,_); bitmap1bg[0] = MASK(_,X,X,X,X,X,_); bitmap1bg[1] = MASK(_,_,X,X,X,_,_); bitmap1bg[2] = MASK(_,_,X,X,X,_,_); bitmap1bg[3] = MASK(_,_,X,X,X,_,_); bitmap1bg[4] = MASK(_,_,X,X,X,_,_); bitmap1bg[5] = MASK(_,_,X,X,X,_,_); bitmap1bg[6] = MASK(_,X,X,X,X,X,_); GrSetCursor(w1, 7, 7, 3, 3, WHITE, BLACK, bitmap1fg, bitmap1bg); /*GrFillRect(GR_ROOT_WINDOW_ID, gc1, 0, 0, si.cols, si.rows);*/ GrSetGCForeground(gc1, BLACK); GrSetGCBackground(gc1, WHITE); text_init(); if (term_init() < 0) { GrClose(); exit(1); } /* we want tfd events also*/ GrRegisterInput(tfd); #if 1 GrMainLoop(HandleEvent); #else while(1) { GR_EVENT ev; GrGetNextEvent(&ev); HandleEvent(&ev); } #endif /* notreached*/ return 0; }
int main(int argc, char **argv) { int t = 1; GR_EVENT event; /* current event */ while (t < argc) { if (!strcmp("-t", argv[t])) { bTextwin = GR_TRUE; ++t; continue; } } if (GrOpen() < 0) { fprintf(stderr, "cannot open graphics\n"); exit(1); } if (bTextwin) { /* create text output window for debugging*/ wt = GrNewWindow(GR_ROOT_WINDOW_ID, 50, 20, TEXTWIN_WIDTH, TEXTWIN_HEIGHT, 5, BLACK, GREEN); GrSelectEvents(wt, GR_EVENT_MASK_CLOSE_REQ | GR_EVENT_MASK_KEY_DOWN | GR_EVENT_MASK_EXPOSURE); GrMapWindow(wt); gct = GrNewGC(); GrSetGCForeground(gct, GREEN); GrGetGCTextSize(gct, "A",1, GR_TFASCII, &width, &height, &base); GrSetGCFont(gct, GrCreateFont(GR_FONT_SYSTEM_FIXED, 0, NULL)); gctb = GrNewGC(); GrSetGCForeground(gctb, BLACK); } /* create scribble input window*/ w = create_scribble(); while (1) { GrGetNextEvent(&event); switch (event.type) { case GR_EVENT_TYPE_BUTTON_DOWN: do_buttondown(&event.button); break; case GR_EVENT_TYPE_BUTTON_UP: do_buttonup(&event.button); break; case GR_EVENT_TYPE_MOUSE_POSITION: case GR_EVENT_TYPE_MOUSE_MOTION: do_motion(&event.mouse); break; case GR_EVENT_TYPE_FOCUS_IN: do_focusin(&event.general); break; case GR_EVENT_TYPE_KEY_DOWN: do_keystroke(&event.keystroke); break; case GR_EVENT_TYPE_EXPOSURE: do_exposure(&event.exposure); break; case GR_EVENT_TYPE_CLOSE_REQ: GrClose(); exit(0); } } }
/* ***********************************************************/ int main(int argc, char* argv[]) { GR_EVENT event; GR_WM_PROPERTIES props; int computer_side; char s[256]; int i; BOOL found; char temp[50]; if (GrOpen() < 0) { fprintf(stderr, "tuxchess: cannot open graphics\n"); exit(1); } load_images(); master = GrNewWindow(GR_ROOT_WINDOW_ID, 0, 0, BM_WIDTH, BM_HEIGHT, 0, WHITE, WHITE); board = GrNewWindow((GR_WINDOW_ID) master, 0, 0, 394, 394, 0, WHITE, WHITE); text = GrNewWindow((GR_WINDOW_ID) master, 0, 393, 394, 20, 0, BLACK, BLACK); GrSelectEvents(master, GR_EVENT_MASK_CLOSE_REQ | GR_EVENT_MASK_EXPOSURE | GR_EVENT_MASK_BUTTON_DOWN); props.flags = GR_WM_FLAGS_PROPS | GR_WM_FLAGS_TITLE; props.props = GR_WM_PROPS_BORDER | GR_WM_PROPS_CAPTION | GR_WM_PROPS_CLOSEBOX; props.title = TITLE; GrSetWMProperties(master, &props); /* eliminate white background*/ props.flags = GR_WM_FLAGS_PROPS; props.props = GR_WM_PROPS_NOBACKGROUND; GrSetWMProperties(board, &props); GrMapWindow(master); GrMapWindow(board); GrMapWindow(text); gc = GrNewGC(); text_gc = GrNewGC(); init(); gen(); max_time = 1 << 25; max_depth = 4; if (argc > 1) computer_side = side; /* computer plays white */ else { computer_side = EMPTY; /* human plays white */ gprintf("Make a move..."); } for (;;) { if (side == computer_side) { /* think about the move and make it */ think(0); if (!pv[0][0].u) { gprintf("No legal moves"); computer_side = EMPTY; continue; } sprintf(temp,"Computer's move: %s\n", move_str(pv[0][0].b)); gprintf(temp); makemove(pv[0][0].b); ply = 0; gen(); print_board(); print_result(); continue; } GrGetNextEvent(&event); switch(event.type) { case GR_EVENT_TYPE_CLOSE_REQ: GrClose(); exit(0); /* no return*/ case GR_EVENT_TYPE_EXPOSURE: print_board(); gprintf(NULL); break; case GR_EVENT_TYPE_BUTTON_DOWN: mouse_hit(event.button.x, event.button.y); break; } if (to != 999) { /* loop through the moves to see if it's legal */ found = FALSE; for (i = 0; i < first_move[1]; ++i) if (gen_dat[i].m.b.from == from && gen_dat[i].m.b.to == to) { found = TRUE; /* get the promotion piece right */ if (gen_dat[i].m.b.bits & 32) switch (s[4]) { case 'N': break; case 'B': i += 1; break; case 'R': i += 2; break; default: i += 3; break; } break; } /* if */ if (!found || !makemove(gen_dat[i].m.b)) gprintf("Illegal move.\n"); else { ply = 0; gen(); print_board(); print_result(); computer_side = side; to = 999; } } /* if to != 999 */ } /* for (;;) */ return(0); /* never reached */ }
int main(int argc, char **argv) { GR_EVENT event; /* current event */ if (GrOpen() < 0) { fprintf(stderr, "cannot open graphics\n"); exit(1); } GrReqShmCmds(65536); /* shared mem is suposed to be faster */ w1 = GrNewWindow(GR_ROOT_WINDOW_ID, 0, 0, WIDTH, HEIGHT, 4, WHITE, BLACK); GrSelectEvents(w1, 0xffffffffl); /* all events :) */ w2 = GrNewWindow(w1, 10, 10, WIDTH / 4, HEIGHT / 4, 4, WHITE, BLACK); GrSelectEvents(w2, 0xffffffffl); /* all events :) */ { GR_WM_PROPERTIES props; props.flags = GR_WM_FLAGS_PROPS | GR_WM_FLAGS_TITLE; props.props = GR_WM_PROPS_BORDER | GR_WM_PROPS_CAPTION | \ GR_WM_PROPS_CAPTION | GR_WM_PROPS_CLOSEBOX; props.title = "nano-X Events"; GrSetWMProperties(w1, &props); } GrMapWindow(w1); GrMapWindow(w2); gc1 = GrNewGC(); GrSetGCForeground(gc1, BLACK); GrSetGCBackground(gc1, WHITE); #ifdef ALT_CURSOR { GR_BITMAP bitmap1fg[7]; /* bitmaps for cursor */ GR_BITMAP bitmap1bg[7]; bitmap1bg[0] = MASK(X,X,X,X,X,X,X); bitmap1bg[1] = MASK(_,X,X,X,X,X,_); bitmap1bg[2] = MASK(_,_,X,X,X,_,_); bitmap1bg[3] = MASK(_,_,_,X,_,_,_); bitmap1bg[4] = MASK(_,_,X,X,X,_,_); bitmap1bg[5] = MASK(_,X,X,X,X,X,_); bitmap1bg[6] = MASK(X,X,X,X,X,X,X); bitmap1fg[0] = MASK(X,X,X,X,X,X,X); bitmap1fg[1] = MASK(_,X,X,X,X,X,_); bitmap1fg[2] = MASK(_,_,X,X,X,_,_); bitmap1fg[3] = MASK(_,_,_,X,_,_,_); bitmap1fg[4] = MASK(_,_,X,X,X,_,_); bitmap1fg[5] = MASK(_,X,X,X,X,X,_); bitmap1fg[6] = MASK(X,X,X,X,X,X,X); GrSetCursor(w1, 7, 7, 3, 3, WHITE, BLACK, bitmap1fg, bitmap1bg); } #endif for (;;) { GrGetNextEvent(&event); printf("%s (0x%x)\n", \ lookupEvent(event.type), event.type); switch(event.type) { case GR_EVENT_TYPE_EXPOSURE: { printf("\twid = %d\n", event.exposure.wid); printf("\t(X, Y) = (%d, %d)\n", \ event.exposure.x, event.exposure.y); printf("\twidth = %d, height = %d\n", \ event.exposure.width, event.exposure.height); } break; case GR_EVENT_TYPE_BUTTON_DOWN: case GR_EVENT_TYPE_BUTTON_UP: { printf("\twid = %d\n", event.button.wid); printf("\tsub-window id = %d\n", event.button.subwid); printf("\troot window (X, Y) coordinates = (%d, %d)\n", \ event.button.rootx, event.button.rooty); printf("\t(X, Y) = (%d, %d)\n", \ event.button.x, event.button.y); printf("\tbuttons: %04X, ", event.button.buttons); printf("changed buttons: %04X\n", event.button.changebuttons); printf("\tmodifiers: %04X\n", event.button.modifiers); } break; case GR_EVENT_TYPE_MOUSE_ENTER: case GR_EVENT_TYPE_MOUSE_EXIT: case GR_EVENT_TYPE_MOUSE_MOTION: case GR_EVENT_TYPE_MOUSE_POSITION: { printf("\twid = %d\n", event.mouse.wid); printf("\tsub-window id = %d\n", event.mouse.subwid); printf("\troot window (X, Y) coordinates = (%d, %d)\n", \ event.mouse.rootx, event.mouse.rooty); printf("\t(X, Y) = (%d, %d)\n", \ event.mouse.x, event.mouse.y); printf("\tbuttons: %04X\n", event.mouse.buttons); printf("\tmodifiers: %04X\n", event.mouse.modifiers); } break; case GR_EVENT_TYPE_KEY_DOWN: case GR_EVENT_TYPE_KEY_UP: { printf("\twid = %d\n", event.keystroke.wid); printf("\tsub-window id = %d\n", event.keystroke.subwid); printf("\troot window (X, Y) coordinates = (%d, %d)\n", \ event.keystroke.rootx, event.keystroke.rooty); printf("\t(X, Y) = (%d, %d)\n", \ event.keystroke.x, event.keystroke.y); printf("\tbuttons: %04X\n", event.keystroke.buttons); printf("\tmodifiers: %04X\n", event.keystroke.modifiers); printf("\tUnicode-16 keyvalue: %d, ASCII: %d\n", \ (int)event.keystroke.ch, event.keystroke.ch); printf("\tscancode: %02X\n", (int)event.keystroke.scancode); } break; case GR_EVENT_TYPE_FOCUS_IN: printf("\twid = %d\n", event.general.wid); printf("\told focus = %d\n", event.general.otherid); break; case GR_EVENT_TYPE_FOCUS_OUT: printf("\twid = %d\n", event.general.wid); printf("\tnew focus = %d\n", event.general.otherid); break; case GR_EVENT_TYPE_UPDATE: case GR_EVENT_TYPE_CHLD_UPDATE: { printf("\twid = %d\n", event.update.wid); printf("\tsub-window id = %d\n", event.update.subwid); printf("\t(X, Y) = (%d, %d)\n", \ event.update.x, event.update.y); printf("\twidth = %d, height = %d\n", \ event.update.width, event.update.height); { GR_UPDATE_TYPE u = event.update.utype; const char* p; p = (u > NR_UPDATES)? \ "<unknown>": \ update_types[u].name; printf("\tupdate_type: %s (%d)\n", p, u); } } break; case GR_EVENT_TYPE_TIMEOUT: printf("\ttimeout?\n"); break; case GR_EVENT_TYPE_CLOSE_REQ: GrClose(); exit(0); /* no return*/ } } return 0; }
int main(int argc,char **argv) { char *imagefile = "bin/slidebmp.bmp"; if (GrOpen() < 0) { GrError("cannot open graphics\n"); exit(1); } gc1 = GrNewGC(); #if USE_IMAGE image = GrNewWindow(GR_ROOT_WINDOW_ID, 300, 0, (WIDTH_IN_TILES * tile_width), (HEIGHT_IN_TILES * tile_height), 4, BLACK, WHITE); if (argc > 1) imagefile = argv[1]; /* need to find out image size.... */ image_addr = malloc(4 * (WIDTH_IN_TILES * tile_width) * (HEIGHT_IN_TILES * tile_height)); image = GrNewPixmap((WIDTH_IN_TILES * tile_width), (HEIGHT_IN_TILES * tile_height), image_addr); GrDrawImageFromFile(image, gc1, 0, 0, GR_IMAGE_MAX_SIZE, GR_IMAGE_MAX_SIZE, imagefile, 0); #endif /* calculate size of tile area */ calc_width = 10 + (WIDTH_IN_TILES * tile_width); calc_height = 15 + 35 + (HEIGHT_IN_TILES * tile_height); #if 0 /* enforce minimum size */ if (calc_width < 240) calc_width=240; if (calc_height < 320) calc_height=320; #endif master = GrNewWindow(GR_ROOT_WINDOW_ID, 0, 0, calc_width, calc_height, 1, RED, WHITE); buttons = GrNewWindow((GR_WINDOW_ID) master, 5, 5, (calc_width - 5), 35, 1, RED, RED); tiles = GrNewWindow((GR_WINDOW_ID) master, (calc_width/2) - (WIDTH_IN_TILES * tile_width /2), 45 + ((calc_height - 50)/2) - (HEIGHT_IN_TILES * tile_height /2), (WIDTH_IN_TILES * tile_width), (HEIGHT_IN_TILES * tile_height), 1, RED, RED); GrMapWindow(master); GrMapWindow(buttons); GrMapWindow(tiles); /* set random seed */ srandom((int) getpid()); RandomiseTiles(); GrSelectEvents(master, GR_EVENT_MASK_EXPOSURE|GR_EVENT_MASK_CLOSE_REQ| GR_EVENT_MASK_KEY_DOWN); GrSelectEvents(buttons, GR_EVENT_MASK_BUTTON_DOWN); GrSelectEvents(tiles, GR_EVENT_MASK_BUTTON_DOWN); RefreshWindow(); while (GR_TRUE) { GR_EVENT event; GrGetNextEvent(&event); HandleEvents(&event); } }
/* * Demo to test child window movement and redrawing */ int main(int ac,char **av) { GR_COORD offset_x = 0, offset_y = 0; GR_WINDOW_ID window1, subwindow1, subsubwin1; GR_WINDOW_ID window2, subwindow2; /*GR_WINDOW_ID subsubwin2;*/ GR_EVENT event; fprintf(stderr,"This is a demo program.\n"); fprintf(stderr,"Left-button drags window\n"); fprintf(stderr,"Right-button raises window\n"); GrOpen(); window1 = GrNewWindow(GR_ROOT_WINDOW_ID, 20, 20, 100, 60, 4, BLACK, BLUE); subwindow1 = GrNewWindow(window1, 5, 5, 90, 50, 4, WHITE, RED); subsubwin1 = GrNewWindow(subwindow1, 10, 10, 10, 10, 2, GREEN, BLUE); window2 = GrNewWindow(GR_ROOT_WINDOW_ID, 20, 100, 100, 60, 4, BLACK, BLUE); subwindow2 = GrNewWindow(window2, 5, 5, 90, 50, 4, WHITE, RED); /* subsubwin2 = GrNewWindow(subwindow2, 10, 10, 10, 10, 2, GREEN, BLUE); */ GrSelectEvents(window1, GR_EVENT_MASK_EXPOSURE | GR_EVENT_MASK_BUTTON_DOWN | GR_EVENT_MASK_BUTTON_UP | GR_EVENT_MASK_MOUSE_ENTER | GR_EVENT_MASK_MOUSE_EXIT | GR_EVENT_MASK_MOUSE_MOTION | GR_EVENT_MASK_CLOSE_REQ); GrSelectEvents(window2, GR_EVENT_MASK_EXPOSURE | GR_EVENT_MASK_BUTTON_DOWN | GR_EVENT_MASK_BUTTON_UP | GR_EVENT_MASK_MOUSE_ENTER | GR_EVENT_MASK_MOUSE_EXIT | GR_EVENT_MASK_MOUSE_MOTION | GR_EVENT_MASK_CLOSE_REQ); GrSelectEvents(subsubwin1, GR_EVENT_MASK_BUTTON_DOWN | 0); GrMapWindow(subsubwin1); GrMapWindow(subwindow1); GrMapWindow(window1); /*GrMapWindow(subsubwin2);*/ GrMapWindow(subwindow2); GrMapWindow(window2); while(1) { GrGetNextEvent(&event); switch (event.type) { case GR_EVENT_TYPE_NONE: break; case GR_EVENT_TYPE_BUTTON_DOWN: offset_x = event.button.x; offset_y = event.button.y; if (event.button.changebuttons & GR_BUTTON_R) { GrRaiseWindow(event.button.wid); } if (event.button.wid == subsubwin1) { GR_WINDOW_INFO winfo; GrGetWindowInfo(subsubwin1, &winfo); if (winfo.parent == subwindow1) { GrReparentWindow(subsubwin1, subwindow2, 10, 10); } else { GrReparentWindow(subsubwin1, subwindow1, 10, 10); } } case GR_EVENT_TYPE_MOUSE_MOTION: if (event.mouse.buttons == GR_BUTTON_L && (event.mouse.wid == window1 || event.mouse.wid == window2)) { GrMoveWindow(event.mouse.wid, event.mouse.rootx - offset_x, event.mouse.rooty - offset_y); } if (event.mouse.buttons == GR_BUTTON_R) { GrResizeWindow(event.mouse.wid, event.mouse.x + 1, event.mouse.y + 1); } break; case GR_EVENT_TYPE_EXPOSURE: /*GrFillRect(event.exposure.wid, defgc, event.exposure.x, event.exposure.y, event.exposure.width, event.exposure.height);*/ break; case GR_EVENT_TYPE_CLOSE_REQ: GrClose(); exit(0); default: fprintf(stderr, "%d\n", event.type); } } GrClose(); }