int main (void)
{
if (GrOpen() < 0)
{
GrError("GrOpen failed");
return 1;
}
gc = GrNewGC();
GrSetGCUseBackground (gc, GR_FALSE);
GrSetGCForeground (gc, RED);
wid = GrNewWindowEx (GR_WM_PROPS_APPFRAME |
GR_WM_PROPS_CAPTION |
GR_WM_PROPS_CLOSEBOX,
"Hello Window",
GR_ROOT_WINDOW_ID,
50, 50, 200, 100, WHITE);
GrSelectEvents (wid, GR_EVENT_MASK_EXPOSURE |
GR_EVENT_MASK_CLOSE_REQ);
GrMapWindow (wid);
GrMainLoop (event_handler);
}
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;
}
}
}
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(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);
}
}
}
void ttk_gfx_init()
{
if (GrOpen() < 0) {
fprintf (stderr, "GrOpen() failed\n");
exit (1);
}
tmp_gc = GrNewGC();
GrSetGCUseBackground (tmp_gc, 0);
ttk_screen->srf = GrNewWindowEx (GR_WM_PROPS_APPFRAME |
GR_WM_PROPS_CAPTION |
GR_WM_PROPS_CLOSEBOX,
"TTK Program",
GR_ROOT_WINDOW_ID,
0, 0, ttk_screen->w, ttk_screen->h, ttk_makecol (WHITE));
GrSelectEvents (ttk_screen->srf, GR_EVENT_MASK_EXPOSURE |
GR_EVENT_MASK_CLOSE_REQ | GR_EVENT_MASK_KEY_UP |
GR_EVENT_MASK_KEY_DOWN | GR_EVENT_MASK_TIMER);
GrMapWindow (ttk_screen->srf);
gettimeofday (&tvstart, 0);
}
int
main(int ac, char **av)
{
GR_EVENT event; /* current event */
GR_BITMAP bitmap1fg[7]; /* bitmaps for first cursor */
GR_BITMAP bitmap1bg[7];
if (GrOpen() < 0) {
fprintf(stderr, "cannot open graphics\n");
exit(1);
}
/* create window*/
w1 = GrNewWindowEx(
GR_WM_PROPS_NOAUTOMOVE|GR_WM_PROPS_BORDER|GR_WM_PROPS_CAPTION|
GR_WM_PROPS_CLOSEBOX, "nxclock", GR_ROOT_WINDOW_ID,
10, 10, CWIDTH, CHEIGHT, GrGetSysColor(GR_COLOR_WINDOW));
GrSelectEvents(w1, GR_EVENT_MASK_EXPOSURE | GR_EVENT_MASK_CLOSE_REQ);
gc1 = GrNewGC();
gc2 = GrNewGC();
GrSetGCForeground(gc1, GrGetSysColor(GR_COLOR_WINDOW));
GrSetGCBackground(gc1, GrGetSysColor(GR_COLOR_WINDOWTEXT));
GrSetGCForeground(gc2, GrGetSysColor(GR_COLOR_WINDOWTEXT));
GrSetGCBackground(gc2, GrGetSysColor(GR_COLOR_WINDOW));
bitmap1bg[0] = MASK(_,_,X,X,X,_,_);
bitmap1bg[1] = MASK(_,X,X,X,X,X,_);
bitmap1bg[2] = MASK(X,X,X,X,X,X,X);
bitmap1bg[3] = MASK(X,X,X,X,X,X,X);
bitmap1bg[4] = MASK(X,X,X,X,X,X,X);
bitmap1bg[5] = MASK(_,X,X,X,X,X,_);
bitmap1bg[6] = MASK(_,_,X,X,X,_,_);
bitmap1fg[0] = MASK(_,_,_,X,_,_,_);
bitmap1fg[1] = MASK(_,X,_,X,_,X,_);
bitmap1fg[2] = MASK(_,_,_,X,_,_,_);
bitmap1fg[3] = MASK(X,_,_,X,X,_,X);
bitmap1fg[4] = MASK(_,_,_,_,_,_,_);
bitmap1fg[5] = MASK(_,X,_,_,_,X,_);
bitmap1fg[6] = MASK(_,_,_,X,_,_,_);
GrSetCursor(w1, 7, 7, 3, 3, WHITE, BLACK, bitmap1fg, bitmap1bg);
GrMapWindow(w1);
while (1) {
GrGetNextEventTimeout(&event, 500L);
switch (event.type) {
case GR_EVENT_TYPE_EXPOSURE:
do_exposure(&event.exposure);
break;
case GR_EVENT_TYPE_CLOSE_REQ:
GrClose();
exit(0);
case GR_EVENT_TYPE_TIMEOUT:
do_clock();
break;
}
}
}
int
main(int ac, char **av)
{
GR_WINDOW_ID window;
GR_GC_ID gc;
GR_FONT_ID fontid;
int x, y, fnum;
GR_REGION_ID regionid;
#if CLIP_POLYGON
GR_POINT points[] = { {20, 20}, {300, 20}, {300, 300}, {20, 300} };
#else
GR_RECT clip_rect = { 20, 20, 300, 300 };
#endif
if (GrOpen() < 0)
exit(1);
window = GrNewWindowEx(GR_WM_PROPS_APPWINDOW,
"t1demo loadable fonts (truetype, t1lib, pcf, mgl, hzk)",
GR_ROOT_WINDOW_ID, 50, 50, WIDTH, HEIGHT, BLACK);
GrSelectEvents(window, GR_EVENT_MASK_EXPOSURE | GR_EVENT_MASK_CLOSE_REQ);
GrMapWindow(window);
gc = GrNewGC();
GrSetGCUseBackground(gc, GR_FALSE);
GrSetGCBackground(gc, BLACK);
#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);
srand(time(0));
while (1) {
GR_EVENT event;
GrCheckNextEvent(&event);
if (event.type == GR_EVENT_TYPE_CLOSE_REQ) {
GrClose();
exit(0);
}
fontid = GrCreateFontEx(names[fnum=RAND(MAXFONTS)], 0, 0, NULL);
GrSetFontSizeEx(fontid, RAND(80) + 1, RAND(80) + 1);
GrSetFontRotation(fontid, 330); /* 33 degrees */
GrSetFontAttr(fontid, GR_TFKERNING | GR_TFANTIALIAS, 0);
GrSetGCFont(gc, fontid);
GrSetGCForeground(gc, rand() & 0xffffff);
/*GrSetGCBackground(gc, rand() & 0xffffff); */
x = RAND(WIDTH);
y = RAND(HEIGHT);
#if HAVE_HZK_SUPPORT
{
#if HZKBIG5
/* hzk big5 unicode-16 test*/
static unsigned short buffer[] = {
0x9060, 0x898b, 0x79d1, 0x6280, 0x0061, 0x0041, 0
};
GrText(window, gc, x, y, buffer, 7, GR_TFUC16);
/* hzk big5 dbcs test #1*/
x = RAND(WIDTH);
y = RAND(HEIGHT);
GrText(window, gc, x, y,
"Microwindows,Åwªï¨Ï¥Î¤¤^¤åÂI°}¦rÅé", -1, GR_TFASCII);
/* hzk big5 dbcs test #2*/
x = RAND(WIDTH);
y = RAND(HEIGHT);
GrText(window, gc, x, y, "£t£u£v£w£¸£¹£º", -1, GR_TFASCII);
#else
#if 0
/* hzk test #1*/
static char buffer[] = {
0x6c, 0x49, 0x73, 0x8b, 0x79,
0xd1, 0x62, 0x80, 0x61, 0x00,
0x41, 0x00, 0x00, 0xa1, 0x00,
0xa6, 0x6c, 0x49, 0, 0
};
/* *static unsigned short buffer[] = {
0x496c, 0x8b73, 0xd179, 0x8062, 0x0061,
0x0041, 0xa100, 0xa600, 0x496c, 0
};***/
GrText(window, gc, x, y, buffer, 9, GR_TFUC16);
#endif
/* HZK Metrix font test, includes Chinese and English */
x = RAND(WIDTH);
y = RAND(HEIGHT);
GrText(window, gc, x, y,
"Microwindows,»¶ÓʹÓÃÖÐÓ¢ÎĵãÕó×ÖÌå", -1, GR_TFASCII);
#endif /* HZKBIG5*/
}
#elif HAVE_BIG5_SUPPORT
/* encoding BIG5 test 61 B1 64 B1 64 61 */
GrText(window, gc, x, y, "\151\261\144\261\144\151", 6, MWTF_DBCS_BIG5);
#elif HAVE_GB2312_SUPPORT
/* encoding GB2312 test BD A1 BD A1 */
GrText(window, gc, x, y, "\275\241\275\241", 4, MWTF_DBCS_GB);
#elif HAVE_EUCJP_SUPPORT
/* encoding EUC_JP test A2 A1 */
GrText(window, gc, x, y, "ï¿½Þ¥ï¿½ï¿½ï¿½ï¿½í¥¦ï¿½ï¿½ï¿½ï¿½ï¿½É¥ï¿½ï¿½ï¿½ï¿½Ø¤è¤¦ï¿½ï¿½ï¿½ï¿½!", -1, MWTF_DBCS_EUCJP);
#elif HAVE_JISX0213_SUPPORT
/* encoding JISX0213 test A2 A1 */
GrText(window, gc, x, y, "\242\241", 2, MWTF_DBCS_JIS);
#elif HAVE_KSC5601_SUPPORT
/* encoding KSC5601 test B0 B0 */
GrText(window, gc, x, y, "\273\273", 2, MWTF_DBCS_EUCKR);
#elif HAVE_FREETYPE_2_SUPPORT
/* ASCII test */
GrText(window, gc, x, y, "Microwindows", -1, GR_TFASCII);
#elif HAVE_PCF_SUPPORT
/* note: large PCF fonts require XCHAR2B, this is not
figured out yet for these fonts. FIXME */
if (fnum == 3) {
/* japanese jiskan24*/
unsigned short text[] =
{ 0x213a, 0x213b, 0x2170, 0x2276, 0x2339 };
GrText(window, gc, x,y, text, 5, GR_TFUC16);
} else if (fnum == 4) {
/* chinese gb24st*/
unsigned short text[] =
/* FIXME: why doesn't first row index correctly?*/
/*{ 0x7765, 0x7766, 0x7767, 0x777a, 0x777e };*/
{ 0x2129, 0x212a, 0x212b, 0x212c, 0x212d };
GrText(window, gc, x,y, text, 5, GR_TFUC16);
} else
GrText(window, gc, x,y, "Microwindows", -1, GR_TFASCII);
#elif HAVE_FNT_SUPPORT
/* UC16 test */
if (fnum == 2 || fnum == 3) {
/* japanese jiskan24, jiskan16-2000-1*/
unsigned short text[] =
{ 0x213a, 0x213b, 0x2170, 0x2276, 0x2339 };
GrText(window, gc, x,y, text, 5, GR_TFUC16);
} else if (fnum == 4) {
/* chinese gbk16-xke*/
unsigned short text[] =
{ 0x8144, 0x8147, 0x8148, 0xfe4e, 0xfe4f };
GrText(window, gc, x,y, text, 5, GR_TFUC16);
} else
GrText(window, gc, x,y, "Microwindows", -1, GR_TFASCII);
#else
/* ASCII test */
GrText(window, gc, x, y, "Microwindows", -1, GR_TFASCII);
#endif
GrFlush();
GrDestroyFont(fontid);
}
GrDestroyRegion(regionid);
GrClose();
return 0;
}
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 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)
{
GR_WINDOW_ID main_wid;
GR_TIMEOUT timeout;
int width, height;
if (argc != 2)
return (-1);
if (GrOpen() == -1)
return (-1);
font = GrCreateFontEx(argv[1], 12, 12, 0);
if (!font)
printf("Unable to load %s\n", argv[1]);
GrGetFontInfo(font, &finfo);
printf("font_id = %d\n", font);
printf("First char = %d, last char = %d\n", finfo.firstchar, finfo.lastchar);
printf("Max width = %d, max height = %d\n", finfo.maxwidth, finfo.height);
printf("baseline = ascent = %d, descent = %d\n", finfo.baseline, finfo.descent);
printf("max ascent = %d, max descent = %d\n", finfo.maxascent, finfo.maxdescent);
printf("linespacing = %d, fixed = %s\n", finfo.linespacing, finfo.fixed? "yes": "no");
// finfo.firstchar = 0; /* force display of undefined chars, test with jiskan24.pcf.gz*/
/* determine window metrics*/
width = (finfo.maxwidth + spacer) * line_width + 2 * border - spacer;
if (width > 640) {
line_width /= 2;
lines *= 2;
width = (finfo.maxwidth + 2) * line_width + 2 * border - spacer;
}
height = lines * (finfo.height + spacer) + 2 * border - spacer;
chars_to_show = lines * line_width;
/* create the main application window*/
main_wid = GrNewWindowEx(GR_WM_PROPS_APPWINDOW, "pcfdemo",
GR_ROOT_WINDOW_ID, 0, 0, width, height, BLACK);
GrSelectEvents(main_wid, GR_EVENT_MASK_EXPOSURE|GR_EVENT_MASK_CLOSE_REQ);
GrMapWindow(main_wid);
if (finfo.lastchar >= chars_to_show)
timeout = 8 * 1000;
else timeout = 0;
while (1) {
GR_EVENT event;
GrGetNextEventTimeout(&event, timeout);
if (event.type == GR_EVENT_TYPE_TIMEOUT) {
first_char += chars_to_show;
draw_string(main_wid);
}
if (event.type == GR_EVENT_TYPE_EXPOSURE)
draw_string(main_wid);
if(event.type == GR_EVENT_TYPE_CLOSE_REQ) {
GrClose();
exit(0);
}
}
}
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;
}
