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();
}
