int start(int argc, char **argv) { GR_SCREEN_INFO si; GR_WM_PROPERTIES props; if (GrOpen() < 0) { printf("Cannot open graphics\n"); exit(1); } GrReqShmCmds(65536); /* Test by Morten Rolland for shm support */ GrGetScreenInfo(&si); #ifdef __ECOS /* 240x320 screen*/ COLS = si.cols - 10; ROWS = si.rows - 40; #else COLS = si.cols - 40; ROWS = si.rows - 80; #endif mainwid = GrNewWindow(GR_ROOT_WINDOW_ID, 0, 0, COLS, ROWS, 0, BLACK, BLACK); /* set title */ props.flags = GR_WM_FLAGS_TITLE | GR_WM_FLAGS_PROPS; props.props = GR_WM_PROPS_BORDER | GR_WM_PROPS_CAPTION; props.title = (GR_CHAR *)"NanoX World Map"; GrSetWMProperties(mainwid, &props); mapwidth = COLS - 2; mapheight = ROWS - 2; mapxorig = mapwidth / 2; mapyorig = mapheight / 2; selectxscale = 4; selectyscale = 3; coordx = 0; coordy = ROWS - 1; mapwid = GrNewWindow(mainwid, 1, 1, mapwidth, mapheight, #if 0 1, BLACK, WHITE); #else 1, LTGRAY, BLACK); #endif GrSelectEvents(mainwid, GR_EVENT_MASK_CLOSE_REQ); GrSelectEvents(mapwid, GR_EVENT_MASK_EXPOSURE | GR_EVENT_MASK_BUTTON_DOWN | GR_EVENT_MASK_BUTTON_UP | GR_EVENT_MASK_MOUSE_POSITION | GR_EVENT_MASK_KEY_DOWN); GrMapWindow(mainwid); GrMapWindow(mapwid); mapgc = GrNewGC(); xorgc = GrNewGC(); GrSetGCMode(xorgc, GR_MODE_XOR); Longitude = ITOF(0); Latitude = ITOF(0); setzoom(ITOF(1)); while (1) checkevent(); }
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; }
void init_game(nstate *state) { GR_WM_PROPERTIES props; GR_COORD x = MAIN_WINDOW_X_POSITION; if(GrOpen() < 0) { fprintf(stderr, "Couldn't connect to Nano-X server\n"); exit(1); } state->fontid = GrCreateFont(NULL, 3, NULL); state->main_window = GrNewWindow(GR_ROOT_WINDOW_ID, x, MAIN_WINDOW_Y_POSITION, MAIN_WINDOW_WIDTH, MAIN_WINDOW_HEIGHT, 0, MAIN_WINDOW_BACKGROUND_COLOUR, 0); /* set title */ props.flags = GR_WM_FLAGS_TITLE | GR_WM_FLAGS_PROPS; props.props = GR_WM_PROPS_BORDER | GR_WM_PROPS_CAPTION | GR_WM_PROPS_CLOSEBOX; props.title = "Nano-Tetris"; GrSetWMProperties(state->main_window, &props); GrSelectEvents(state->main_window, GR_EVENT_MASK_EXPOSURE | GR_EVENT_MASK_CLOSE_REQ | GR_EVENT_MASK_KEY_DOWN | GR_EVENT_MASK_TIMEOUT); state->score_window = GrNewWindow(state->main_window, SCORE_WINDOW_X_POSITION, SCORE_WINDOW_Y_POSITION, SCORE_WINDOW_WIDTH, SCORE_WINDOW_HEIGHT, 0, SCORE_WINDOW_BACKGROUND_COLOUR, 0); GrSelectEvents(state->score_window, GR_EVENT_MASK_EXPOSURE); GrMapWindow(state->score_window); state->scoregcf = GrNewGC(); GrSetGCFont(state->scoregcf, state->fontid); GrSetGCForeground(state->scoregcf, SCORE_WINDOW_FOREGROUND_COLOUR); GrSetGCBackground(state->scoregcf, SCORE_WINDOW_BACKGROUND_COLOUR); state->scoregcb = GrNewGC(); GrSetGCFont(state->scoregcb, state->fontid); GrSetGCForeground(state->scoregcb, SCORE_WINDOW_BACKGROUND_COLOUR); state->next_shape_window = GrNewWindow(state->main_window, NEXT_SHAPE_WINDOW_X_POSITION, NEXT_SHAPE_WINDOW_Y_POSITION, NEXT_SHAPE_WINDOW_WIDTH, NEXT_SHAPE_WINDOW_HEIGHT, 0, NEXT_SHAPE_WINDOW_BACKGROUND_COLOUR, 0); GrSelectEvents(state->next_shape_window, GR_EVENT_MASK_EXPOSURE); GrMapWindow(state->next_shape_window); state->nextshapegcf = GrNewGC(); state->nextshapegcb = GrNewGC(); GrSetGCForeground(state->nextshapegcb, NEXT_SHAPE_WINDOW_BACKGROUND_COLOUR); state->new_game_button = GrNewWindow(state->main_window, NEW_GAME_BUTTON_X_POSITION, NEW_GAME_BUTTON_Y_POSITION, NEW_GAME_BUTTON_WIDTH, NEW_GAME_BUTTON_HEIGHT, 0, BUTTON_BACKGROUND_COLOUR, 0); GrSelectEvents(state->new_game_button, GR_EVENT_MASK_EXPOSURE | GR_EVENT_MASK_BUTTON_DOWN); GrMapWindow(state->new_game_button); state->buttongcf = GrNewGC(); GrSetGCFont(state->buttongcf, state->fontid); GrSetGCForeground(state->buttongcf, BUTTON_FOREGROUND_COLOUR); GrSetGCBackground(state->buttongcf, BUTTON_BACKGROUND_COLOUR); state->buttongcb = GrNewGC(); GrSetGCFont(state->buttongcb, state->fontid); GrSetGCForeground(state->buttongcb, BUTTON_BACKGROUND_COLOUR); state->pause_continue_button = GrNewWindow(state->main_window, PAUSE_CONTINUE_BUTTON_X_POSITION, PAUSE_CONTINUE_BUTTON_Y_POSITION, PAUSE_CONTINUE_BUTTON_WIDTH, PAUSE_CONTINUE_BUTTON_HEIGHT, 0, BUTTON_BACKGROUND_COLOUR, 0); GrSelectEvents(state->pause_continue_button, GR_EVENT_MASK_EXPOSURE | GR_EVENT_MASK_BUTTON_DOWN); state->anticlockwise_button = GrNewWindow(state->main_window, ANTICLOCKWISE_BUTTON_X_POSITION, ANTICLOCKWISE_BUTTON_Y_POSITION, ANTICLOCKWISE_BUTTON_WIDTH, ANTICLOCKWISE_BUTTON_HEIGHT, 0, BUTTON_BACKGROUND_COLOUR, 0); GrSelectEvents(state->anticlockwise_button, GR_EVENT_MASK_EXPOSURE | GR_EVENT_MASK_BUTTON_DOWN); state->clockwise_button = GrNewWindow(state->main_window, CLOCKWISE_BUTTON_X_POSITION, CLOCKWISE_BUTTON_Y_POSITION, CLOCKWISE_BUTTON_WIDTH, CLOCKWISE_BUTTON_HEIGHT, 0, BUTTON_BACKGROUND_COLOUR, 0); GrSelectEvents(state->clockwise_button, GR_EVENT_MASK_EXPOSURE | GR_EVENT_MASK_BUTTON_DOWN); state->left_button = GrNewWindow(state->main_window, LEFT_BUTTON_X_POSITION, LEFT_BUTTON_Y_POSITION, LEFT_BUTTON_WIDTH, LEFT_BUTTON_HEIGHT, 0, BUTTON_BACKGROUND_COLOUR, 0); GrSelectEvents(state->left_button, GR_EVENT_MASK_EXPOSURE | GR_EVENT_MASK_BUTTON_DOWN); state->right_button = GrNewWindow(state->main_window, RIGHT_BUTTON_X_POSITION, RIGHT_BUTTON_Y_POSITION, RIGHT_BUTTON_WIDTH, RIGHT_BUTTON_HEIGHT, 0, BUTTON_BACKGROUND_COLOUR, 0); GrSelectEvents(state->right_button, GR_EVENT_MASK_EXPOSURE | GR_EVENT_MASK_BUTTON_DOWN); state->drop_button = GrNewWindow(state->main_window, DROP_BUTTON_X_POSITION, DROP_BUTTON_Y_POSITION, DROP_BUTTON_WIDTH, DROP_BUTTON_HEIGHT, 0, BUTTON_BACKGROUND_COLOUR, 0); GrSelectEvents(state->drop_button, GR_EVENT_MASK_EXPOSURE | GR_EVENT_MASK_BUTTON_DOWN); state->well_window = GrNewWindow(state->main_window, WELL_WINDOW_X_POSITION, WELL_WINDOW_Y_POSITION, WELL_WINDOW_WIDTH, WELL_WINDOW_HEIGHT, 0, WELL_WINDOW_BACKGROUND_COLOUR, 0); GrSelectEvents(state->well_window, GR_EVENT_MASK_EXPOSURE); GrMapWindow(state->well_window); state->wellgc = GrNewGC(); GrMapWindow(state->main_window); state->state = STATE_STOPPED; state->score = 0; read_hiscore(state); state->level = 0; state->running_buttons_mapped = 0; srandom(time(0)); choose_new_shape(state); new_game(state); }
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 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_OEM_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() { #ifdef TEST_FOR_X Display *display; Window window; GC gc; XGCValues gcValues; Colormap colormap; Pixmap src_pixmap; unsigned long fgColor, bgColor; int screenNum; XPoint points[NUM_POINTS]; #else GR_WINDOW_ID window; GR_WINDOW_ID src_pixmap; unsigned char* src_pixmap_buf[320*240*2]; GR_GC_ID gc; GR_POINT points[NUM_POINTS]; #endif int c, c1, count=4500; int x, y, x1, y1, x2, y2; #ifdef TEST_FOR_X if(!(display=XOpenDisplay(""))) { printf("Cannot connect to X.\n"); } screenNum = DefaultScreen(display); colormap = DefaultColormap(display, screenNum); bgColor = BlackPixel(display, screenNum); fgColor = WhitePixel(display, screenNum); window = XCreateSimpleWindow(display, RootWindow(display, screenNum), 0, 0 , 639, 479, 0, fgColor, bgColor); src_pixmap = XCreatePixmap(display, window, 320, 240, 16); XMapRaised(display, window); gcValues.background = bgColor; gcValues.foreground = fgColor; gcValues.line_width = 1; gcValues.line_style = LineSolid; gcValues.fill_style = FillSolid; gcValues.fill_rule = WindingRule; gcValues.arc_mode = ArcPieSlice; gc = XCreateGC(display, window, GCForeground | GCBackground | GCLineWidth | GCLineStyle | GCFillStyle, &gcValues); #else GrOpen(); window = GrNewWindow(GR_ROOT_WINDOW_ID, 0, 0, 639, 479, 0, BLACK, BLUE); src_pixmap = GrNewPixmap(640, 480, src_pixmap_buf); GrMapWindow(window); gc = GrNewGC(); GrSetGCForeground(gc, WHITE); GrSetGCBackground(gc, BLACK); GrSetGCMode(gc, GR_MODE_COPY); #endif // Horizontal Line //////////////////////////////////////////////// printf("Horizontal Line(XDrawLine)\n"); start_timer(); for(c=0; c<count*20; c++) { y1=random()%480; #ifdef TEST_FOR_X XDrawLine(display, window, gc, 0, y1, 639, y1); XFlush(display); #else GrLine(window, gc, 0, y1, 639, y1); GrFlush(); #endif } end_timer(); #ifdef TEST_FOR_X XClearWindow(display, window); #else GrClearWindow(window, GR_TRUE); #endif // Vertical Line ///////////////////////////////////////////////// printf("Vertical Line(XDrawLine)\n"); start_timer(); for(c=0; c<count*19; c++) { x1=random()%640; #ifdef TEST_FOR_X XDrawLine(display, window, gc, x1, 0, x1, 479); XFlush(display); #else GrLine(window, gc, x1, 0, x1, 479); GrFlush(); #endif } end_timer(); #ifdef TEST_FOR_X XClearWindow(display, window); #else GrClearWindow(window, GR_TRUE); #endif // General Line ///////////////////////////////////////////////// printf("General Line(XDrawLine)\n"); start_timer(); for(c=0; c<count*22; c++) { x1 = random()%640; x2 = random()%640; y1 = random()%480; y2 = random()%480; #ifdef TEST_FOR_X XDrawLine(display, window, gc, x1, y1, x2, y2); XFlush(display); #else GrLine(window, gc, x1, y1, x2, y2); GrFlush(); #endif } end_timer(); #ifdef TEST_FOR_X XClearWindow(display, window); #else GrClearWindow(window, GR_TRUE); #endif // Point ////////////////////////////////////////////////// printf("XPoint\n"); start_timer(); for(c=0; c<count*25; c++) { x1 = random()%640; y1 = random()%480; #ifdef TEST_FOR_X XDrawPoint(display, window, gc, x1, y1); XFlush(display); #else GrPoint(window, gc, x1, y1); GrFlush(); #endif } end_timer(); #ifdef TEST_FOR_X XClearWindow(display, window); #else GrClearWindow(window, GR_TRUE); #endif // Rectangle ////////////////////////////////////////////////// printf("XRectangle\n"); start_timer(); for(c=0; c<count*20; c++) { x1=random()%639; y1=random()%479; x2=random()%(639-x1)+1; y2=random()%(479-y1)+1; #ifdef TEST_FOR_X XDrawRectangle(display, window, gc, x1, y1, x2, y2); XFlush(display); #else GrRect(window, gc, x1, y1, x2, y2); GrFlush(); #endif } end_timer(); #ifdef TEST_FOR_X XClearWindow(display, window); #else GrClearWindow(window, GR_TRUE); #endif // FillRectangle ////////////////////////////////////////////////// printf("XFillRectangle\n"); start_timer(); for(c=0; c<count*18; c++) { x1=random()%639; y1=random()%479; x2=random()%(639-x1)+1; y2=random()%(479-y1)+1; #ifdef TEST_FOR_X XFillRectangle(display, window, gc, x1, y1, x2, y2); XFlush(display); #else GrFillRect(window, gc, x1, y1, x2, y2); GrFlush(); #endif } end_timer(); #ifdef TEST_FOR_X XClearWindow(display, window); #else GrClearWindow(window, GR_TRUE); #endif // FillPolygon ////////////////////////////////////////////////// printf("XFillPolygon\n"); start_timer(); for(c=0; c<count; c++) { for(c1=0; c1<NUM_POINTS; c1++) { points[c1].x = random()%640; points[c1].y = random()%480; } #ifdef TEST_FOR_X XFillPolygon(display, window, gc, points, NUM_POINTS, 0, 0); XFlush(display); #else GrFillPoly(window, gc, NUM_POINTS, points); GrFlush(); #endif } end_timer(); #ifdef TEST_FOR_X XClearWindow(display, window); #else GrClearWindow(window, GR_TRUE); #endif // CopyArea ///////////////////////////////////////////////// printf("XCopyArea\n"); start_timer(); for(c=0; c<count*5; c++) { x1=random()%320; y1=random()%240; x2=random()%319+1; y2=random()%239+1; #ifdef TEST_FOR_X XCopyArea(display, src_pixmap, window, gc, 0, 0, x2, y2, x1, y1); XFlush(display); #else GrCopyArea(window, gc, x1, y1, x2 ,y2, src_pixmap, 0, 0, 0); GrFlush(); #endif } end_timer(); #ifdef TEST_FOR_X XDestroyWindow(display, window); #else GrClose(); #endif }
int main(int argc, char **argv) { GR_WINDOW_ID window; GR_EVENT event; GR_GC_ID gc; GR_FONT_ID fontid; int x, y, rnd = 0; MWLOGFONT lf; char description[128]; srand(time(0)); GrOpen(); window = GrNewWindow(GR_ROOT_WINDOW_ID, 5, 5, MAXW, MAXH, 4, BLACK, BLUE); GrMapWindow(window); gc = GrNewGC(); GrSelectEvents(window,GR_EVENT_MASK_ALL); GrSetGCUseBackground(gc,GR_FALSE); GrSetGCBackground(gc, GR_RGB(0, 0, 0)); y = 30; x = 0; while(1) { GrCheckNextEvent(&event); if(event.type == GR_EVENT_TYPE_CLOSE_REQ) { GrClose(); exit(0); } /*sleep(1);*/ MWLF_Clear(&lf); description[0] = '\0'; /*lf.lfSerif = 1;*/ if ( rnd & 1 ) { lf.lfWeight = MWLF_WEIGHT_BOLD; strcat(description,"Bold "); } if ( rnd & 2 ) { lf.lfItalic = 1; strcat(description,"Italics "); } if ( rnd & 4 ) { lf.lfOblique = 1; strcat(description,"Oblique "); } if ( rnd & 8 ) { lf.lfMonospace = 1; strcat(description,"Monospace "); } else { lf.lfProportional = 1; strcat(description,"Proportional "); } if ( argc > 1 ) strcpy(lf.lfFaceName,argv[1]); else strcpy(lf.lfFaceName,"fantasy"); fontid = GrCreateFont(0, 0, &lf); /* GrSetFontSize(fontid, 1+(int)(80.0 * rand() / (RAND_MAX+1.0))); */ GrSetFontSize(fontid,26); GrSetFontRotation(fontid, 330); /* 33 degrees*/ GrSetFontAttr(fontid, GR_TFKERNING | GR_TFANTIALIAS, 0); GrSetGCFont(gc, fontid); /*GrSetGCBackground(gc, rand() & 0xffffff);*/ GrSetGCForeground(gc, 0xffffff); /* x = (int) ((MAXW * 1.0) *rand()/(RAND_MAX+1.0)); y = (int) ((MAXH * 1.0) *rand()/(RAND_MAX+1.0)); */ GrText(window, gc,x,y, description, -1, GR_TFASCII); GrDestroyFont(fontid); rnd++; y += 30; if ( y > 460 ) y = 0; } GrClose(); }
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; }
void ecos_nx_init(CYG_ADDRWORD data) { GR_SCREEN_INFO si; /* window information */ GR_FONT_INFO fi; /* font information */ GR_WINDOW_ID mainwid; /* main window id */ GR_WM_PROPERTIES props; GR_GC_ID gct = 0; #if 0 NWIDGET *w; NBUTTON *b; NTEXTFIELD *t; #endif cyg_thread_delay(50); INIT_PER_THREAD_DATA(); test_file_io(); if(GrOpen() < 0) { fprintf(stderr, "Couldn't connect to Nano-X server\n"); exit(1); } #if (defined CYGPKG_HAL_ARM_SA11X0_IPAQ) && (!defined CYGBLD_MICROWINDOWS_VNC_DRIVERS) GrSetPortraitMode(MWPORTRAIT_RIGHT); #endif GrGetScreenInfo(&si); GrGetFontInfo(0, &fi); #if 1 mainwid = GrNewWindow(GR_ROOT_WINDOW_ID, 0, 0, si.cols, si.rows, 0, RED, WHITE); props.flags = GR_WM_FLAGS_PROPS; props.props = GR_WM_PROPS_BORDER; GrSetWMProperties(mainwid, &props); GrMapWindow(mainwid); GrFlush(); cyg_thread_delay(50); gct = GrNewGC(); GrSetGCForeground(gct, WHITE); #ifdef CYGPKG_IO_FILEIO { struct stat stat_data; if (0 == stat("/redhat.logo", &stat_data)) { GrDrawImageFromFile(mainwid, gct, 0, 0, si.cols, si.rows, "/redhat.logo", 0); } } #endif #if (defined CYGPKG_HAL_ARM) && (!defined CYGBLD_MICROWINDOWS_VNC_DRIVERS) // Touch sensitive screen calibration, only relevant on some // platforms. GrSetGCFont(gct, GrCreateFont(GR_FONT_GUI_VAR, 0, NULL)); GrText(mainwid, gct, 80, 350, "Tap all 4 corners", 17, GR_TFTOP); GrFlush(); printf("Tap all four corners\n"); cyg_thread_delay(10*100); #endif #else n_init_button_class(); n_init_textfield_class(); w = NEW_NOBJECT(widget); n_widget_init(w, 0); n_widget_resize(w, si.cols - 10, si.rows - 30); n_widget_background(w, "/redhat.logo"); n_widget_show(w); b = NEW_NOBJECT(button); n_button_init(b, w, "Close"); n_button_onclick(b, do_close); n_widget_resize(b, 40, 20); n_widget_move(b,180,260); n_widget_show(b); t = NEW_NOBJECT(textfield); n_textfield_init(t,w,"Tap all 4 corners"); n_widget_move(t,45,220); n_widget_resize(t,120,20); n_widget_show(t); t = NEW_NOBJECT(textfield); n_textfield_init(t,w,"Then press close"); n_widget_move(t,45,250); n_widget_resize(t,120,20); n_widget_show(t); while (!closed) { n_handle_event(); } n_widget_hide(w); n_object_cleanup(w); #endif GrClose(); }
void wm_container_buttondown(win *window, GR_EVENT_BUTTON *event) { struct pos_size *pos; GR_RECT r; GR_COORD cxborder = 0, cyborder = 0; GR_WINDOW_INFO info; GR_WINDOW_INFO cinfo; GR_GC_ID gc; Dprintf("wm_container_buttondown window %d\n", window->wid); if(window->active) return; GrGetWindowInfo(window->wid, &info); GrGetWindowInfo(window->clientid, &cinfo); /* calc border sizes*/ if (info.props & GR_WM_PROPS_BORDER) { cxborder = 1; cyborder = 1; } if (info.props & GR_WM_PROPS_APPFRAME) { cxborder = CXBORDER; cyborder = CYBORDER; } /* Check for close box press*/ if ((info.props & (GR_WM_PROPS_CAPTION|GR_WM_PROPS_CLOSEBOX)) == (GR_WM_PROPS_CAPTION|GR_WM_PROPS_CLOSEBOX)) { /* Get close box rect*/ r.x = info.width - CXCLOSEBOX - cxborder - 2; r.y = cyborder + 2; r.width = CXCLOSEBOX; r.height = CYCLOSEBOX; /* Check mousedn in close box*/ if (PtInRect(&r, event->x, event->y)) { /* close on button up*/ window->close = GR_TRUE; return; } } /* Set focus on button down*/ GrSetFocus(window->clientid); /* check for corner resize */ r.x = info.width - 5; r.y = info.height - 5; r.width = 5; r.height = 5; if (PtInRect(&r,event->x, event->y) && !(info.props & GR_WM_PROPS_NORESIZE) && !(cinfo.props & GR_WM_PROPS_NORESIZE)) { #if !NO_CORNER_RESIZE struct pos_size * pos; if(!window->data) if(!(window->data = malloc(sizeof(struct pos_size)))) return; window->sizing = GR_TRUE; /* save off the width/height offset from the window manager */ GrGetWindowInfo(window->clientid,&info); pos = (struct pos_size*)window->data; pos->xoff = -info.width; pos->yoff = -info.height; GrGetWindowInfo(window->wid,&info); pos->xoff += info.width; pos->yoff += info.height; gc = GrNewGC(); GrSetGCMode(gc, GR_MODE_XOR|GR_MODE_EXCLUDECHILDREN); GrRect(GR_ROOT_WINDOW_ID,gc,info.x, info.y, info.width, info.height); GrDestroyGC(gc); /* save this rectangle's width/height so we can erase it later */ pos->width = info.width; pos->height = info.height; return; #endif /* !NO_CORNER_RESIZE*/ } else GrSetWindowCursor(window->wid, 0); /* if not in caption, return (FIXME, not calc'd exactly)*/ if (!(info.props & GR_WM_PROPS_CAPTION)) return; /* Get caption box rect*/ r.x = cxborder; r.y = cyborder; r.width = info.width - cxborder*2; r.height = CYCAPTION; /* Check for mousedn in caption box*/ if (!PtInRect(&r, event->x, event->y)) return; /* Raise window if mouse down and allowed*/ if (!(info.props & GR_WM_PROPS_NORAISE) && !(cinfo.props & GR_WM_PROPS_NORAISE)) GrRaiseWindow(window->wid); /* Don't allow window move if NOMOVE property set*/ if ((info.props & GR_WM_PROPS_NOMOVE) || (cinfo.props & GR_WM_PROPS_NOMOVE)) return; if(!window->data) if(!(window->data = malloc(sizeof(struct pos_size)))) return; GrGetWindowInfo(window->wid,&info); pos = (struct pos_size *)window->data; pos->xoff = event->x; pos->yoff = event->y; #if OUTLINE_MOVE pos->xorig = info.x; pos->yorig = info.y; pos->width = info.width; pos->height = info.height; gc = GrNewGC(); GrSetGCMode(gc, GR_MODE_XOR|GR_MODE_EXCLUDECHILDREN); GrRect(GR_ROOT_WINDOW_ID, gc,info.x, info.y, info.width, info.height); GrDestroyGC(gc); #endif window->active = GR_TRUE; }
static int NX_CreateWindow (_THIS, SDL_Surface * screen, int w, int h, int bpp, Uint32 flags) { Dprintf ("enter NX_CreateWindow\n") ; // If a window is already present, destroy it and start fresh if (SDL_Window && SDL_Window != GR_ROOT_WINDOW_ID) { NX_DestroyWindow (this, screen) ; } // See if we have been given a window id if (SDL_windowid) { SDL_Window = SDL_strtol (SDL_windowid, NULL, 0) ; } else { SDL_Window = 0 ; } if ( ! SDL_ReallocFormat (screen, bpp, SDL_Visual.red_mask, SDL_Visual.green_mask, SDL_Visual.blue_mask, 0)) return -1; // Create (or use) the nanox display window if (! SDL_windowid) { SDL_Window = GrNewWindow (GR_ROOT_WINDOW_ID, 0, 0, w, h, 0, BLACK, WHITE) ; GrSelectEvents (SDL_Window, (GR_EVENT_MASK_EXPOSURE | GR_EVENT_MASK_BUTTON_DOWN | GR_EVENT_MASK_BUTTON_UP | GR_EVENT_MASK_FOCUS_IN | GR_EVENT_MASK_FOCUS_OUT | GR_EVENT_MASK_KEY_DOWN | GR_EVENT_MASK_KEY_UP | GR_EVENT_MASK_MOUSE_ENTER | GR_EVENT_MASK_MOUSE_EXIT | GR_EVENT_MASK_MOUSE_MOTION | GR_EVENT_MASK_UPDATE | GR_EVENT_MASK_CLOSE_REQ)) ; } /* Create the graphics context here, once we have a window */ SDL_GC = GrNewGC () ; if (SDL_GC == 0) { SDL_SetError("Couldn't create graphics context"); return(-1); } // Map them both and go fullscreen, if requested if (! SDL_windowid) { GrMapWindow (SDL_Window) ; if (flags & SDL_FULLSCREEN) { screen -> flags |= SDL_FULLSCREEN ; NX_EnterFullScreen (this) ; } else { screen -> flags &= ~ SDL_FULLSCREEN ; } } #ifdef ENABLE_NANOX_DIRECT_FB /* attempt allocating the client side framebuffer */ Clientfb = GrOpenClientFramebuffer(); /* NULL return will default to using GrArea()*/ #endif Dprintf ("leave NX_CreateWindow\n") ; return 0 ; }
void wm_container_mousemoved(win *window, GR_EVENT_MOUSE *event) { struct pos_size *pos; GR_GC_ID gc; GR_RECT r; GR_WINDOW_INFO info; Dprintf("wm_container_mousemoved window %d\n", window->wid); GrGetWindowInfo(window->wid, &info); if(window->sizing) { struct pos_size * pos = (struct pos_size*)window->data; /* erase old rectangle */ gc = GrNewGC(); GrSetGCMode(gc, GR_MODE_XOR|GR_MODE_EXCLUDECHILDREN); GrRect(GR_ROOT_WINDOW_ID, gc, info.x, info.y, pos->width, pos->height); /* draw new one */ GrRect(GR_ROOT_WINDOW_ID,gc,info.x, info.y, event->rootx - info.x, event->rooty - info.y); GrDestroyGC(gc); /* save this new rectangle's width, height */ /* I know, this shouldn't be stored in x/y, but... */ pos->width = event->rootx - info.x; pos->height = event->rooty - info.y; return; } #if !NO_CORNER_RESIZE /* check corner resize cursor on/off*/ r.x = info.width - 5; r.y = info.height - 5; r.width = 5; r.height = 5; if (PtInRect(&r,event->x, event->y)) set_resize_cursor(window->wid); else GrSetWindowCursor(window->wid, 0); #endif if(!window->active) return; pos = (struct pos_size *)window->data; #if OUTLINE_MOVE gc = GrNewGC(); GrSetGCMode(gc, GR_MODE_XOR|GR_MODE_EXCLUDECHILDREN); GrRect(GR_ROOT_WINDOW_ID,gc,pos->xorig, pos->yorig, pos->width, pos->height); GrRect(GR_ROOT_WINDOW_ID,gc,event->rootx - pos->xoff, event->rooty - pos->yoff, pos->width, pos->height); pos->xorig = event->rootx - pos->xoff; pos->yorig = event->rooty - pos->yoff; GrDestroyGC(gc); #else GrMoveWindow(window->wid, event->rootx - pos->xoff, event->rooty - pos->yoff); #endif }
void wm_container_buttonup(win *window, GR_EVENT_BUTTON *event) { GR_RECT r; GR_COORD cxborder = 0, cyborder = 0; GR_WINDOW_INFO info; Dprintf("wm_container_buttonup window %d\n", window->wid); GrGetWindowInfo(window->wid, &info); /* Check for close box press*/ if ((info.props & (GR_WM_PROPS_CAPTION|GR_WM_PROPS_CLOSEBOX)) == (GR_WM_PROPS_CAPTION|GR_WM_PROPS_CLOSEBOX)) { /* calc border sizes*/ if (info.props & GR_WM_PROPS_BORDER) { cxborder = 1; cyborder = 1; } if (info.props & GR_WM_PROPS_APPFRAME) { cxborder = CXBORDER; cyborder = CYBORDER; } /* Get close box rect*/ r.x = info.width - CXCLOSEBOX - cxborder - 2; r.y = cyborder + 2; r.width = CXCLOSEBOX; r.height = CYCLOSEBOX; /* Check mouseup in close box*/ if (PtInRect(&r, event->x, event->y)) { if(window->close == GR_TRUE) { /* * This sends a CLOSE_REQ event to the window. * NXLIB clients catch this and convert it * to an X11 ClientMessage with a WM_DELETE_WINDOW * atom, causing the window to close. */ GrCloseWindow(window->clientid); window->close = GR_FALSE; return; } } } window->close = GR_FALSE; if(window->active) { #if OUTLINE_MOVE struct pos_size * pos = (struct pos_size *)window->data; GR_GC_ID gc = GrNewGC(); GrSetGCMode(gc, GR_MODE_XOR|GR_MODE_EXCLUDECHILDREN); GrRect(GR_ROOT_WINDOW_ID, gc, pos->xorig, pos->yorig, pos->width, pos->height); GrMoveWindow(window->wid, pos->xorig, pos->yorig); #endif free(window->data); window->active = GR_FALSE; window->data = 0; } if(window->sizing) { struct pos_size * pos = (struct pos_size *)window->data; GR_GC_ID gc = GrNewGC(); GR_WINDOW_INFO info; GrGetWindowInfo(window->wid, &info); GrSetGCMode(gc, GR_MODE_XOR|GR_MODE_EXCLUDECHILDREN); GrRect(GR_ROOT_WINDOW_ID, gc, info.x, info.y, pos->width, pos->height); GrResizeWindow(window->wid, event->rootx - info.x, event->rooty - info.y); GrResizeWindow(window->clientid, event->rootx - info.x - pos->xoff, event->rooty - info.y - pos->yoff); GrDestroyGC(gc); free(window->data); window->sizing = GR_FALSE; window->data = 0; } }
int start(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) { printf("cannot open graphics\n"); exit(1); } GrGetScreenInfo(&si); //signal(SIGCHLD, &reaper); gc = GrNewGC(); bgc = GrNewGC(); GrSetGCForeground(bgc, GRAY); GrSetGCFont(gc, GrCreateFontEx((GR_CHAR *)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); reaper(); 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(); exit(0); } } }
int main() { GR_WINDOW_ID window; GR_EVENT event; GR_GC_ID gc; GR_FONT_ID fontid; int i, x, y; GR_REGION_ID regionid = 0; #if CLIP_POLYGON GR_POINT points[]={ {100, 100}, {300, 100}, {300, 300}, {100, 300}}; #else GR_RECT clip_rect={100,100,300,300}; #endif srand(time(0)); GrOpen(); window = GrNewWindow(GR_ROOT_WINDOW_ID, 50,50, MAXW,MAXH, 4, BLACK,BLUE); GrMapWindow(window); gc = GrNewGC(); #if CLIP_POLYGON /* polygon clip region*/ regionid = GrNewPolygonRegion(MWPOLY_EVENODD, 3, points); #else /* rectangle clip region*/ regionid = GrNewRegion(); GrUnionRectWithRegion(regionid, &clip_rect); #endif GrSetGCRegion(gc, regionid); GrSelectEvents(window,GR_EVENT_MASK_ALL); GrSetGCUseBackground(gc,GR_FALSE); GrSetGCBackground(gc, GR_RGB(0, 0, 0)); while(1) { GrCheckNextEvent(&event); i = (int)((float)MAXFONTS * rand() / (RAND_MAX + 1.0)); fontid = GrCreateFont(names[i], 20, NULL); GrSetFontSize(fontid, 1+(int)(80.0 * rand() / (RAND_MAX+1.0))); GrSetFontRotation(fontid, 330); /* 33 degrees*/ GrSetFontAttr(fontid, GR_TFKERNING | GR_TFANTIALIAS, 0); GrSetGCFont(gc, fontid); /*GrSetGCBackground(gc, rand() & 0xffffff);*/ GrSetGCForeground(gc, rand() & 0xffffff); x = (int) ((MAXW * 1.0) *rand()/(RAND_MAX+1.0)); y = (int) ((MAXH * 1.0) *rand()/(RAND_MAX+1.0)); #if HAVE_HZK_SUPPORT { /* to test Unicode 16 chinese characters display ,use HZK font Bitmap font (Metrix font). */ #ifndef BIG5 char buffer[256]; buffer[0]=0x6c; buffer[1]=0x49; buffer[2]=0x73; buffer[3]=0x8b; buffer[4]=0x79; buffer[5]=0xd1; buffer[6]=0x62; buffer[7]=0x80; buffer[8]=0x61; buffer[9]=0x00; buffer[10]=0x41; buffer[11]=0x00; buffer[12]=0x00; buffer[13]=0xa1; buffer[14]=0x00; buffer[15]=0xa6; buffer[16]=0x6c; buffer[17]=0x49; buffer[18]=0x0; buffer[19]=0x0; GrText(window, gc,x,y+20, buffer,17, GR_TFUC16); x=0;y=16; GrText(window, gc,x,y+20, buffer,17, GR_TFUC16); #else unsigned short buffer[7]; buffer[0]=0x9060; buffer[1]=0x898b; buffer[2]=0x79d1; buffer[3]=0x6280; buffer[4]=0x0061; buffer[5]=0x0041; buffer[6]=0x0; GrText(window, gc,x,y+20, buffer,7, GR_TFUC16); x=0;y=16; GrText(window, gc,x,y+20, buffer,7, GR_TFUC16); #endif } #ifndef BIG5 x=0;y=16; /* HZK Metrix font test, includes Chinese and English*/ GrText(window, gc,x,y, "Microwindows,欢迎使用中英文点阵字体", -1, GR_TFASCII); #else GrText(window, gc,x,y, "Microwindows,舧ㄏノい璣ゅ翴皚砰", -1, GR_TFASCII); x=0;y=16*3+4; GrText(window, gc,x,y, "89:", -1, GR_TFASCII); #endif GrFlush(); #else /* !HZK_FONT_SUPPORT*/ #if HAVE_BIG5_SUPPORT /* ENCODING_BIG5 test*/ GrText(window, gc,x,y, "眃眃", -1, GR_TFASCII); #else #if HAVE_GB2312_SUPPORT /* ENCODING_GB2312 test*/ GrText(window, gc,x,y, "\275\241\275\241", -1, GR_TFASCII); #else /* ASCII test*/ GrText(window, gc,x,y, "Microwindows", -1, GR_TFASCII); #endif #endif #endif /* HZK_FONT_SUPPORT*/ GrDestroyFont(fontid); if(event.type == GR_EVENT_TYPE_CLOSE_REQ) { GrClose(); exit(0); } } GrDestroyRegion(regionid); GrClose(); }
int ui_loop(int argc,char **argv, const char *name) { GR_EVENT event; /* current event */ GR_IMAGE_ID id = 0; NGLXContext cx; int width, height, k; if (GrOpen() < 0) { fprintf(stderr, "cannot open graphics\n"); exit(1); } width = 400; height = 300; GrSetErrorHandler(errorcatcher); w1 = GrNewWindow(GR_ROOT_WINDOW_ID, 10, 10, width, height, 4, BLACK, WHITE); GrSelectEvents(w1, GR_EVENT_MASK_CLOSE_REQ|GR_EVENT_MASK_EXPOSURE|GR_EVENT_MASK_KEY_DOWN); GrMapWindow(w1); gc1 = GrNewGC(); GrSetGCForeground(gc1, WHITE); cx = nglXCreateContext(NULL, 0); nglXMakeCurrent(w1, cx); init(); reshape(width, height); while (1) { GrCheckNextEvent(&event); switch(event.type) { case GR_EVENT_TYPE_CLOSE_REQ: GrFreeImage(id); GrClose(); exit(0); case GR_EVENT_TYPE_EXPOSURE: break; case GR_EVENT_TYPE_KEY_DOWN: { GR_EVENT_KEYSTROKE *kp = &event.keystroke; /* XXX: nanoX special keys are totally bugged ! */ switch(kp->ch) { case 81: k = KEY_LEFT; break; case 83: k = KEY_RIGHT; break; case 82: k = KEY_UP; break; case 84: k = KEY_DOWN; break; default: k = kp->ch; break; } key(k, 0); } break; default: idle(); break; } } return 0; }
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); } GrReqShmCmds(655360); GrGetScreenInfo(&si); COLS = si.cols - 40; ROWS = si.rows - 80; /* print error, but don't exit*/ GrSetErrorHandler(errorcatcher); w1 = GrNewWindow(GR_ROOT_WINDOW_ID, 100, 50, COLS - 120, 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); 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); /* must select down and up for w2 to get implicit grab when * running window manager, otherwise the wm-created parent * window will get the grab, and we won't get the button up... */ GrSelectEvents(w2, GR_EVENT_MASK_BUTTON_DOWN | 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, 7, 3, 3, WHITE, BLACK, bitmap2fg, bitmap2bg); while (1) { GrCheckNextEvent(&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; } } }
void nxPaintNCArea(GR_DRAW_ID id, int w, int h, GR_CHAR *title, GR_BOOL active, GR_WM_PROPS props) { int x = 0; int y = 0; GR_GC_ID gc = GrNewGC(); GR_FONT_ID fontid; GR_RECT r; if (props & GR_WM_PROPS_APPFRAME) { /* draw 2-line 3d border around window*/ nxDraw3dOutset(id, x, y, w, h); x += 2; y += 2; w -= 4; h -= 4; /* draw 1-line inset inside border*/ GrSetGCForeground(gc, GrGetSysColor(GR_COLOR_APPWINDOW)); GrRect(id, gc, x, y, w, h); x += 1; y += 1; w -= 2; h -= 2; } else if (props & GR_WM_PROPS_BORDER) { /* draw 1-line black border around window*/ GrSetGCForeground(gc, GrGetSysColor(GR_COLOR_WINDOWFRAME)); GrRect(id, gc, x, y, w, h); x += 1; y += 1; w -= 2; h -= 2; } if (!(props & GR_WM_PROPS_CAPTION)) goto out; /* fill caption*/ GrSetGCForeground(gc, GrGetSysColor(active? GR_COLOR_ACTIVECAPTION: GR_COLOR_INACTIVECAPTION)); GrFillRect(id, gc, x, y, w, CYCAPTION); /* draw caption text*/ if (title) { GrSetGCForeground(gc, GrGetSysColor(active? GR_COLOR_ACTIVECAPTIONTEXT: GR_COLOR_INACTIVECAPTIONTEXT)); GrSetGCUseBackground(gc, GR_FALSE); fontid = GrCreateFont(GR_FONT_GUI_VAR, 0, NULL); GrSetGCFont(gc, fontid); GrText(id, gc, x+4, y-1, title, -1, GR_TFASCII|GR_TFTOP); GrDestroyFont(fontid); } y += CYCAPTION; /* draw one line under caption*/ if (props & GR_WM_PROPS_APPFRAME) { GrSetGCForeground(gc, GrGetSysColor(GR_COLOR_APPWINDOW)); GrLine(id, gc, x, y, x+w-1, y); } if (props & GR_WM_PROPS_CLOSEBOX) { /* draw close box*/ r.x = x + w - CXCLOSEBOX - 2; r.y = y - CYCAPTION + 2; r.width = CXCLOSEBOX; r.height = CYCLOSEBOX; nxDraw3dBox(id, r.x, r.y, r.width, r.height, GrGetSysColor(GR_COLOR_BTNHIGHLIGHT), GrGetSysColor(GR_COLOR_WINDOWFRAME)); nxInflateRect(&r, -1, -1); GrSetGCForeground(gc, GrGetSysColor(GR_COLOR_APPWINDOW)); GrFillRect(id, gc, r.x, r.y, r.width, r.height); nxInflateRect(&r, -1, -1); GrSetGCForeground(gc, GrGetSysColor(GR_COLOR_BTNTEXT)); GrLine(id, gc, r.x, r.y, r.x+r.width-1, r.y+r.height-1); GrLine(id, gc, r.x, r.y+r.height-1, r.x+r.width-1, r.y); } #if 0 /* fill in client area*/ y++; h -= CYCAPTION+1; GrSetGCForeground(gc, GrGetSysColor(GR_COLOR_APPWINDOW)); GrFillRect(id, gc, x, y, w, h); #endif out: GrDestroyGC(gc); }
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; }
/* * Demo to test child window movement and redrawing * * NOTE: THIS DEMO IS DEPRECATED AND IS NOT INDICATIVE OF * GOOD NANO-X PROGRAMMING. DON'T USE! */ 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; GR_GC_ID gc; 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_EXPOSURE | GR_EVENT_MASK_BUTTON_DOWN | 0); GrSelectEvents(GR_ROOT_WINDOW_ID, GR_EVENT_MASK_EXPOSURE); gc = GrNewGC(); GrSetGCForeground(gc, GREEN); 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 0 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); } } #endif 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: printf("expose %d\n", event.exposure.wid); GrFillRect(event.exposure.wid, gc, 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, "unhandled event type %d\n", event.type); } } GrClose(); }